Qt opengl assimp加载骨骼动画

使用Qt OpenGL和Assimp库加载骨骼动画的基本步骤如下：

1. 导入模型文件：使用Assimp库导入模型文件，包括模型数据，材质和纹理等。

2. 创建骨骼：解析模型文件中的骨骼数据，并创建骨骼节点、骨骼关节等。

3. 加载动画：从模型文件中加载动画数据，包括关键帧，动画时长等。

4. 计算动画：根据当前时间计算出每个骨骼节点的变换矩阵，以便在渲染时对模型进行正确的姿态变换。

5. 绘制模型：使用OpenGL绘制模型，并传递动画时刻所对应的骨骼变换矩阵。

具体实现步骤如下：

1. 导入模型文件

使用Assimp库的Importer类导入模型文件，可以获取到模型中的顶点数据、材质、纹理、骨骼等信息。例如：

Assimp::Importer importer;
const aiScene* scene = importer.ReadFile(filename, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_GenNormals | aiProcess_LimitBoneWeights);

2. 创建骨骼

解析模型文件中的骨骼数据，并创建骨骼节点、骨骼关节等。例如：

void CreateBoneTree(const aiNode* node, const aiScene* scene, Bone* parentBone = nullptr)
{
    Bone* bone = new Bone(node->mName.C_Str(), parentBone);

    // 处理骨骼节点变换矩阵
    bone->mOffsetMatrix = node->mTransformation;

    // 处理骨骼节点中的骨骼关节
    for (unsigned int i = 0; i < node->mNumMeshes; ++i)
    {
        int meshIndex = node->mMeshes[i];
        aiMesh* mesh = scene->mMeshes[meshIndex];

        for (unsigned int j = 0; j < mesh->mNumBones; ++j)
        {
            aiBone* boneData = mesh->mBones[j];
            if (strcmp(bone->mName.c_str(), boneData->mName.C_Str()) == 0)
            {
                bone->mBoneData = boneData;
                break;
            }
        }
    }

    // 递归处理子骨骼节点
    for (unsigned int i = 0; i < node->mNumChildren; ++i)
    {
        CreateBoneTree(node->mChildren[i], scene, bone);
    }
}

3. 加载动画

从模型文件中加载动画数据，可以获取到每个关键帧的骨骼变换矩阵、动画时长等信息。例如：

void LoadAnimations(const aiScene* scene, Model* model)
{
    for (unsigned int i = 0; i < scene->mNumAnimations; ++i)
    {
        aiAnimation* anim = scene->mAnimations[i];
        Animation* animation = new Animation(anim->mName.C_Str(), anim->mDuration, anim->mTicksPerSecond);

        // 处理关键帧
        for (unsigned int j = 0; j < anim->mNumChannels; ++j)
        {
            aiNodeAnim* nodeAnim = anim->mChannels[j];

            for (unsigned int k = 0; k < nodeAnim->mNumPositionKeys; ++k)
            {
                aiVector3D pos = nodeAnim->mPositionKeys[k].mValue;
                aiQuaternion rot = nodeAnim->mRotationKeys[k].mValue;
                aiVector3D scale = nodeAnim->mScalingKeys[k].mValue;

                KeyFrame* keyFrame = new KeyFrame(nodeAnim->mNodeName.C_Str(), nodeAnim->mNumPositionKeys,
                                                  nodeAnim->mNumRotationKeys, nodeAnim->mNumScalingKeys);

                keyFrame->mTime = nodeAnim->mPositionKeys[k].mTime;

                keyFrame->mPosition.x = pos.x;
                keyFrame->mPosition.y = pos.y;
                keyFrame->mPosition.z = pos.z;

                keyFrame->mRotation.w = rot.w;
                keyFrame->mRotation.x = rot.x;
                keyFrame->mRotation.y = rot.y;
                keyFrame->mRotation.z = rot.z;

                keyFrame->mScaling.x = scale.x;
                keyFrame->mScaling.y = scale.y;
                keyFrame->mScaling.z = scale.z;

                animation->AddKeyFrame(keyFrame);
            }
        }

        model->AddAnimation(animation);
    }
}

4. 计算动画

根据当前时间计算出每个骨骼节点的变换矩阵，以便在渲染时对模型进行正确的姿态变换。例如：

void CalculateBoneTransforms(const Animation* animation, float time, std::map<std::string, glm::mat4>& boneTransforms)
{
    std::vector<KeyFrame*> keyFrames = animation->GetKeyFrames();
    if (keyFrames.empty())
        return;

    KeyFrame* frameA = nullptr;
    KeyFrame* frameB = nullptr;

    // 查找当前时间所在的关键帧
    for (unsigned int i = 0; i < keyFrames.size() - 1; ++i)
    {
        frameA = keyFrames[i];
        frameB = keyFrames[i + 1];

        if (time < frameB->mTime)
            break;
    }

    float delta = (time - frameA->mTime) / (frameB->mTime - frameA->mTime);

    // 计算每个骨骼节点的变换矩阵
    for (unsigned int i = 0; i < frameA->mNumBones; ++i)
    {
        BoneData* boneDataA = frameA->mBones[i];
        BoneData* boneDataB = frameB->mBones[i];

        glm::vec3 position = glm::mix(boneDataA->mPosition, boneDataB->mPosition, delta);
        glm::quat rotation = glm::slerp(boneDataA->mRotation, boneDataB->mRotation, delta);
        glm::vec3 scaling = glm::mix(boneDataA->mScaling, boneDataB->mScaling, delta);

        glm::mat4 translateMat = glm::translate(glm::mat4(1.0f), position);
        glm::mat4 rotateMat = glm::toMat4(rotation);
        glm::mat4 scaleMat = glm::scale(glm::mat4(1.0f), scaling);

        glm::mat4 boneMat = translateMat * rotateMat * scaleMat;
        glm::mat4 offsetMat = boneDataA->mBone->mOffsetMatrix;

        boneTransforms[boneDataA->mBone->mName] = boneMat * offsetMat;
    }
}

5. 绘制模型

使用OpenGL绘制模型，并传递动画时刻所对应的骨骼变换矩阵。例如：

void RenderModel(Model* model, std::map<std::string, glm::mat4>& boneTransforms)
{
    for (unsigned int i = 0; i < model->GetMeshCount(); ++i)
    {
        Mesh* mesh = model->GetMesh(i);
        Material* material = mesh->GetMaterial();

        // 绑定材质和纹理
        material->Bind();
        material->SetUniform("modelViewMatrix", m_camera->GetViewMatrix() * mesh->GetModelMatrix());
        material->SetUniform("projectionMatrix", m_camera->GetProjectionMatrix());
        material->SetUniform("boneTransforms", boneTransforms);

        // 绘制网格
        mesh->Render();
    }
}

完整的代码示例可以参考以下链接：

https://github.com/cxong/QtOpenGLAssimpSkeletonAnimation