骨骼动画实现逻辑

牛掰是怎么形成的

于 2024-09-09 22:36:08 发布

阅读量674

点赞数 9

分类专栏： FPS射击游戏技术专栏文章标签：游戏

本文链接：https://blog.csdn.net/qq_33060405/article/details/142071162

版权

FPS射击游戏技术专栏专栏收录该内容

12 篇文章 0 订阅

订阅专栏

骨骼动画（Skeletal Animation）是一种常用于3D计算机图形学中的动画技术，特别是在角色动画中。它通过使用骨骼（骨架）来控制网格（Mesh）的变形，从而实现复杂的动画效果。以下是骨骼动画的实现逻辑，包括基本概念、数据结构和实现步骤。

基本概念

骨骼（Skeleton）: 由一系列骨骼（Bones）组成，每个骨骼都有一个父骨骼和若干子骨骼，形成一个层次结构。
关节（Joint）: 骨骼之间的连接点，通常用于定义骨骼的旋转和变换。
权重（Weight）: 每个顶点在不同骨骼上的影响程度，通常用权重值表示。
绑定姿态（Bind Pose）: 初始姿态，表示模型在未变形状态下的骨骼和顶点位置。

数据结构

骨骼结构

struct Bone
{
    std::string name;          // 骨骼名称
    int parentIndex;           // 父骨骼索引
    glm::mat4 bindPose;        // 绑定姿态矩阵
    glm::mat4 inverseBindPose; // 绑定姿态的逆矩阵
    glm::mat4 currentTransform;// 当前变换矩阵
};

顶点权重

struct VertexWeight
{
    int boneIndex; // 骨骼索引
    float weight;  // 权重值
};

顶点数据

struct Vertex
{
    glm::vec3 position;             // 顶点位置
    glm::vec3 normal;               // 顶点法线
    std::vector<VertexWeight> weights; // 顶点权重
};

实现步骤

1. 加载骨骼和动画数据

首先，需要从文件中加载骨骼和动画数据。常见的文件格式包括FBX、Collada等。可以使用Assimp库来简化这一过程。

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

void LoadSkeleton(const std::string& filePath, std::vector<Bone>& bones)
{
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || !scene->mRootNode)
    {
        std::cerr << "Failed to load file: " << filePath << std::endl;
        return;
    }

    // 递归加载骨骼
    LoadBones(scene->mRootNode, -1, bones);
}

void LoadBones(aiNode* node, int parentIndex, std::vector<Bone>& bones)
{
    Bone bone;
    bone.name = node->mName.C_Str();
    bone.parentIndex = parentIndex;
    bone.bindPose = aiMatrix4x4ToGlm(node->mTransformation);
    bone.inverseBindPose = glm::inverse(bone.bindPose);
    bones.push_back(bone);

    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
        LoadBones(node->mChildren[i], bones.size() - 1, bones);
    }
}

2. 计算骨骼变换矩阵

在每一帧中，需要根据动画数据计算每个骨骼的变换矩阵。

void CalculateBoneTransforms(const std::vector<Bone>& bones, const std::vector<Animation>& animations, float time, std::vector<glm::mat4>& boneTransforms)
{
    for (size_t i = 0; i < bones.size(); ++i)
    {
        glm::mat4 transform = CalculateBoneTransform(bones[i], animations, time);
        if (bones[i].parentIndex != -1)
        {
            transform = boneTransforms[bones[i].parentIndex] * transform;
        }
        boneTransforms[i] = transform;
    }
}

glm::mat4 CalculateBoneTransform(const Bone& bone, const std::vector<Animation>& animations, float time)
{
    // 根据动画数据计算骨骼的变换矩阵
    // 这里省略具体实现，通常包括插值计算等
    return glm::mat4(1.0f);
}

好的，让我们继续探讨如何将计算得到的骨骼变换应用到顶点上，从而实现骨骼动画的最终效果。

3. 应用骨骼变换到顶点

在每一帧中，计算得到的骨骼变换矩阵需要应用到网格的顶点上，以实现动画效果。具体步骤如下：

计算每个顶点的变换矩阵：根据顶点的权重和对应骨骼的变换矩阵，计算每个顶点的最终变换矩阵。
应用变换矩阵：将变换矩阵应用到顶点的位置和法线。

计算顶点的变换矩阵

每个顶点的变换矩阵是其受影响的所有骨骼变换矩阵的加权和。假设一个顶点受多个骨骼影响，每个骨骼的影响程度由权重值表示。

glm::mat4 CalculateVertexTransform(const Vertex& vertex, const std::vector<glm::mat4>& boneTransforms)
{
    glm::mat4 vertexTransform = glm::mat4(0.0f);

    for (const auto& weight : vertex.weights)
    {
        int boneIndex = weight.boneIndex;
        float boneWeight = weight.weight;
        vertexTransform += boneWeight * boneTransforms[boneIndex];
    }

    return vertexTransform;
}

应用变换矩阵到顶点

将计算得到的变换矩阵应用到顶点的位置和法线。

void ApplyBoneTransforms(std::vector<Vertex>& vertices, const std::vector<glm::mat4>& boneTransforms)
{
    for (auto& vertex : vertices)
    {
        glm::mat4 vertexTransform = CalculateVertexTransform(vertex, boneTransforms);

        // 变换顶点位置
        glm::vec4 transformedPosition = vertexTransform * glm::vec4(vertex.position, 1.0f);
        vertex.position = glm::vec3(transformedPosition);

        // 变换顶点法线
        glm::vec4 transformedNormal = vertexTransform * glm::vec4(vertex.normal, 0.0f);
        vertex.normal = glm::normalize(glm::vec3(transformedNormal));
    }
}

4. 渲染

在渲染阶段，使用变换后的顶点数据进行绘制。通常，骨骼动画的渲染会在顶点着色器中进行，以提高性能。

顶点着色器

在顶点着色器中，可以直接使用骨骼变换矩阵对顶点进行变换。以下是一个简单的GLSL顶点着色器示例：

#version 330 core

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec4 inBoneWeights;
layout(location = 3) in ivec4 inBoneIndices;

uniform mat4 boneTransforms[100]; // 假设最多有100个骨骼
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 fragNormal;

void main()
{
    mat4 boneTransform = mat4(0.0);
    for (int i = 0; i < 4; ++i)
    {
        boneTransform += inBoneWeights[i] * boneTransforms[inBoneIndices[i]];
    }

    vec4 transformedPosition = boneTransform * vec4(inPosition, 1.0);
    vec4 transformedNormal = boneTransform * vec4(inNormal, 0.0);

    fragNormal = normalize(vec3(transformedNormal));

    gl_Position = projection * view * model * transformedPosition;
}

5. 动画插值

为了实现平滑的动画效果，通常需要对动画关键帧进行插值计算。常见的插值方法包括线性插值（Linear Interpolation）和球面线性插值（Spherical Linear Interpolation, Slerp）。

线性插值

glm::vec3 Lerp(const glm::vec3& start, const glm::vec3& end, float t)
{
    return start + t * (end - start);
}

glm::quat Slerp(const glm::quat& start, const glm::quat& end, float t)
{
    return glm::slerp(start, end, t);
}

好的，让我们继续探讨如何计算插值后的变换矩阵，并将其应用到骨骼动画中。

计算插值后的变换矩阵

在骨骼动画中，通常需要对关键帧进行插值，以获得在任意时间点的骨骼变换矩阵。以下是一个示例，展示如何计算插值后的变换矩阵。

关键帧数据结构

首先，我们需要定义关键帧的数据结构。每个关键帧包含时间戳、位置、旋转和缩放信息。

struct KeyFrame
{
    float timeStamp;       // 时间戳
    glm::vec3 position;    // 位置
    glm::quat rotation;    // 旋转
    glm::vec3 scale;       // 缩放
};

struct Animation
{
    std::vector<KeyFrame> keyFrames; // 关键帧列表
};

查找插值关键帧

在给定时间点，找到前后两个关键帧，以便进行插值计算。

void FindInterpolationFrames(const Animation& animation, float time, KeyFrame& outStartFrame, KeyFrame& outEndFrame)
{
    for (size_t i = 0; i < animation.keyFrames.size() - 1; ++i)
    {
        if (time >= animation.keyFrames[i].timeStamp && time <= animation.keyFrames[i + 1].timeStamp)
        {
            outStartFrame = animation.keyFrames[i];
            outEndFrame = animation.keyFrames[i + 1];
            return;
        }
    }

    // 如果时间超出范围，返回最后一个关键帧
    outStartFrame = animation.keyFrames.back();
    outEndFrame = animation.keyFrames.back();
}

计算插值后的变换矩阵

使用线性插值（Lerp）和球面线性插值（Slerp）计算插值后的变换矩阵。

glm::mat4 CalculateInterpolatedTransform(const Bone& bone, const Animation& animation, float time)
{
    KeyFrame startFrame, endFrame;
    FindInterpolationFrames(animation, time, startFrame, endFrame);

    float deltaTime = endFrame.timeStamp - startFrame.timeStamp;
    float factor = (time - startFrame.timeStamp) / deltaTime;

    glm::vec3 interpolatedPosition = Lerp(startFrame.position, endFrame.position, factor);
    glm::quat interpolatedRotation = Slerp(startFrame.rotation, endFrame.rotation, factor);
    glm::vec3 interpolatedScale = Lerp(startFrame.scale, endFrame.scale, factor);

    glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), interpolatedPosition);
    glm::mat4 rotationMatrix = glm::toMat4(interpolatedRotation);
    glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), interpolatedScale);

    return translationMatrix * rotationMatrix * scaleMatrix;
}

完整的骨骼动画实现流程

加载骨骼和动画数据：从文件中加载骨骼和动画数据。
计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。
应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到网格的顶点上。
渲染：使用变换后的顶点数据进行绘制。

以下是一个完整的示例，展示如何实现骨骼动画：

#include <iostream>
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

// 数据结构定义
struct Bone
{
    std::string name;
    int parentIndex;
    glm::mat4 bindPose;
    glm::mat4 inverseBindPose;
    glm::mat4 currentTransform;
};

struct VertexWeight
{
    int boneIndex;
    float weight;
};

struct Vertex
{
    glm::vec3 position;
    glm::vec3 normal;
    std::vector<VertexWeight> weights;
};

struct KeyFrame
{
    float timeStamp;
    glm::vec3 position;
    glm::quat rotation;
    glm::vec3 scale;
};

struct Animation
{
    std::vector<KeyFrame> keyFrames;
};

好的，让我们继续完成骨骼动画的实现流程。

### 加载骨骼和动画数据

首先，我们需要从文件中加载骨骼和动画数据。这里我们使用Assimp库来简化这一过程。

```cpp
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

// 递归加载骨骼
void LoadBones(aiNode* node, int parentIndex, std::vector<Bone>& bones)
{
    Bone bone;
    bone.name = node->mName.C_Str();
    bone.parentIndex = parentIndex;
    bone.bindPose = aiMatrix4x4ToGlm(node->mTransformation);
    bone.inverseBindPose = glm::inverse(bone.bindPose);
    bones.push_back(bone);

    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
        LoadBones(node->mChildren[i], bones.size() - 1, bones);
    }
}

void LoadSkeleton(const std::string& filePath, std::vector<Bone>& bones)
{
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || !scene->mRootNode)
    {
        std::cerr << "Failed to load file: " << filePath << std::endl;
        return;
    }

    LoadBones(scene->mRootNode, -1, bones);
}

// 辅助函数：将Assimp的aiMatrix4x4转换为GLM的mat4
glm::mat4 aiMatrix4x4ToGlm(const aiMatrix4x4& from)
{
    glm::mat4 to;
    to[0][0] = from.a1; to[0][1] = from.b1; to[0][2] = from.c1; to[0][3] = from.d1;
    to[1][0] = from.a2; to[1][1] = from.b2; to[1][2] = from.c2; to[1][3] = from.d2;
    to[2][0] = from.a3; to[2][1] = from.b3; to[2][2] = from.c3; to[2][3] = from.d3;
    to[3][0] = from.a4; to[3][1] = from.b4; to[3][2] = from.c4; to[3][3] = from.d4;
    return to;
}

计算骨骼变换矩阵

在每一帧中，根据动画数据计算每个骨骼的变换矩阵。

void CalculateBoneTransforms(const std::vector<Bone>& bones, const std::vector<Animation>& animations, float time, std::vector<glm::mat4>& boneTransforms)
{
    for (size_t i = 0; i < bones.size(); ++i)
    {
        glm::mat4 transform = CalculateInterpolatedTransform(bones[i], animations[i], time);
        if (bones[i].parentIndex != -1)
        {
            transform = boneTransforms[bones[i].parentIndex] * transform;
        }
        boneTransforms[i] = transform;
    }
}

glm::mat4 CalculateInterpolatedTransform(const Bone& bone, const Animation& animation, float time)
{
    KeyFrame startFrame, endFrame;
    FindInterpolationFrames(animation, time, startFrame, endFrame);

    float deltaTime = endFrame.timeStamp - startFrame.timeStamp;
    float factor = (time - startFrame.timeStamp) / deltaTime;

    glm::vec3 interpolatedPosition = Lerp(startFrame.position, endFrame.position, factor);
    glm::quat interpolatedRotation = Slerp(startFrame.rotation, endFrame.rotation, factor);
    glm::vec3 interpolatedScale = Lerp(startFrame.scale, endFrame.scale, factor);

    glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), interpolatedPosition);
    glm::mat4 rotationMatrix = glm::toMat4(interpolatedRotation);
    glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), interpolatedScale);

    return translationMatrix * rotationMatrix * scaleMatrix;
}

好的，让我们继续完成应用骨骼变换到顶点的部分，并总结整个骨骼动画的实现流程。

应用骨骼变换到顶点（续）

将计算得到的骨骼变换矩阵应用到网格的顶点上。

void ApplyBoneTransforms(std::vector<Vertex>& vertices, const std::vector<glm::mat4>& boneTransforms)
{
    for (auto& vertex : vertices)
    {
        glm::mat4 vertexTransform = CalculateVertexTransform(vertex, boneTransforms);

        // 变换顶点位置
        glm::vec4 transformedPosition = vertexTransform * glm::vec4(vertex.position, 1.0f);
        vertex.position = glm::vec3(transformedPosition);

        // 变换顶点法线
        glm::vec4 transformedNormal = vertexTransform * glm::vec4(vertex.normal, 0.0f);
        vertex.normal = glm::normalize(glm::vec3(transformedNormal));
    }
}

glm::mat4 CalculateVertexTransform(const Vertex& vertex, const std::vector<glm::mat4>& boneTransforms)
{
    glm::mat4 vertexTransform = glm::mat4(0.0f);

    for (const auto& weight : vertex.weights)
    {
        int boneIndex = weight.boneIndex;
        float boneWeight = weight.weight;
        vertexTransform += boneWeight * boneTransforms[boneIndex];
    }

    return vertexTransform;
}

渲染

在渲染阶段，使用变换后的顶点数据进行绘制。通常，骨骼动画的渲染会在顶点着色器中进行，以提高性能。

顶点着色器

在顶点着色器中，可以直接使用骨骼变换矩阵对顶点进行变换。以下是一个简单的GLSL顶点着色器示例：

#version 330 core

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec4 inBoneWeights;
layout(location = 3) in ivec4 inBoneIndices;

uniform mat4 boneTransforms[100]; // 假设最多有100个骨骼
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 fragNormal;

void main()
{
    mat4 boneTransform = mat4(0.0);
    for (int i = 0; i < 4; ++i)
    {
        boneTransform += inBoneWeights[i] * boneTransforms[inBoneIndices[i]];
    }

    vec4 transformedPosition = boneTransform * vec4(inPosition, 1.0);
    vec4 transformedNormal = boneTransform * vec4(inNormal, 0.0);

    fragNormal = normalize(vec3(transformedNormal));

    gl_Position = projection * view * model * transformedPosition;
}

完整的骨骼动画实现流程

加载骨骼和动画数据：从文件中加载骨骼和动画数据。
计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。
应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到网格的顶点上。
渲染：使用变换后的顶点数据进行绘制。

以下是一个完整的示例，展示如何实现骨骼动画：

#include <iostream>
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

// 数据结构定义
struct Bone
{
    std::string name;
    int parentIndex;
    glm::mat4 bindPose;
    glm::mat4 inverseBindPose;
    glm::mat4 currentTransform;
};

struct VertexWeight
{
    int boneIndex;
    float weight;
};

struct Vertex
{
    glm::vec3 position;
    glm::vec3 normal;
    std::vector<VertexWeight> weights;
};

struct KeyFrame
{
    float timeStamp;
    glm::vec3 position;
    glm::quat rotation;
    glm::vec3 scale;
};

struct Animation
{
    std::vector<KeyFrame> keyFrames;
};

好的，让我们继续完成加载骨骼和动画数据的部分，并总结整个骨骼动画的实现流程。

### 加载骨骼和动画数据（续）

```cpp
void LoadBones(aiNode* node, int parentIndex, std::vector<Bone>& bones)
{
    Bone bone;
    bone.name = node->mName.C_Str();
    bone.parentIndex = parentIndex;
    bone.bindPose = aiMatrix4x4ToGlm(node->mTransformation);
    bone.inverseBindPose = glm::inverse(bone.bindPose);
    bones.push_back(bone);

    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
        LoadBones(node->mChildren[i], bones.size() - 1, bones);
    }
}

void LoadSkeleton(const std::string& filePath, std::vector<Bone>& bones)
{
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || !scene->mRootNode)
    {
        std::cerr << "Failed to load file: " << filePath << std::endl;
        return;
    }

    LoadBones(scene->mRootNode, -1, bones);
}

// 辅助函数：将Assimp的aiMatrix4x4转换为GLM的mat4
glm::mat4 aiMatrix4x4ToGlm(const aiMatrix4x4& from)
{
    glm::mat4 to;
    to[0][0] = from.a1; to[0][1] = from.b1; to[0][2] = from.c1; to[0][3] = from.d1;
    to[1][0] = from.a2; to[1][1] = from.b2; to[1][2] = from.c2; to[1][3] = from.d2;
    to[2][0] = from.a3; to[2][1] = from.b3; to[2][2] = from.c3; to[2][3] = from.d3;
    to[3][0] = from.a4; to[3][1] = from.b4; to[3][2] = from.c4; to[3][3] = from.d4;
    return to;
}

计算骨骼变换矩阵

在每一帧中，根据动画数据计算每个骨骼的变换矩阵。

void CalculateBoneTransforms(const std::vector<Bone>& bones, const std::vector<Animation>& animations, float time, std::vector<glm::mat4>& boneTransforms)
{
    for (size_t i = 0; i < bones.size(); ++i)
    {
        glm::mat4 transform = CalculateInterpolatedTransform(bones[i], animations[i], time);
        if (bones[i].parentIndex != -1)
        {
            transform = boneTransforms[bones[i].parentIndex] * transform;
        }
        boneTransforms[i] = transform;
    }
}

glm::mat4 CalculateInterpolatedTransform(const Bone& bone, const Animation& animation, float time)
{
    KeyFrame startFrame, endFrame;
    FindInterpolationFrames(animation, time, startFrame, endFrame);

    float deltaTime = endFrame.timeStamp - startFrame.timeStamp;
    float factor = (time - startFrame.timeStamp) / deltaTime;

    glm::vec3 interpolatedPosition = Lerp(startFrame.position, endFrame.position, factor);
    glm::quat interpolatedRotation = Slerp(startFrame.rotation, endFrame.rotation, factor);
    glm::vec3 interpolatedScale = Lerp(startFrame.scale, endFrame.scale, factor);

    glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), interpolatedPosition);
    glm::mat4 rotationMatrix = glm::toMat4(interpolatedRotation);
    glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), interpolatedScale);

    return translationMatrix * rotationMatrix * scaleMatrix;
}

应用骨骼变换到顶点

将计算得到的骨骼变换矩阵应用到网格的顶点上。

void ApplyBoneTransforms(std::vector<Vertex>& vertices, const std::vector<glm::mat4>& boneTransforms)
{
    for (auto& vertex : vertices)
    {
        glm::mat4 vertexTransform = CalculateVertexTransform(vertex, boneTransforms);

        // 变换顶点位置
        glm::vec4 transformedPosition = vertexTransform * glm::vec4好的，让我们继续完成应用骨骼变换到顶点的部分，并总结整个骨骼动画的实现流程。

### 应用骨骼变换到顶点（续）

```cpp
        // 变换顶点位置
        glm::vec4 transformedPosition = vertexTransform * glm::vec4(vertex.position, 1.0f);
        vertex.position = glm::vec3(transformedPosition);

        // 变换顶点法线
        glm::vec4 transformedNormal = vertexTransform * glm::vec4(vertex.normal, 0.0f);
        vertex.normal = glm::normalize(glm::vec3(transformedNormal));
    }
}

glm::mat4 CalculateVertexTransform(const Vertex& vertex, const std::vector<glm::mat4>& boneTransforms)
{
    glm::mat4 vertexTransform = glm::mat4(0.0f);

    for (const auto& weight : vertex.weights)
    {
        int boneIndex = weight.boneIndex;
        float boneWeight = weight.weight;
        vertexTransform += boneWeight * boneTransforms[boneIndex];
    }

    return vertexTransform;
}

渲染

在渲染阶段，使用变换后的顶点数据进行绘制。通常，骨骼动画的渲染会在顶点着色器中进行，以提高性能。

顶点着色器

在顶点着色器中，可以直接使用骨骼变换矩阵对顶点进行变换。以下是一个简单的GLSL顶点着色器示例：

#version 330 core

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec4 inBoneWeights;
layout(location = 3) in ivec4 inBoneIndices;

uniform mat4 boneTransforms[100]; // 假设最多有100个骨骼
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 fragNormal;

void main()
{
    mat4 boneTransform = mat4(0.0);
    for (int i = 0; i < 4; ++i)
    {
        boneTransform += inBoneWeights[i] * boneTransforms[inBoneIndices[i]];
    }

    vec4 transformedPosition = boneTransform * vec4(inPosition, 1.0);
    vec4 transformedNormal = boneTransform * vec4(inNormal, 0.0);

    fragNormal = normalize(vec3(transformedNormal));

    gl_Position = projection * view * model * transformedPosition;
}

完整的骨骼动画实现流程

加载骨骼和动画数据：从文件中加载骨骼和动画数据。
计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。
应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到网格的顶点上。
渲染：使用变换后的顶点数据进行绘制。

以下是一个完整的示例，展示如何实现骨骼动画：

#include <iostream>
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

// 数据结构定义
struct Bone
{
    std::string name;
    int parentIndex;
    glm::mat4 bindPose;
    glm::mat4 inverseBindPose;
    glm::mat4 currentTransform;
};

struct VertexWeight
{
    int boneIndex;
    float weight;
};

struct Vertex
{
    glm::vec3 position;
    glm::vec3 normal;
    std::vector<VertexWeight> weights;
};

struct KeyFrame
{
    float timeStamp;
    glm::vec3 position;
    glm::quat rotation;
    glm::vec3 scale;
};

struct Animation
{
    std::vector<KeyFrame> keyFrames;
};

// 加载骨骼和动画数据
void LoadBones(aiNode* node, int parentIndex, std::vector<Bone>& bones)
{
    Bone bone;
    bone.name = node->mName.C_Str();
    bone.parentIndex = parentIndex;
    bone.bindPose = aiMatrix4x4ToGlm(node->mTransformation);
    bone.inverseBindPose = glm::inverse(bone.bindPose);
    bones.push_back(bone);

    for (unsigned int i = 0; i好的，让我们继续完成加载骨骼和动画数据的部分，并总结整个骨骼动画的实现流程。

### 加载骨骼和动画数据（续）

```cpp
    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
        LoadBones(node->mChildren[i], bones.size() - 1, bones);
    }
}

void LoadSkeleton(const std::string& filePath, std::vector<Bone>& bones)
{
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || !scene->mRootNode)
    {
        std::cerr << "Failed to load file: " << filePath << std::endl;
        return;
    }

    LoadBones(scene->mRootNode, -1, bones);
}

// 辅助函数：将Assimp的aiMatrix4x4转换为GLM的mat4
glm::mat4 aiMatrix4x4ToGlm(const aiMatrix4x4& from)
{
    glm::mat4 to;
    to[0][0] = from.a1; to[0][1] = from.b1; to[0][2] = from.c1; to[0][3] = from.d1;
    to[1][0] = from.a2; to[1][1] = from.b2; to[1][2] = from.c2; to[1][3] = from.d2;
    to[2][0] = from.a3; to[2][1] = from.b3; to[2][2] = from.c3; to[2][3] = from.d3;
    to[3][0] = from.a4; to[3][1] = from.b4; to[3][2] = from.c4; to[3][3] = from.d4;
    return to;
}

计算骨骼变换矩阵

在每一帧中，根据动画数据计算每个骨骼的变换矩阵。

void CalculateBoneTransforms(const std::vector<Bone>& bones, const std::vector<Animation>& animations, float time, std::vector<glm::mat4>& boneTransforms)
{
    for (size_t i = 0; i < bones.size(); ++i)
    {
        glm::mat4 transform = CalculateInterpolatedTransform(bones[i], animations[i], time);
        if (bones[i].parentIndex != -1)
        {
            transform = boneTransforms[bones[i].parentIndex] * transform;
        }
        boneTransforms[i] = transform;
    }
}

glm::mat4 CalculateInterpolatedTransform(const Bone& bone, const Animation& animation, float time)
{
    KeyFrame startFrame, endFrame;
    FindInterpolationFrames(animation, time, startFrame, endFrame);

    float deltaTime = endFrame.timeStamp - startFrame.timeStamp;
    float factor = (time - startFrame.timeStamp) / deltaTime;

    glm::vec3 interpolatedPosition = Lerp(startFrame.position, endFrame.position, factor);
    glm::quat interpolatedRotation = Slerp(startFrame.rotation, endFrame.rotation, factor);
    glm::vec3 interpolatedScale = Lerp(startFrame.scale, endFrame.scale, factor);

    glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), interpolatedPosition);
    glm::mat4 rotationMatrix = glm::toMat4(interpolatedRotation);
    glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), interpolatedScale);

    return translationMatrix * rotationMatrix * scaleMatrix;
}

void FindInterpolationFrames(const Animation& animation, float time, KeyFrame& startFrame, KeyFrame& endFrame)
{
    for (size_t i = 0; i < animation.keyFrames.size() - 1; ++i)
    {
        if (time >= animation.keyFrames[i].timeStamp && time <= animation.keyFrames[i + 1].timeStamp)
        {
            startFrame = animation.keyFrames[i];
            endFrame = animation.keyFrames[i + 1];
            return;
        }
    }

    // 如果没有找到合适的帧，默认返回第一个和最后一个帧
    startFrame = animation.keyFrames.front();
    endFrame = animation.keyFrames.back();
}

glm::vec3 Lerp(const glm::vec3& start, const glm::vec3& end, float factor)
{
    return start + factor * (end - start);
}

好的，让我们继续完成骨骼动画的实现流程。

### 计算骨骼变换矩阵（续）

```cpp
glm::quat Slerp(const glm::quat& start, const glm::quat& end, float factor)
{
    return glm::slerp(start, end, factor);
}

应用骨骼变换到顶点

将计算得到的骨骼变换矩阵应用到网格的顶点上。

void ApplyBoneTransforms(std::vector<Vertex>& vertices, const std::vector<glm::mat4>& boneTransforms)
{
    for (auto& vertex : vertices)
    {
        glm::mat4 vertexTransform = CalculateVertexTransform(vertex, boneTransforms);

        // 变换顶点位置
        glm::vec4 transformedPosition = vertexTransform * glm::vec4(vertex.position, 1.0f);
        vertex.position = glm::vec3(transformedPosition);

        // 变换顶点法线
        glm::vec4 transformedNormal = vertexTransform * glm::vec4(vertex.normal, 0.0f);
        vertex.normal = glm::normalize(glm::vec3(transformedNormal));
    }
}

glm::mat4 CalculateVertexTransform(const Vertex& vertex, const std::vector<glm::mat4>& boneTransforms)
{
    glm::mat4 vertexTransform = glm::mat4(0.0f);

    for (const auto& weight : vertex.weights)
    {
        int boneIndex = weight.boneIndex;
        float boneWeight = weight.weight;
        vertexTransform += boneWeight * boneTransforms[boneIndex];
    }

    return vertexTransform;
}

渲染

在渲染阶段，使用变换后的顶点数据进行绘制。通常，骨骼动画的渲染会在顶点着色器中进行，以提高性能。

顶点着色器

在顶点着色器中，可以直接使用骨骼变换矩阵对顶点进行变换。以下是一个简单的GLSL顶点着色器示例：

#version 330 core

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec4 inBoneWeights;
layout(location = 3) in ivec4 inBoneIndices;

uniform mat4 boneTransforms[100]; // 假设最多有100个骨骼
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 fragNormal;

void main()
{
    mat4 boneTransform = mat4(0.0);
    for (int i = 0; i < 4; ++i)
    {
        boneTransform += inBoneWeights[i] * boneTransforms[inBoneIndices[i]];
    }

    vec4 transformedPosition = boneTransform * vec4(inPosition, 1.0);
    vec4 transformedNormal = boneTransform * vec4(inNormal, 0.0);

    fragNormal = normalize(vec3(transformedNormal));

    gl_Position = projection * view * model * transformedPosition;
}

完整的骨骼动画实现流程

加载骨骼和动画数据：从文件中加载骨骼和动画数据。
计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。
应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到网格的顶点上。
渲染：使用变换后的顶点数据进行绘制。

以下是一个完整的示例，展示如何实现骨骼动画：

#include <iostream>
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

// 数据结构定义
struct Bone
{
    std::string name;
    int parentIndex;
    glm::mat4 bindPose;
    glm::mat4 inverseBindPose;
    glm::mat4 currentTransform;
};

struct VertexWeight
{
    int boneIndex;
    float weight;
};

struct Vertex
{
    glm::vec3 position;
    glm::vec3 normal;
    std::vector<VertexWeight> weights;
};

struct KeyFrame
{
    float timeStamp;
    glm::vec3 position;
    glm::quat rotation;
    glm::vec3 scale;
};

好的，让我们继续完成完整的骨骼动画实现示例。

### 完整的骨骼动画实现流程（续）

```cpp
struct Animation
{
    std::vector<KeyFrame> keyFrames;
};

// 加载骨骼和动画数据
void LoadBones(aiNode* node, int parentIndex, std::vector<Bone>& bones)
{
    Bone bone;
    bone.name = node->mName.C_Str();
    bone.parentIndex = parentIndex;
    bone.bindPose = aiMatrix4x4ToGlm(node->mTransformation);
    bone.inverseBindPose = glm::inverse(bone.bindPose);
    bones.push_back(bone);

    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
        LoadBones(node->mChildren[i], bones.size() - 1, bones);
    }
}

void LoadSkeleton(const std::string& filePath, std::vector<Bone>& bones)
{
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(filePath, aiProcess_Triangulate | aiProcess_FlipUVs);

    if (!scene || !scene->mRootNode)
    {
        std::cerr << "Failed to load file: " << filePath << std::endl;
        return;
    }

    LoadBones(scene->mRootNode, -1, bones);
}

// 辅助函数：将Assimp的aiMatrix4x4转换为GLM的mat4
glm::mat4 aiMatrix4x4ToGlm(const aiMatrix4x4& from)
{
    glm::mat4 to;
    to[0][0] = from.a1; to[0][1] = from.b1; to[0][2] = from.c1; to[0][3] = from.d1;
    to[1][0] = from.a2; to[1][1] = from.b2; to[1][2] = from.c2; to[1][3] = from.d2;
    to[2][0] = from.a3; to[2][1] = from.b3; to[2][2] = from.c3; to[2][3] = from.d3;
    to[3][0] = from.a4; to[3][1] = from.b4; to[3][2] = from.c4; to[3][3] = from.d4;
    return to;
}

// 计算骨骼变换矩阵
void CalculateBoneTransforms(const std::vector<Bone>& bones, const std::vector<Animation>& animations, float time, std::vector<glm::mat4>& boneTransforms)
{
    for (size_t i = 0; i < bones.size(); ++i)
    {
        glm::mat4 transform = CalculateInterpolatedTransform(bones[i], animations[i], time);
        if (bones[i].parentIndex != -1)
        {
            transform = boneTransforms[bones[i].parentIndex] * transform;
        }
        boneTransforms[i] = transform;
    }
}

glm::mat4 CalculateInterpolatedTransform(const Bone& bone, const Animation& animation, float time)
{
    KeyFrame startFrame, endFrame;
    FindInterpolationFrames(animation, time, startFrame, endFrame);

    float deltaTime = endFrame.timeStamp - startFrame.timeStamp;
    float factor = (time - startFrame.timeStamp) / deltaTime;

    glm::vec3 interpolatedPosition = Lerp(startFrame.position, endFrame.position, factor);
    glm::quat interpolatedRotation = Slerp(startFrame.rotation, endFrame.rotation, factor);
    glm::vec3 interpolatedScale = Lerp(startFrame.scale, endFrame.scale, factor);

    glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), interpolatedPosition);
    glm::mat4 rotationMatrix = glm::toMat4(interpolatedRotation);
    glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), interpolatedScale);

    return translationMatrix * rotationMatrix * scaleMatrix;
}

void FindInterpolationFrames(const Animation& animation, float time, KeyFrame& startFrame, KeyFrame& endFrame)
{
    for (size_t i = 0; i < animation.keyFrames.size() - 1; ++i)
    {
        if (time >= animation.keyFrames[i].timeStamp && time <= animation.keyFrames[i + 1].timeStamp)
        {
            startFrame = animation.keyFrames[i];
            endFrame = animation.keyFrames[i + 1];
            return;
        }
    }

    // 如果没有找到合适的帧，默认返回第一个和最后一个好的，让我们继续完成骨骼动画实现的完整示例。

### 完整的骨骼动画实现流程（续）

```cpp
    // 如果没有找到合适的帧，默认返回第一个和最后一个帧
    startFrame = animation.keyFrames.front();
    endFrame = animation.keyFrames.back();
}

glm::vec3 Lerp(const glm::vec3& start, const glm::vec3& end, float factor)
{
    return start + factor * (end - start);
}

glm::quat Slerp(const glm::quat& start, const glm::quat& end, float factor)
{
    return glm::slerp(start, end, factor);
}

// 应用骨骼变换到顶点
void ApplyBoneTransforms(std::vector<Vertex>& vertices, const std::vector<glm::mat4>& boneTransforms)
{
    for (auto& vertex : vertices)
    {
        glm::mat4 vertexTransform = CalculateVertexTransform(vertex, boneTransforms);

        // 变换顶点位置
        glm::vec4 transformedPosition = vertexTransform * glm::vec4(vertex.position, 1.0f);
        vertex.position = glm::vec3(transformedPosition);

        // 变换顶点法线
        glm::vec4 transformedNormal = vertexTransform * glm::vec4(vertex.normal, 0.0f);
        vertex.normal = glm::normalize(glm::vec3(transformedNormal));
    }
}

glm::mat4 CalculateVertexTransform(const Vertex& vertex, const std::vector<glm::mat4>& boneTransforms)
{
    glm::mat4 vertexTransform = glm::mat4(0.0f);

    for (const auto& weight : vertex.weights)
    {
        int boneIndex = weight.boneIndex;
        float boneWeight = weight.weight;
        vertexTransform += boneWeight * boneTransforms[boneIndex];
    }

    return vertexTransform;
}

// 渲染
void Render(const std::vector<Vertex>& vertices, const std::vector<glm::mat4>& boneTransforms)
{
    // 这里假设你已经设置好了OpenGL的上下文和着色器程序
    // 并且已经将顶点数据上传到GPU

    // 将骨骼变换矩阵上传到着色器
    for (size_t i = 0; i < boneTransforms.size(); ++i)
    {
        std::string uniformName = "boneTransforms[" + std::to_string(i) + "]";
        GLint location = glGetUniformLocation(shaderProgram, uniformName.c_str());
        glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(boneTransforms[i]));
    }

    // 绘制网格
    glBindVertexArray(vao);
    glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);
}

int main()
{
    // 初始化OpenGL上下文和窗口

    // 加载骨骼和动画数据
    std::vector<Bone> bones;
    LoadSkeleton("path/to/your/model/file.fbx", bones);

    // 加载动画数据
    std::vector<Animation> animations;
    // 这里假设你已经实现了加载动画数据的函数

    // 初始化顶点数据
    std::vector<Vertex> vertices;
    // 这里假设你已经实现了加载顶点数据的函数

    // 初始化骨骼变换矩阵
    std::vector<glm::mat4> boneTransforms(bones.size());

    // 主循环
    while (!glfwWindowShouldClose(window))
    {
        // 计算当前时间
        float time = static_cast<float>(glfwGetTime());

        // 计算骨骼变换矩阵
        CalculateBoneTransforms(bones, animations, time, boneTransforms);

        // 应用骨骼变换到顶点
        ApplyBoneTransforms(vertices, boneTransforms);

        // 渲染
        Render(vertices, boneTransforms);

        // 交换缓冲区和处理事件
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 清理资源
    glfwTerminate();
    return 0;
}

总结

加载骨骼和动画数据：从文件中加载骨骼和动画数据。
计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。
应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到网格的顶点上。
渲染：使用变换后的顶点数据进行绘制好的，让我们继续深入探讨骨骼动画的实现，特别是如何加载动画数据和处理更多细节。

加载动画数据

在加载动画数据时，我们需要从文件中提取关键帧信息，包括每个骨骼在不同时间点的位移、旋转和缩放信息。以下是一个示例，展示如何从Assimp库中加载动画数据：

void LoadAnimations(const aiScene* scene, std::vector<Animation>& animations)
{
    for (unsigned int i = 0; i < scene->mNumAnimations; ++i)
    {
        const aiAnimation* aiAnim = scene->mAnimations[i];
        Animation animation;

        for (unsigned int j = 0; j < aiAnim->mNumChannels; ++j)
        {
            const aiNodeAnim* aiNodeAnim = aiAnim->mChannels[j];
            std::vector<KeyFrame> keyFrames;

            for (unsigned int k = 0; k < aiNodeAnim->mNumPositionKeys; ++k)
            {
                KeyFrame keyFrame;
                keyFrame.timeStamp = static_cast<float>(aiNodeAnim->mPositionKeys[k].mTime);
                keyFrame.position = aiVector3DToGlm(aiNodeAnim->mPositionKeys[k].mValue);
                keyFrames.push_back(keyFrame);
            }

            for (unsigned int k = 0; k < aiNodeAnim->mNumRotationKeys; ++k)
            {
                KeyFrame keyFrame;
                keyFrame.timeStamp = static_cast<float>(aiNodeAnim->mRotationKeys[k].mTime);
                keyFrame.rotation = aiQuaternionToGlm(aiNodeAnim->mRotationKeys[k].mValue);
                keyFrames.push_back(keyFrame);
            }

            for (unsigned int k = 0; k < aiNodeAnim->mNumScalingKeys; ++k)
            {
                KeyFrame keyFrame;
                keyFrame.timeStamp = static_cast<float>(aiNodeAnim->mScalingKeys[k].mTime);
                keyFrame.scale = aiVector3DToGlm(aiNodeAnim->mScalingKeys[k].mValue);
                keyFrames.push_back(keyFrame);
            }

            animation.keyFrames = keyFrames;
        }

        animations.push_back(animation);
    }
}

glm::vec3 aiVector3DToGlm(const aiVector3D& vec)
{
    return glm::vec3(vec.x, vec.y, vec.z);
}

glm::quat aiQuaternionToGlm(const aiQuaternion& quat)
{
    return glm::quat(quat.w, quat.x, quat.y, quat.z);
}

处理更多细节

在实际应用中，骨骼动画系统可能需要处理更多细节，例如：

骨骼权重归一化：确保每个顶点的骨骼权重之和为1。
多动画混合：支持多个动画的混合，例如过渡动画和循环动画。
优化：使用GPU加速计算骨骼变换矩阵，减少CPU负载。

骨骼权重归一化

在加载顶点数据时，确保每个顶点的骨骼权重之和为1：

void NormalizeWeights(std::vector<Vertex>& vertices)
{
    for (auto& vertex : vertices)
    {
        float totalWeight = 0.0f;
        for (const auto& weight : vertex.weights)
        {
            totalWeight += weight.weight;
        }

        if (totalWeight > 0.0f)
        {
            for (auto& weight : vertex.weights)
            {
                weight.weight /= totalWeight;
            }
        }
    }
}

好的，让我们继续深入探讨多动画混合的实现，并完成之前的代码示例。

多动画混合（续）

在多动画混合中，我们需要对不同动画的关键帧进行插值，以实现平滑的过渡效果。以下是完成的代码示例：

glm::mat4 BlendTransforms(const glm::mat4& transform1, const glm::mat4& transform2, float blendFactor)
{
    glm::vec3 position1, scale1, skew1;
    glm::quat rotation1;
    glm::vec4 perspective1;
    glm::decompose(transform1, scale1, rotation1, position1, skew1, perspective1);

    glm::vec3 position2, scale2, skew2;
    glm::quat rotation2;
    glm::vec4 perspective2;
    glm::decompose(transform2, scale2, rotation2, position2, skew2, perspective2);

    glm::vec3 blendedPosition = Lerp(position1, position2, blendFactor);
    glm::quat blendedRotation = Slerp(rotation1, rotation2, blendFactor);
    glm::vec3 blendedScale = Lerp(scale1, scale2, blendFactor);

    glm::mat4 translationMatrix = glm::translate(glm::mat4(1.0f), blendedPosition);
    glm::mat4 rotationMatrix = glm::toMat4(blendedRotation);
    glm::mat4 scaleMatrix = glm::scale(glm::mat4(1.0f), blendedScale);

    return translationMatrix * rotationMatrix * scaleMatrix;
}

void CalculateBlendedBoneTransforms(const std::vector<Bone>& bones, const std::vector<Animation>& animations1, const std::vector<Animation>& animations2, float time1, float time2, float blendFactor, std::vector<glm::mat4>& boneTransforms)
{
    for (size_t i = 0; i < bones.size(); ++i)
    {
        glm::mat4 transform1 = CalculateInterpolatedTransform(bones[i], animations1[i], time1);
        glm::mat4 transform2 = CalculateInterpolatedTransform(bones[i], animations2[i], time2);
        glm::mat4 blendedTransform = BlendTransforms(transform1, transform2, blendFactor);

        if (bones[i].parentIndex != -1)
        {
            blendedTransform = boneTransforms[bones[i].parentIndex] * blendedTransform;
        }
        boneTransforms[i] = blendedTransform;
    }
}

优化

为了提高性能，可以将骨骼变换矩阵的计算移到GPU上。以下是一个简单的示例，展示如何在着色器中进行骨骼变换：

顶点着色器

#version 330 core

layout(location = 0) in vec3 inPosition;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec4 inBoneIDs;
layout(location = 3) in vec4 inWeights;

uniform mat4 boneTransforms[100]; // 假设最多有100个骨骼
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 fragNormal;
out vec3 fragPosition;

void main()
{
    mat4 boneTransform = mat4(0.0);
    for (int i = 0; i < 4; ++i)
    {
        int boneID = int(inBoneIDs[i]);
        float weight = inWeights[i];
        boneTransform += weight * boneTransforms[boneID];
    }

    vec4 transformedPosition = boneTransform * vec4(inPosition, 1.0);
    fragPosition = vec3(model * transformedPosition);
    fragNormal = mat3(transpose(inverse(model))) * mat3(boneTransform) * inNormal;

    gl_Position = projection * view * model * transformedPosition;
}

好的，让我们继续完成主循环中的更新和渲染部分。

主循环中的更新和渲染（续）

在主循环中，我们需要更新动画时间，并计算骨骼变换矩阵，然后将这些矩阵上传到着色器中进行渲染：

int main()
{
    // 初始化OpenGL上下文和窗口
    if (!glfwInit())
    {
        std::cerr << "Failed to initialize GLFW" << std::endl;
        return -1;
    }

    GLFWwindow* window = glfwCreateWindow(800, 600, "Skeletal Animation", nullptr, nullptr);
    if (!window)
    {
        std::cerr << "Failed to create GLFW window" << std::endl;
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(window);
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
    {
        std::cerr << "Failed to initialize GLAD" << std::endl;
        return -1;
    }

    // 加载骨骼和动画数据
    std::vector<Bone> bones;
    LoadSkeleton("path/to/your/model/file.fbx", bones);

    // 加载动画数据
    std::vector<Animation> animations1;
    std::vector<Animation> animations2;
    LoadAnimations("path/to/your/animation1.fbx", animations1);
    LoadAnimations("path/to/your/animation2.fbx", animations2);

    // 初始化顶点数据
    std::vector<Vertex> vertices;
    LoadVertices("path/to/your/model/file.fbx", vertices);

    // 归一化骨骼权重
    NormalizeWeights(vertices);

    // 初始化骨骼变换矩阵
    std::vector<glm::mat4> boneTransforms(bones.size());

    // 创建和编译着色器程序
    GLuint shaderProgram = CreateShaderProgram("vertex_shader.glsl", "fragment_shader.glsl");

    // 设置顶点数组对象和顶点缓冲对象
    GLuint vao, vbo, ebo;
    glGenVertexArrays(1, &vao);
    glGenBuffers(1, &vbo);
    glGenBuffers(1, &ebo);

    glBindVertexArray(vao);

    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(Vertex), vertices.data(), GL_STATIC_DRAW);

    // 假设你已经设置了顶点属性指针
    // ...

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    // 假设你已经设置了索引数据
    // ...

    glBindVertexArray(0);

    // 主循环
    while (!glfwWindowShouldClose(window))
    {
        // 计算当前时间
        float time = static_cast<float>(glfwGetTime());

        // 计算骨骼变换矩阵
        float blendFactor = 0.5f; // 你可以根据需要调整混合因子
        CalculateBlendedBoneTransforms(bones, animations1, animations2, time, time, blendFactor, boneTransforms);

        // 渲染
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glUseProgram(shaderProgram);

        // 将骨骼变换矩阵上传到着色器
        for (size_t i = 0; i < boneTransforms.size(); ++i)
        {
            std::string uniformName = "boneTransforms[" + std::to_string(i) + "]";
            GLint location = glGetUniformLocation(shaderProgram, uniformName.c_str());
            glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(boneTransforms[i]));
        }

        // 绘制网格
        glBindVertexArray(vao);
        glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
        glBindVertexArray(0);

        // 交换缓冲区和处理事件
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // 清理资源
    glDeleteVertexArrays(1, &vao);
    glDeleteBuffers(1, &vbo);
    glDeleteBuffers(1, &ebo);
    glDeleteProgram(shaderProgram);

    glfwTerminate();
    return 0;
}

总结

加载骨骼和动画数据：从文件中加载骨骼和动画数据。
计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。
应用骨骼变换到顶点：将计算得到的骨骼好的，让我们继续完成总结部分，并进一步探讨如何优化和扩展骨骼动画系统。

总结（续）

应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到顶点数据上，以实现动画效果。
渲染：在主循环中，更新动画时间，计算骨骼变换矩阵，并将这些矩阵上传到着色器中进行渲染。

优化和扩展

为了提高性能和扩展功能，我们可以考虑以下优化和扩展：

1. 使用Uniform Buffer Objects (UBOs)

使用UBOs可以更高效地管理和上传大量的骨骼变换矩阵。以下是一个简单的示例，展示如何使用UBOs：

GLuint ubo;
glGenBuffers(1, &ubo);
glBindBuffer(GL_UNIFORM_BUFFER, ubo);
glBufferData(GL_UNIFORM_BUFFER, boneTransforms.size() * sizeof(glm::mat4), nullptr, GL_DYNAMIC_DRAW);
glBindBuffer(GL_UNIFORM_BUFFER, 0);

// 绑定UBO到着色器
GLuint blockIndex = glGetUniformBlockIndex(shaderProgram, "BoneTransforms");
glUniformBlockBinding(shaderProgram, blockIndex, 0);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, ubo);

在主循环中更新UBO：

glBindBuffer(GL_UNIFORM_BUFFER, ubo);
glBufferSubData(GL_UNIFORM_BUFFER, 0, boneTransforms.size() * sizeof(glm::mat4), boneTransforms.data());
glBindBuffer(GL_UNIFORM_BUFFER, 0);

在着色器中定义UBO：

#version 330 core

layout(std140) uniform BoneTransforms
{
    mat4 boneTransforms[100]; // 假设最多有100个骨骼
};

void main()
{
    // 使用boneTransforms进行骨骼变换
}

2. 支持更多动画功能

动画过渡：实现动画过渡功能，使得角色可以平滑地从一个动画过渡到另一个动画。
动画混合：支持多个动画的混合，例如上半身和下半身分别播放不同的动画。
动画事件：在特定的动画时间点触发事件，例如播放音效或触发游戏逻辑。

3. 使用GPU计算骨骼变换

将骨骼变换的计算移到GPU上，可以大大减轻CPU的负担。可以使用Compute Shader来实现这一点：

#version 430 core

layout(local_size_x = 1) in;

layout(std140, binding = 0) buffer BoneTransforms
{
    mat4 boneTransforms[];
};

void main()
{
    uint boneIndex = gl_GlobalInvocationID.x;
    // 计算骨骼变换矩阵
    // boneTransforms[boneIndex] = ...
}

在主程序中调用Compute Shader：

glUseProgram(computeShaderProgram);
glDispatchCompute(numBones, 1, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);

4. 动画压缩和优化

为了减少内存占用和提高性能，可以对动画数据进行压缩和优化。例如：

关键帧压缩：只存储关键帧数据，并在运行时进行插值。
骨骼LOD（Level of Detail）：根据距离和视角，动态调整骨骼的详细程度。

结语

骨骼动画是现代3D图形学中的一个重要技术，广泛应用于游戏、电影和虚拟现实等领域。通过本文的介绍，我们了解了骨骼动画的基本原理和实现方法，并探讨了如何优化和扩展骨骼动画系统。希望这些内容能对你有所帮助，并激发你在这一领域的进一步探索和研究。

牛掰是怎么形成的

关注

9
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
0
评论
骨骼动画实现逻辑

加载骨骼和动画数据：从文件中加载骨骼和动画数据。计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。应用骨骼变换到顶点：将计算得到的骨骼变换矩阵应用到网格的顶点上。渲染：使用变换后的顶点数据进行绘制好的，让我们继续深入探讨骨骼动画的实现，特别是如何加载动画数据和处理更多细节。加载骨骼和动画数据：从文件中加载骨骼和动画数据。计算骨骼变换矩阵：在每一帧中，根据动画数据计算每个骨骼的变换矩阵。应用骨骼变换到顶点。
复制链接

扫一扫