feat(animation): enhance animation system with node animation support and refactor bone handling

Author: AhmedAmrNabil

src/common/animation/animation.hpp

@@ -6,7 +6,7 @@
 #include <glm/gtc/quaternion.hpp>
 #include <stdexcept>
 #include <string>
-#include <vector>
+#include <unordered_map>
 
 #include "bone.hpp"
 #include "skeleton.hpp"
@@ -16,27 +16,26 @@ namespace our {
     class Animation {
     public:
         std::string name;
-        std::unordered_map<BoneID, BoneAnimation> bones;
+        std::unordered_map<std::string, BoneAnimation> channels;
         Skeleton& skeleton;
         float duration;  // in ticks
         float ticksPerSecond;
         Animation(const aiAnimation* anim, Skeleton& skeleton) : skeleton(skeleton) {
             duration = static_cast<float>(anim->mDuration);
-            ticksPerSecond = static_cast<float>(anim->mTicksPerSecond);
+            float tps = static_cast<float>(anim->mTicksPerSecond);
+            if (tps == 0.0f) tps = 25.0f;  // default to 25 if not specified
+            ticksPerSecond = tps;
+            name = anim->mName.C_Str();
 
             for (unsigned int i = 0; i < anim->mNumChannels; i++) {
                 aiNodeAnim* channel = anim->mChannels[i];
-                std::string boneName = channel->mNodeName.C_Str();
-
-                // find or create because some bones are not referenced in the meshes but are still animated
-                // they don't contribute to mesh weights but they still affect the bones after them in the hierarchy
-                BoneID id = skeleton.findOrCreateBone(boneName, glm::mat4(1.0f));
-                bones.emplace(id, BoneAnimation(boneName, id, channel));
+                std::string nodeName = channel->mNodeName.C_Str();
+                channels[nodeName] = BoneAnimation(nodeName, skeleton.getBoneID(nodeName), channel);
             }
         }
         BoneAnimation& findBone(const std::string& name) {
-            auto it = bones.find(skeleton.getBoneID(name));
-            if (it != bones.end()) {
+            auto it = channels.find(name);
+            if (it != channels.end()) {
                 return it->second;
             }
             throw std::runtime_error("BoneAnimation not found: " + name);

src/common/animation/animator.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <unordered_map>
+#include <vector>
+
 #include "animation.hpp"
 
 namespace our {
@@ -9,22 +12,27 @@ namespace our {
     class Animator {
         const Animation* currentAnimation;
         float currentTime;  // in ticks
-        std::vector<glm::mat4> finalBoneMatrices;
+        // there are 2 types of animations that assimp supports
+        // 1. skeletal animations that affect the bones and are used for skinning meshes
+        // 2. node animations that affect any node in the hierarchy but are not used for skinning
+        //    (eg. a whole mesh rotating as a child of a bone, or a light source attached to a bone)
+        std::vector<glm::mat4> finalBoneMatrices;                   // for bone animations
+        std::unordered_map<std::string, glm::mat4> nodeTransforms;  // for node animations
         bool loop;
 
         void computeBoneTransform(const std::vector<SkeletonNode>& nodes) {
             const Skeleton& skeleton = currentAnimation->skeleton;
             std::vector<glm::mat4> globalTransforms(nodes.size());
+            nodeTransforms.clear();
 
             for (int i = 0; i < (int)nodes.size(); i++) {
                 const auto& node = nodes[i];
 
                 // animated local transform, fallback to bind pose
                 glm::mat4 localTransform = node.localTransform;
-                BoneID id = skeleton.getBoneID(node.name);
-                if (id >= 0) {
-                    auto it = currentAnimation->bones.find(id);
-                    if (it != currentAnimation->bones.end()) localTransform = it->second.interpolate(currentTime);
+                auto it = currentAnimation->channels.find(node.name);
+                if (it != currentAnimation->channels.end()) {
+                    localTransform = it->second.interpolate(currentTime);
                 }
 
                 // accumulate from parent
@@ -33,6 +41,11 @@ namespace our {
                 else
                     globalTransforms[i] = globalTransforms[node.parentIndex] * localTransform;
 
+                // Cache for meshes
+                nodeTransforms[node.name] = globalTransforms[i];
+
+                // Cache for skeletal bones
+                BoneID id = skeleton.getBoneID(node.name);
                 if (id >= 0 && id < (BoneID)finalBoneMatrices.size())
                     finalBoneMatrices[id] = skeleton.getGlobalInverseTransform() * globalTransforms[i] *
                                             skeleton.getOffsetMatrix(node.name);
@@ -63,6 +76,12 @@ namespace our {
             return finalBoneMatrices;
         }
 
+        const glm::mat4* getNodeTransform(const std::string& name) const {
+            auto it = nodeTransforms.find(name);
+            if (it != nodeTransforms.end()) return &it->second;
+            return nullptr;
+        }
+
         bool isFinished() const {
             return currentAnimation && currentTime >= currentAnimation->duration;
         }

src/common/animation/bone.hpp

@@ -5,12 +5,13 @@
 #include <glm/glm.hpp>
 #include <glm/gtx/quaternion.hpp>
 #include <string>
+#include <vector>
 
 namespace our {
     using BoneID = int;
     struct BonePose {
         BoneID id;
-        glm::mat4 offsetMatrix;
+        glm::mat4 offsetMatrix;  // the inverse of the bone's bind pose transform
     };
 
     struct KeyPosition {
@@ -33,7 +34,6 @@ namespace our {
         std::vector<KeyRotation> rotations;
         std::vector<KeyScale> scales;
         std::string name;
-        BoneID id;
 
         template <typename TKey>
         static size_t findIndex(const std::vector<TKey>& keys, float animationTime) {
@@ -64,7 +64,8 @@ namespace our {
         }
 
     public:
-        BoneAnimation(const std::string& name, BoneID id, const aiNodeAnim* channel) : name(name), id(id) {
+        BoneAnimation() = default;
+        BoneAnimation(const std::string& name, BoneID id, const aiNodeAnim* channel) : name(name) {
             // Load position keyframes
             positions = loadKeys<KeyPosition>(
                 channel->mNumPositionKeys, channel->mPositionKeys,

src/common/animation/skeleton.hpp

@@ -57,6 +57,7 @@ namespace our {
         }
 
         // used for FBX files where the root node's transform is not identity
+        // currently its unused since our test models don't have such a case, but it's here for completeness
         void setGlobalInverseTransform(const glm::mat4& inverseTransform) {
             globalInverseTransform = inverseTransform;
         }

src/common/components/mesh-renderer.hpp

@@ -14,6 +14,7 @@ namespace our {
         Mesh* mesh;             // The mesh that should be drawn
         Material* material;     // The material used to draw the mesh
         glm::mat4 transform;    // The transformation of the mesh relative to parent
+        std::string nodeName;   // The name of the node that owns this submesh (used for node animations)
         bool hasBones = false;  // True if this mesh has bone weights for skinning
 
         // The ID of this component type is "Mesh Renderer"

src/common/model/model.cpp

@@ -86,6 +86,7 @@ namespace our {
             aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
             MeshRendererComponent* submesh = processMesh(mesh, scene);
             submesh->transform = globalTransform;
+            submesh->nodeName = node->mName.C_Str();
             submeshes.push_back(submesh);
         }
         for (unsigned int i = 0; i < node->mNumChildren; i++) {
@@ -136,7 +137,7 @@ namespace our {
             vertices[i] = v;
         }
 
-        processVertexBoneData(vertices, mesh, scene);
+        if (mesh->HasBones()) processVertexBoneData(vertices, mesh, scene);
 
         // process indices
         for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {

src/common/systems/animation-system.cpp

@@ -1,6 +1,5 @@
 #include "animation-system.hpp"
 
-#include <iostream>
 #include <string>
 
 #include "components/animation.hpp"
@@ -10,9 +9,6 @@ namespace our {
         for (auto entity : world->getEntities()) {
             AnimationComponent* animComp = entity->getComponent<AnimationComponent>();
             if (!animComp) continue;
-            if (glfwGetKey(glfwGetCurrentContext(), GLFW_KEY_SPACE) == GLFW_PRESS) {
-                animComp->play(std::string("Attack1_0.anm"), false);
-            }
             animComp->animator.update(deltaTime * animComp->speed);
         }
     }

src/common/systems/forward-renderer.cpp

@@ -169,8 +169,13 @@ namespace our {
                 command.center = glm::vec3(command.localToWorld * glm::vec4(0, 0, 0, 1));
                 command.mesh = meshRenderer->mesh;
                 command.material = meshRenderer->material;
-                if (auto anim = entity->getComponent<AnimationComponent>(); anim && meshRenderer->hasBones) {
-                    command.animator = &anim->animator;
+                if (auto anim = entity->getComponent<AnimationComponent>(); anim) {
+                    if (meshRenderer->hasBones) {
+                        command.animator = &anim->animator;
+                    } else if (auto nodeTransform = anim->animator.getNodeTransform(meshRenderer->nodeName);
+                               nodeTransform) {
+                        command.localToWorld = command.localToWorld * (*nodeTransform);
+                    }
                 }
                 // if it is transparent, we add it to the transparent commands list
                 if (command.material->transparent) {
@@ -205,8 +210,13 @@ namespace our {
                     command.center = glm::vec3(command.localToWorld * glm::vec4(0, 0, 0, 1));
                     command.mesh = submesh->mesh;
                     command.material = submesh->material;
-                    if (auto anim = entity->getComponent<AnimationComponent>(); anim && submesh->hasBones) {
-                        command.animator = &anim->animator;
+                    if (auto anim = entity->getComponent<AnimationComponent>(); anim) {
+                        if (submesh->hasBones) {
+                            command.animator = &anim->animator;
+                        } else if (auto nodeTransform = anim->animator.getNodeTransform(submesh->nodeName);
+                                   nodeTransform) {
+                            command.localToWorld = modelMatrix * (*nodeTransform);
+                        }
                     }
                     if (command.material->transparent) {
                         transparentCommands.push_back(command);