Qt opengl assimp使用骨骼动画代码

以下是使用Assimp库和Qt中OpenGL实现骨骼动画的代码：

首先，需要在Qt项目中添加Assimp库的头文件和链接库：

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

#pragma comment(lib, "assimp-vc141-mt.lib")

接下来，需要定义一个结构体来存储骨骼信息：

struct BoneInfo
{
    aiMatrix4x4 boneOffset;
    aiMatrix4x4 finalTransformation;
};

struct VertexBoneData
{
    int IDs[4];
    float Weights[4];

    VertexBoneData()
    {
        memset(IDs, 0, sizeof(IDs));
        memset(Weights, 0, sizeof(Weights));
    }
};

然后，需要定义一个类来加载模型、骨骼信息和动画数据：

class Model
{
public:
    Model(const std::string& path);
    ~Model();

    void Draw(GLuint shaderProgram);
    void BoneTransform(float timeInSeconds, std::vector<aiMatrix4x4>& transforms);

private:
    void LoadModel(const std::string& path);
    void ProcessNode(aiNode* node, const aiScene* scene);
    void ProcessMesh(aiMesh* mesh, const aiScene* scene);
    void LoadBones(unsigned int meshIndex, aiMesh* mesh, std::vector<VertexBoneData>& bones);
    void LoadAnimations(const aiScene* scene);
    void ReadNodeHierarchy(float animationTime, const aiNode* node, const aiMatrix4x4& parentTransform);
    const aiNodeAnim* FindNodeAnim(const aiAnimation* animation, const std::string& nodeName);
    void CalcInterpolatedScaling(aiVector3D& out, float animationTime, const aiNodeAnim* nodeAnim);
    void CalcInterpolatedRotation(aiQuaternion& out, float animationTime, const aiNodeAnim* nodeAnim);
    void CalcInterpolatedPosition(aiVector3D& out, float animationTime, const aiNodeAnim* nodeAnim);

    GLuint m_VAO;
    GLuint m_VBO;
    GLuint m_EBO;

    std::vector<BoneInfo> m_BoneInfo;
    std::map<std::string, unsigned int> m_BoneMapping;
    unsigned int m_NumBones;
    std::vector<VertexBoneData> m_Bones;

    std::vector<Texture> m_Textures;
    std::vector<Mesh> m_Meshes;
    std::string m_Directory;

    std::vector<aiMatrix4x4> m_BoneTransforms;

    std::vector<Animation> m_Animations;
    float m_TimeInSeconds;
    float m_TickPerSecond;
};

在实现类的成员函数时，需要依次实现加载模型、骨骼信息和动画数据的函数。其中，加载模型的函数主要是使用Assimp库中的函数来读取模型文件，提取网格数据和纹理数据。加载骨骼信息的函数则需要遍历每个网格，提取顶点对应的骨骼编号和权重，以及每个骨骼的变换矩阵。加载动画数据的函数需要遍历每个动画，提取动画名称、时间长度、帧率和关键帧数据。

当加载完模型、骨骼信息和动画数据后，就可以在绘制函数中使用骨骼动画了。具体操作是，在每个动画关键帧的时间点上，计算每个骨骼的变换矩阵，然后将这些矩阵传递给着色器，进行渲染。计算变换矩阵的函数如下：

void Model::BoneTransform(float timeInSeconds, std::vector<aiMatrix4x4>& transforms)
{
    aiMatrix4x4 identityMatrix;

    float ticksPerSecond = m_TickPerSecond != 0 ? m_TickPerSecond : 25.0f;
    float timeInTicks = timeInSeconds * ticksPerSecond;
    float animationTime = fmod(timeInTicks, m_TimeInSeconds);

    ReadNodeHierarchy(animationTime, m_Scene->mRootNode, identityMatrix);

    transforms.resize(m_NumBones);

    for (unsigned int i = 0; i < m_NumBones; i++)
    {
        transforms[i] = m_BoneInfo[i].finalTransformation;
    }
}

在计算变换矩阵时，需要遍历骨骼节点树，找到每个节点对应的关键帧数据，然后进行插值计算。具体实现过程可以参考以下代码：

void Model::ReadNodeHierarchy(float animationTime, const aiNode* node, const aiMatrix4x4& parentTransform)
{
    std::string nodeName(node->mName.data);

    const aiAnimation* animation = m_Animations[0].m_Animation;
    aiMatrix4x4 nodeTransform = node->mTransformation;

    const aiNodeAnim* nodeAnim = FindNodeAnim(animation, nodeName);

    if (nodeAnim)
    {
        aiVector3D scaling;
        CalcInterpolatedScaling(scaling, animationTime, nodeAnim);
        aiMatrix4x4 scalingMatrix;
        aiMatrix4x4::Scaling(scaling, scalingMatrix);

        aiQuaternion rotation;
        CalcInterpolatedRotation(rotation, animationTime, nodeAnim);
        aiMatrix4x4 rotationMatrix = aiMatrix4x4(rotation.GetMatrix());

        aiVector3D position;
        CalcInterpolatedPosition(position, animationTime, nodeAnim);
        aiMatrix4x4 translationMatrix;
        aiMatrix4x4::Translation(position, translationMatrix);

        nodeTransform = translationMatrix * rotationMatrix * scalingMatrix;
    }

    aiMatrix4x4 globalTransform = parentTransform * nodeTransform;

    if (m_BoneMapping.find(nodeName) != m_BoneMapping.end())
    {
        unsigned int boneIndex = m_BoneMapping[nodeName];
        m_BoneTransforms[boneIndex] = globalTransform * m_BoneInfo[boneIndex].boneOffset;
    }

    for (unsigned int i = 0; i < node->mNumChildren; i++)
    {
        ReadNodeHierarchy(animationTime, node->mChildren[i], globalTransform);
    }
}

最后，在着色器中使用骨骼信息来进行顶点变换，实现骨骼动画的效果。具体操作是，在顶点着色器中传递每个顶点对应的骨骼编号和权重，然后根据骨骼变换矩阵来计算顶点的最终位置。示例代码如下：

#version 330 core

layout (location = 0) in vec3 aPos;
layout (location = 1) in vec3 aNormal;
layout (location = 2) in vec2 aTexCoords;
layout (location = 3) in ivec4 aBoneIDs;
layout (location = 4) in vec4 aWeights;

uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

uniform mat4 boneTransforms[100];

out vec3 FragPos;
out vec3 Normal;
out vec2 TexCoords;

void main()
{
    mat4 boneTransform = boneTransforms[aBoneIDs[0]] * aWeights[0];
    boneTransform += boneTransforms[aBoneIDs[1]] * aWeights[1];
    boneTransform += boneTransforms[aBoneIDs[2]] * aWeights[2];
    boneTransform += boneTransforms[aBoneIDs[3]] * aWeights[3];

    vec4 pos = boneTransform * vec4(aPos, 1.0);
    gl_Position = projection * view * model * pos;

    FragPos = vec3(model * pos);
    Normal = mat3(transpose(inverse(model))) * aNormal;
    TexCoords = aTexCoords;
}

以上就是使用Assimp库和Qt中OpenGL实现骨骼动画的代码。需要注意的是，在实际开发中，还需要考虑一些特殊情况，比如模型中没有骨骼信息或者动画数据，或者骨骼数量超过了硬件限制等问题。