feat: animations (#45)

* Add animation system with skeleton and bone support

- Implemented Animation, Animator, Bone, and Skeleton classes to handle skeletal animations.
- Added AnimationComponent to manage animations within entities.
- Integrated animation loading in the Model class, supporting multiple animations.
- Created AnimationSystem to update animations based on input and delta time.
- Enhanced ForwardRenderer to support animated meshes with bone transformations.
- Introduced UniformBuffer class for efficient bone matrix handling in shaders.
- Updated MeshRendererComponent to indicate if a mesh uses bones for skinning.
- Added deserialization for AnimationComponent to load animation data from JSON.

* fix(animation): fix inlcudes

* feat(animation): implement skinned animation support in vertex shader

* refactor(animation): update animation system and remove skeleton.cpp

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

* refactor(animation): update processNode to use pointer for skeleton nodes

* fix(animation): correct isFinished logic to account for looping animations

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

* refactor(animation): clean up bones uniform buffer management and remove commented code

* fix(animation): optimize bone transformation calculation by reusing global inverse matrix

* perf(model): add optimize graph flag

* fix(animation): handle left-handed axis Y up models

* fix(c_cpp_properties): add include paths for animator.hpp bug

* feat(animation): add new enemy model and animations for 'mundo'

* feat(animation): add new enemy models and animations for 'shaco' and 'yummi'

* refactor(animation): simplify BoneAnimation constructor by removing BoneID parameter

* feat(animation): enhance model loading to support animations and update asset paths

* chore: fix compilation error

* feat(animation): add playDuration method to AnimationComponent for timed playback of animations

* refactor(animation): remove unused includes from animation-system.hpp

* refactor(model): remove unused scene parameter from processVertexBoneData methods

* refactor(uniform-buffer): disable copying of UniformBuffer class

* refactor(uniform-buffer): add assertions for input validation in UniformBuffer constructor and update method

* refactor(animation): clear ununsed enemy definitions in playground configurations

* fix(model): set global inverse transform for skeleton when animations are present

* fix(animator): include cmath for std::fmod usage

* fix(animator): update MAX_BONES definition to modern c++ and change to 128

* fix(animation): enhance key interpolation to handle empty vectors and avoid division by zero

* feat(shader): add getUniformBlockBinding caching

* fix(animation): initialize model and defaultClip to avoid uninitialized usage

* feat(renderer): optimize bone matrix updates by caching last uploaded animator

* feat(animation): enhance play method to support force restart and improve isFinished logic

* fix(animation): ensure animator updates before checking if animation is finished

* fix(animation): correct isFinished logic to account for looping animations

* fix(animation): use findBone instead of manual reading from animation channels

* fix(model): fix cache key for model texture

Author: AhmedAmrNabil

.vscode/c_cpp_properties.json

@@ -7,7 +7,18 @@
             "browse": {
                 "path": ["${workspaceFolder}/src", "${workspaceFolder}/vendor"]
             },
-            "defines": ["COLLISION_DEBUG_DRAW"]
+            "defines": ["COLLISION_DEBUG_DRAW"],
+            "includePath": [
+                "src/common",
+                "src/game",
+                "src/states",
+                "vendor/bullet3/src",
+                "vendor/imgui",
+                "vendor/imgui/imgui_impl",
+                "vendor/glad/include",
+                "vendor/glm",
+                "vendor/utils"
+            ]
         }
     ],
     "version": 4

CMakeLists.txt

@@ -257,6 +257,7 @@ add_executable(${PROJECT_NAME}
     src/common/components/free-camera-controller.cpp
     src/common/components/movement.cpp
     src/common/components/light.cpp
+    src/common/components/animation.cpp
 
     src/game/components/collider.cpp
     src/game/components/enemy.cpp
@@ -272,6 +273,7 @@ add_executable(${PROJECT_NAME}
 
     src/common/systems/forward-renderer.cpp
     src/common/systems/audio-system.cpp
+    src/common/systems/animation-system.cpp
 
     src/common/audio/audio-utils.cpp
     src/common/components/audio-source.cpp

assets/gltf/enemies/mundo.glb

@@ -16,24 +16,54 @@ out Varyings {
     mat3 TBN;
 } vs_out;
 
+#define MAX_BONES 128
 uniform mat4 transform;
 uniform mat4 model;
+layout(std140) uniform Bones {
+    mat4 bones[MAX_BONES];
+};
+uniform bool hasBones;
 
 void main() {
-    gl_Position = transform * vec4(position, 1.0);
+    vec4 skinnedPosition = vec4(0.0);
+    vec3 skinnedNormal = vec3(0.0);
+    vec3 skinnedTangent = vec3(0.0);
+    float totalWeight = 0.0;
 
+    if(hasBones) {
+        for(int i = 0; i < 4; i++) {
+            if (bone_ids[i] < 0 || bone_ids[i] >= MAX_BONES)
+                continue;
+            mat4 boneMatrix = bones[bone_ids[i]];
+            float weight = weights[i];
+            totalWeight += weight;
+
+            skinnedPosition += weight * (boneMatrix * vec4(position, 1.0));
+            skinnedNormal += weight * (mat3(boneMatrix) * normal);
+            skinnedTangent += weight * (mat3(boneMatrix) * tangent.xyz);
+        }
+        if (totalWeight <= 0.0) {
+            skinnedPosition = vec4(position, 1.0);
+            skinnedNormal = normal;
+            skinnedTangent = tangent.xyz;
+        }
+    } else {
+        skinnedPosition = vec4(position, 1.0);
+        skinnedNormal = normal;
+        skinnedTangent = tangent.xyz;
+    }
+
+    gl_Position = transform * skinnedPosition;
+    vs_out.worldPos = vec3(model * skinnedPosition);
     vs_out.color = color;
     vs_out.tex_coord = tex_coord;
-    vs_out.worldPos = vec3(model * vec4(position, 1.0));
 
-    // normal matrix — handles non-uniform scaling correctly
     mat3 normalMatrix = transpose(inverse(mat3(model)));
-    vec3 N = normalize(normalMatrix * normal);
+    vec3 N = normalize(normalMatrix * skinnedNormal);
     vs_out.worldNormal = N;
 
-    // TBN matrix for normal mapping
-    vec3 T = normalize(normalMatrix * tangent.xyz);
-    T = normalize(T - dot(T, N) * N);  // re-orthogonalize
-    vec3 B = cross(N, T) * tangent.w;  // bitangent with handedness
+    vec3 T = normalize(normalMatrix * skinnedTangent);
+    T = normalize(T - dot(T, N) * N);
+    vec3 B = cross(N, T) * tangent.w;
     vs_out.TBN = mat3(T, B, N);
 }