animator.h

#pragma once
 
#include <glm/glm.hpp>
#include <map>
#include <vector>
#include <assimp/scene.h>
#include <assimp/Importer.hpp>
 
#include "meshManager.h"
#include "animation.h"
#include "bone.h"
#include <glm/gtx/matrix_decompose.hpp>  
#include <glm/gtc/quaternion.hpp>  
namespace Aire {
 
    class Animator
    {
    public:
        bool isStatic = true;
        Model* m_Model;
        std::vector<Animation*> animations;
 
        Animator(Aire::MeshManager* meshManager, const std::string& animationPath, bool flippedUV)
        {
            Aire::ModelHandle modelObjHandle = meshManager->createModel(animationPath, flippedUV);
            Aire::ModelPtr modelObjPtr = meshManager->getModelPtr(modelObjHandle);
            meshManager->moveModelToGpu(modelObjHandle);
            m_Model = modelObjPtr.get();
            Animation* animation = new Animation(animationPath, m_Model);
 
            m_CurrentTime = 0.0;
            m_DeltaTime = 0.0;
            m_CurrentAnimation = animation;
            m_NextAnimation = nullptr;
 
            m_FinalBoneMatrices.reserve(100);
 
            for (int i = 0; i < 100; i++)
                m_FinalBoneMatrices.push_back(glm::mat4(1.0f));
        }
 
        Animator(Animation* animation)
        {
            animations.push_back(animation);
            m_CurrentTime = 0.0;
            m_DeltaTime = 0.0;
            m_Model = nullptr;
            m_CurrentAnimation = animation;
            m_NextAnimation = nullptr;
            m_FinalBoneMatrices.reserve(100);
 
            for (int i = 0; i < 100; i++)
                m_FinalBoneMatrices.push_back(glm::mat4(1.0f));
        }
 
        ~Animator()
        {
            delete m_Model;
            delete m_CurrentAnimation;
        }
 
        glm::mat4 InterpolateMatrices(const glm::mat4& matrix1, const glm::mat4& matrix2, float blendFactor)
        {
            glm::quat rotation1 = glm::quat_cast(matrix1);
            glm::quat rotation2 = glm::quat_cast(matrix2);
            glm::vec3 translation1 = glm::vec3(matrix1[3]);
            glm::vec3 translation2 = glm::vec3(matrix2[3]);
 
            glm::quat interpolatedRotation = glm::slerp(rotation1, rotation2, blendFactor);
            glm::vec3 interpolatedTranslation = glm::mix(translation1, translation2, blendFactor);
 
            return glm::translate(glm::mat4(1.0f), interpolatedTranslation) * glm::mat4_cast(interpolatedRotation);
        }
 
        void UpdateAnimation(float dt)
        {
            if (m_CurrentAnimation == nullptr) return;
 
            m_DeltaTime = dt;
            m_CurrentTime += m_CurrentAnimation->GetTicksPerSecond() * dt;
            m_CurrentTime = fmod(m_CurrentTime, m_CurrentAnimation->GetDuration());
 
            if (m_Blending && m_NextAnimation != nullptr)
            {
                m_BlendFactor += dt; // Increase blend factor over time
                if (m_BlendFactor >= 1.0f)
                {
                    m_BlendFactor = 0.0f;
                    m_CurrentAnimation = m_NextAnimation;
                    m_NextAnimation = nullptr;
                    m_Blending = false;
                }
            }
 
            glm::mat4 identity = glm::mat4(1.0f);
            std::vector<glm::mat4> currentBoneMatrices(100, identity);
            std::vector<glm::mat4> nextBoneMatrices(100, identity);
 
            CalculateBoneTransform(&m_CurrentAnimation->GetRootNode(), identity, currentBoneMatrices);
 
            if (m_Blending && m_NextAnimation != nullptr)
            {
                CalculateBoneTransform(&m_NextAnimation->GetRootNode(), identity, nextBoneMatrices);
                for (int i = 0; i < 100; i++)
                {
                    glm::vec3 scaleCurrent, translationCurrent, skewCurrent, scaleNext, translationNext, skewNext;
                    glm::vec4 perspectiveCurrent, perspectiveNext;
                    glm::quat rotationCurrent, rotationNext;
 
                    glm::decompose(currentBoneMatrices[i], scaleCurrent, rotationCurrent, translationCurrent, skewCurrent, perspectiveCurrent);
                    glm::decompose(nextBoneMatrices[i], scaleNext, rotationNext, translationNext, skewNext, perspectiveNext);
 
                    glm::vec3 scaleInterpolated = glm::mix(scaleCurrent, scaleNext, m_BlendFactor);
                    glm::quat rotationInterpolated = glm::slerp(rotationCurrent, rotationNext, m_BlendFactor);
                    glm::vec3 translationInterpolated = glm::mix(translationCurrent, translationNext, m_BlendFactor);
 
                    glm::mat4 matInterpolated = glm::translate(glm::mat4(1.0), translationInterpolated) *
                        glm::mat4_cast(rotationInterpolated) *
                        glm::scale(glm::mat4(1.0), scaleInterpolated);
 
                    m_FinalBoneMatrices[i] = matInterpolated;
                }
            }
            else
            {
                m_FinalBoneMatrices = currentBoneMatrices;
            }
        }
 
        void PlayAnimation(Animation* pAnimation)
        {
            if (m_CurrentAnimation != pAnimation)
            {
 
                m_NextAnimation = pAnimation;
 
                if (m_BlendFactor == false) {
 
                    m_BlendFactor = 0.0f;
 
                }
 
                m_Blending = true;
 
            }
        }
 
        void CalculateBoneTransform(const AssimpNodeData* node, glm::mat4 parentTransform, std::vector<glm::mat4>& boneMatrices)
        {
            std::string nodeName = node->name;
            glm::mat4 nodeTransform = node->transformation;
 
            Bone* currentBone = m_CurrentAnimation->FindBone(nodeName);
            Bone* nextBone = m_NextAnimation ? m_NextAnimation->FindBone(nodeName) : nullptr;
 
            if (currentBone)
            {
                currentBone->Update(m_CurrentTime);
                nodeTransform = currentBone->GetLocalTransform();
            }
 
            if (nextBone)
            {
                nextBone->Update(m_CurrentTime);
                glm::mat4 nextBoneTransform = nextBone->GetLocalTransform();
 
                // Mix current and next bone transforms based on blend factor
                nodeTransform = InterpolateMatrices(nodeTransform, nextBoneTransform, m_BlendFactor);
            }
 
            glm::mat4 globalTransformation = parentTransform * nodeTransform;
 
            auto& boneInfoMap = m_CurrentAnimation->GetBoneIDMap();
            if (boneInfoMap.find(nodeName) != boneInfoMap.end())
            {
                int index = boneInfoMap.at(nodeName).id;
                glm::mat4 offset = boneInfoMap.at(nodeName).offset;
                boneMatrices[index] = globalTransformation * offset;
            }
 
            for (int i = 0; i < node->childrenCount; i++)
                CalculateBoneTransform(&node->children[i], globalTransformation, boneMatrices);
        }
 
        std::vector<glm::mat4> GetFinalBoneMatrices()
        {
            return m_FinalBoneMatrices;
        }
 
        void render(ShaderProgram& shader, Camera& camera)
        {
            auto transforms = GetFinalBoneMatrices();
 
            for (int i = 0; i < transforms.size(); ++i)
            {
                glUniformMatrix4fv(glGetUniformLocation(shader.getProgramId(), 
                    ("finalBonesMatrices[" + std::to_string(i) + "]").c_str()), 1, GL_FALSE, glm::value_ptr(transforms[i]));
            }
 
            m_Model->render(shader, camera);
        }
 
        void renderInstanced(ShaderProgram& shader, Camera& camera, glm::mat4 transform)
        {
            auto transforms = GetFinalBoneMatrices();
 
            for (int i = 0; i < transforms.size(); ++i)
            {
                glUniformMatrix4fv(glGetUniformLocation(shader.getProgramId(),
                    ("finalBonesMatrices[" + std::to_string(i) + "]").c_str()), 1, GL_FALSE, glm::value_ptr(transforms[i]));
            }
 
            m_Model->renderInstanced(shader, camera, transform);
        }
 
    private:
        std::vector<glm::mat4> m_FinalBoneMatrices;
        Animation* m_CurrentAnimation;
        Animation* m_NextAnimation;
        float m_CurrentTime;
        float m_DeltaTime;
        bool m_Blending;
        float m_BlendFactor;
    };
};