feat(animation): enhance animation system with clip management and speed control

Author: AhmedAmrNabil

config/playgrounds/animation.jsonc

@@ -3,15 +3,15 @@
     "window": {
         "title": "Default Game Window",
         "size": {
-            "width": 1920,
-            "height": 1080
+            "width": 1280,
+            "height": 720
         },
         "fullscreen": false
     },
     "scene": {
         "renderer": {
             "sky": "assets/textures/sky.jpg",
-            "postprocess": "assets/shaders/postprocess/vignette.frag"
+            "postprocess": "assets/shaders/postprocess/dash-distortion.frag"
         },
         "assets": {
             "shaders": {
@@ -182,10 +182,22 @@
                 "drone": "assets/gltf/mech_drone/mech_drone.glb",
                 "map": "assets/gltf/map/map.glb",
                 "gun": "assets/gltf/weapons/rifle.glb",
-                "alistar": "assets/gltf/enemies/mundo/corporate_mundo.glb"
+                "mundo": "assets/gltf/enemies/mundo/corporate_mundo.glb"
             }
         },
         "game": {
+            "enemyHealthBars": {
+                "enabled": true,
+                "maxDistance": 22.0,
+                "colors": {
+                    "low": [0.84, 0.18, 0.24, 0.96],
+                    "mid": [0.96, 0.76, 0.25, 0.96],
+                    "high": [0.28, 0.84, 0.45, 0.96],
+                    "border": [0.02, 0.03, 0.05, 0.92],
+                    "background": [0.12, 0.14, 0.18, 0.88],
+                    "highlight": [1.0, 1.0, 1.0, 0.12]
+                }
+            },
             "enemySpawner": {
                 "spawnPoints": [
                     [30.0, 0.0, 30.0],
@@ -281,15 +293,32 @@
                     },
                     {
                         "type": "Free Camera Controller",
-                        "positionSensitivity": [8.0, 0.0, 8.0],
-                        "rotationSensitivity": 0.008,
-                        "speedupFactor": 2.5,
+                        "rotationSensitivity": 0.01,
+                        "fovSensitivity": 0.3
+                    },
+                    {
+                        "type": "PlayerMovement",
+                        "walkSpeed": 8.0,
+                        "sprintMultiplier": 2.0,
+                        "crouchSpeed": 4.0,
+                        "crouchHeight": 1.0,
+                        "slideSpeedMultiplier": 1.5,
+                        "slideDuration": 0.8,
+                        "slideCooldown": 0.5,
+                        "dashDistance": 5.0,
+                        "dashCooldown": 1.0,
                         "groundLevel": 0.0,
-                        "playerHeight": 1.8
+                        "playerHeight": 2,
+                        "jumpForce": 9.0
                     },
                     {
                         "type": "Player"
                     },
+                    {
+                        "type": "Post Process Effects Component"
+                    }
+                ],
+                "children": [
                     {
                         "type": "Health",
                         "maxHealth": 100.0
@@ -301,68 +330,77 @@
                         "height": 1.8
                     },
                     {
-                        "type": "light",
-                        "lightType": "spot",
-                        "color": [3, 3, 3],
-                        "attenuation": [1.0, 0.22, 0.2],
-                        "spotAngles": [13, 20]
-                    }
-                ],
-                "children": [
-                    {
-                        "position": [1, -1, -1],
-                        "rotation": [45, 45, 0],
-                        "scale": [0.1, 0.1, 1.0],
+                        "position": [1, -1, -2],
+                        "rotation": [0, 0, 0],
+                        "scale": [0.3, 0.3, 0.3],
                         "components": [
                             {
-                                "type": "Mesh Renderer",
-                                "mesh": "cube",
-                                "material": "metal"
+                                "type": "Model Renderer",
+                                "model": "gun"
+                            }
+                        ],
+                        "children": [
+                            {
+                                "position": [0, 0, 0],
+                                "components": [
+                                    {
+                                        "type": "light",
+                                        "lightType": "spot",
+                                        "color": [1, 0.8, 0.6],
+                                        "attenuation": [1.0, 0.14, 0.07],
+                                        "spotAngles": [15, 20]
+                                    }
+                                ]
                             }
                         ]
                     }
                 ]
             },
             {
-                "name": "Ground",
-                "position": [0.0, 0.0, 0.0],
-                "rotation": [-90.0, 0.0, 0.0],
-                "scale": [120.0, 120.0, 1.0],
-                "components": [
-                    {
-                        "type": "Mesh Renderer",
-                        "mesh": "plane",
-                        "material": "ground"
-                    }
-                ]
-            },
-            {
-                "position": [2, 4, -2],
-                "scale": [5, 5, 5],
+                "name": "map",
+                "position": [0, 0, 0],
                 "components": [
                     {
-                        "type": "Mesh Renderer",
-                        "mesh": "monkey",
-                        "material": "monkey"
+                        "type": "Model Renderer",
+                        "model": "map"
                     }
                 ]
             },
             {
                 "name": "test enemy",
                 "position": [10, 0, 10],
-                "scale": [0.01, 0.01, 0.01],
+                "scale": [0.05, 0.05, 0.05],
                 "components": [
                     {
                         "type": "Model Renderer",
-                        "model": "alistar"
+                        "model": "mundo"
                     },
                     {
                         "type": "Animation",
-                        "model": "alistar",
-                        "clip": "Run01",
-                        "loop": true,
-                        "speed": 1.0,
-                        "autoplay": true
+                        "model": "mundo",
+                        "default": "idle",
+                        "clips": {
+                            "idle": {
+                                "clip": "IdleVariant1",
+                                "loop": true,
+                                "speed": 1.0
+                            },
+                            "walk": {
+                                "clip": "Run01",
+                                "loop": true,
+                                "speed": 1.0
+                            },
+                            "attack": {
+                                "clip": "Attack1",
+                                "loop": false,
+                                "speed": 1.0
+                            },
+                            "die": {
+                                "clip": "Death",
+                                "loop": false,
+                                "speed": 1.0
+                            }
+                        }
                     }
                 ]
             }

src/common/animation/animator.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <queue>
 #include <unordered_map>
 #include <vector>
 
@@ -10,8 +11,9 @@ namespace our {
 #define MAX_BONES 110
 
     class Animator {
-        const Animation* currentAnimation;
+        const Animation* currentAnimation = nullptr;
         float currentTime;  // in ticks
+        float speed;        // animation speed
         // 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
@@ -55,15 +57,17 @@ namespace our {
     public:
         Animator() : finalBoneMatrices(MAX_BONES, glm::mat4(1.0f)) {}
 
-        void play(const Animation* anim, bool loop = true) {
+        // speed should be affected by the scale and movement speed of the real entity
+        void play(const Animation* anim, bool loop = true, float speed = 1.0f) {
             currentAnimation = anim;
             currentTime = 0.0f;
             this->loop = loop;
+            this->speed = speed;
         }
 
         void update(float deltaTime) {
             if (!currentAnimation) return;
-            currentTime += currentAnimation->ticksPerSecond * deltaTime;
+            currentTime += currentAnimation->ticksPerSecond * speed * deltaTime;
             if (loop) {
                 currentTime = std::fmod(currentTime, currentAnimation->duration);
             } else {

src/common/components/animation.cpp

@@ -13,32 +13,53 @@ namespace our {
                       << "\033[0m" << std::endl;
             return;
         }
-        autoplay = data.value("autoplay", autoplay);
-        loop = data.value("loop", loop);
-        speed = data.value("speed", speed);
-        clip = data.value("clip", "");
-        std::cout << "lodead animationComponent: " << clip << std::endl;
-        if (!clip.empty()) {
-            auto it = model->animations.find(clip);
-            if (it != model->animations.end()) {
-                if (autoplay) animator.play(&it->second, loop);
-            } else {
-                std::cerr << "\033[31mAnimation clip not found: " << clip << "\033[0m" << std::endl;
+
+        // deserializing clip:
+        if (data.contains("clips")) {
+            for (auto& [name, clipData] : data["clips"].items()) {
+                AnimationClip clip;
+
+                if (!clipData.contains("clip")) {
+                    std::cerr << "\033[31mClip missing 'clip' field: " << name << "\033[0m" << std::endl;
+                    continue;
+                }
+
+                clip.clip = clipData["clip"].get<std::string>();
+                if (clipData.contains("loop")) clip.loop = clipData["loop"].get<bool>();
+                if (clipData.contains("speed")) clip.speed = clipData["speed"].get<float>();
+                clips[name] = clip;
+                std::cout << "Loaded animation clip: " << name << " -> " << clip.clip << " (loop: " << clip.loop
+                          << ", speed: " << clip.speed << ")" << std::endl;
             }
         }
+        // default clip is the clip that will be played when the animation component is first initialized
+        defaultClip = data.value("default", "");
+        if (!defaultClip.empty()) {
+            play(defaultClip);
+        }
     }
 
-    void AnimationComponent::play(const std::string& clipName, bool loop) {
+    void AnimationComponent::play(const std::string& clipName, float speedScale) {
         if (!model) {
             std::cerr << "\033[31mCannot play animation: model is not set\033[0m" << std::endl;
             return;
         }
-        auto it = model->animations.find(clipName);
-        if (it != model->animations.end()) {
-            animator.play(&it->second, loop);
-        } else {
-            std::cerr << "\033[31mAnimation clip not found: " << clipName << "\033[0m" << std::endl;
+
+        auto clipIt = clips.find(clipName);
+        if (clipIt == clips.end()) {
+            std::cerr << "\033[31mClip not found: " << clipName << "\033[0m" << std::endl;
+            return;
+        }
+        AnimationClip& clip = clipIt->second;
+        auto animIt = model->animations.find(clip.clip);
+        if (animIt == model->animations.end()) {
+            std::cerr << "\033[31mAnimation not found in model: " << clip.clip << "\033[0m" << std::endl;
+            return;
         }
+        // speed scale is used so we can change the speed of the animation
+        // depending on the movement speed of the entity
+        // and the scale of the model (eg. a giant monster should have slower animations than a small character)
+        animator.play(&animIt->second, clip.loop, clip.speed * speedScale);
     }
 
 }  // namespace our

src/common/components/animation.hpp

@@ -7,21 +7,26 @@
 #include "model/model.hpp"
 
 namespace our {
+    struct AnimationClip {
+        std::string clip;
+        bool loop = false;
+        float speed = 1.0f;
+    };
+
     class AnimationComponent : public Component {
     public:
         Model* model;
         Animator animator;
-        std::string clip;
-        bool autoplay = false;
-        bool loop = false;
-        float speed = 1.0f;
+        std::string defaultClip;
+        // maps clip names to their corresponding animation clip data (animation name, loop, speed)
+        std::unordered_map<std::string, AnimationClip> clips;
         static std::string getID() {
             return "Animation";
         }
 
         void deserialize(const nlohmann::json& data) override;
 
-        void play(const std::string& clipName, bool loop = false);
+        void play(const std::string& clipName, float speedScale = 1.0f);
     };
 
 }  // namespace our

src/common/systems/animation-system.cpp

@@ -9,7 +9,11 @@ namespace our {
         for (auto entity : world->getEntities()) {
             AnimationComponent* animComp = entity->getComponent<AnimationComponent>();
             if (!animComp) continue;
-            animComp->animator.update(deltaTime * animComp->speed);
+            if (animComp->animator.isFinished()) {
+                std::string defaultAnimation = animComp->defaultClip.empty() ? "idle" : animComp->defaultClip;
+                animComp->play(defaultAnimation);
+            }
+            animComp->animator.update(deltaTime);
         }
     }
 }  // namespace our