Add Skeletal Animation Component

.gitignore

@@ -403,4 +403,8 @@ FodyWeavers.xsd
 # /** makes entire folders or formats that should be excluded (bin for example) are ignored
 !Engine/libs/FidelityFX-SDK-v1.1.4/**
 Engine/libs/FidelityFX-SDK-v1.1.4/sdk/build
-!Engine/libs/FidelityFX-SDK-v2.0.0/**
+!Engine/libs/FidelityFX-SDK-v2.0.0/**
+
+# Include bin directories under Tools
+!Tools/**/bin/
+!Tools/**/bin/**

Engine/common_gl/source/GLVertexArray.cpp

@@ -17,42 +17,89 @@ void GLVertexArray::Initialize()
 
 void GLVertexArray::AddVertexBuffer(GLVertexBuffer&& buffer, size_t size, std::initializer_list<GLAttributeLayout> layout)
 {
-	//glCheck(glBindVertexArray(vaoHandle));
+	////glCheck(glBindVertexArray(vaoHandle));
 
-	GLuint vboHandle = buffer.GetHandle();
-	//glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboHandle));
+	//GLuint vboHandle = buffer.GetHandle();
+	////glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboHandle));
 
-	//for (int index = 0; index < layout.size(); ++index)
-	//{
-	//	const GLAttributeLayout* attribute = layout.begin() + index;
+	////for (int index = 0; index < layout.size(); ++index)
+	////{
+	////	const GLAttributeLayout* attribute = layout.begin() + index;
+
+	////	glCheck(glEnableVertexArrayAttrib(vaoHandle, index));
+	////	glCheck(glVertexAttribPointer(index, attribute->component_dimension, attribute->component_type, attribute->normalized, size, reinterpret_cast<const void*>(attribute->relative_offset)));
+	////}
+
+	////glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
+	////glCheck(glBindVertexArray(0));
 
-	//	glCheck(glEnableVertexArrayAttrib(vaoHandle, index));
-	//	glCheck(glVertexAttribPointer(index, attribute->component_dimension, attribute->component_type, attribute->normalized, size, reinterpret_cast<const void*>(attribute->relative_offset)));
+	////bind a buffer to a vertex buffer bind point
+	//glCheck(glVertexArrayVertexBuffer(vaoHandle, 0, vboHandle, 0, static_cast<GLsizei>(size)));
+
+	//for (const GLAttributeLayout& attribute : layout)
+	//{
+	//	glCheck(glEnableVertexArrayAttrib(vaoHandle, attribute.vertex_layout_location));
+	//	switch (attribute.component_type)
+	//	{
+	//	case GL_FLOAT:
+	//		//For Float
+	//		glCheck(glVertexArrayAttribFormat(vaoHandle, attribute.vertex_layout_location, attribute.component_dimension, attribute.component_type, attribute.normalized, attribute.relative_offset));
+	//		break;
+	//	case GL_INT:
+	//	case GL_UNSIGNED_INT:
+	//		//For Int
+	//		glCheck(glVertexArrayAttribIFormat(vaoHandle, attribute.vertex_layout_location, attribute.component_dimension, attribute.component_type, attribute.relative_offset));
+	//		break;
+	//	}
+	//	glCheck(glVertexArrayAttribBinding(vaoHandle, attribute.vertex_layout_location, 0));
 	//}
 
-	//glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
-	//glCheck(glBindVertexArray(0));
+	GLuint vboHandle = buffer.GetHandle();
+
+	// Save current VAO state
+	GLint previousVAO;
+	glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &previousVAO);
 
-	//bind a buffer to a vertex buffer bind point
-	glCheck(glVertexArrayVertexBuffer(vaoHandle, 0, vboHandle, 0, static_cast<GLsizei>(size)));
+	// Bind VAO and VBO
+	glCheck(glBindVertexArray(vaoHandle));
+	glCheck(glBindBuffer(GL_ARRAY_BUFFER, vboHandle));
 
 	for (const GLAttributeLayout& attribute : layout)
 	{
-		glCheck(glEnableVertexArrayAttrib(vaoHandle, attribute.vertex_layout_location));
+		glCheck(glEnableVertexAttribArray(attribute.vertex_layout_location));
+
 		switch (attribute.component_type)
 		{
 		case GL_FLOAT:
-			//For Float
-			glCheck(glVertexArrayAttribFormat(vaoHandle, attribute.vertex_layout_location, attribute.component_dimension, attribute.component_type, attribute.normalized, attribute.relative_offset));
+			// For Float attributes
+			glCheck(glVertexAttribPointer(
+				attribute.vertex_layout_location,
+				attribute.component_dimension,
+				attribute.component_type,
+				attribute.normalized ? GL_TRUE : GL_FALSE,
+				static_cast<GLsizei>(size),  // stride
+				reinterpret_cast<const void*>(static_cast<uintptr_t>(attribute.relative_offset))
+			));
 			break;
 		case GL_INT:
 		case GL_UNSIGNED_INT:
-			//For Int
-			glCheck(glVertexArrayAttribIFormat(vaoHandle, attribute.vertex_layout_location, attribute.component_dimension, attribute.component_type, attribute.relative_offset));
+			// For Integer attributes (boneIDs)
+			glCheck(glVertexAttribIPointer(
+				attribute.vertex_layout_location,
+				attribute.component_dimension,
+				attribute.component_type,
+				static_cast<GLsizei>(size),  // stride
+				reinterpret_cast<const void*>(static_cast<uintptr_t>(attribute.relative_offset))
+			));
 			break;
 		}
-		glCheck(glVertexArrayAttribBinding(vaoHandle, attribute.vertex_layout_location, 0));
 	}
+
+	// Unbind
+	glCheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
+
+	// Restore previous VAO state
+	glCheck(glBindVertexArray(previousVAO));
 }
 
 void GLVertexArray::SetIndexBuffer(GLIndexBuffer&& buffer)

Engine/include/BasicComponents/Physics3D.hpp

@@ -11,9 +11,6 @@
 
 #include "Interface/IComponent.hpp"
 #include "Object.hpp"
-#ifdef _DEBUG
-#include "BasicComponents/DynamicSprite.hpp"
-#endif
 
 enum class CollisionDetectionMode
 {
@@ -29,13 +26,7 @@ struct CollisionResult
 	glm::vec3 collisionNormal = { 0.f, 0.f, 0.f };
 };
 
-#ifdef _DEBUG
-struct Point3D
-{
-	glm::vec3 pos = { 0.f,0.f,0.f };
-	DynamicSprite* sprite = nullptr;
-};
-#endif
+
 
 enum class BodyType3D
 {
@@ -113,6 +104,7 @@ class Physics3D : public IComponent
 
 	//2d->3d
 	std::vector<glm::vec3> GetCollidePolyhedron() { return collidePolyhedron; }
+	float GetSphereRadius() const { return sphere.radius; }
 	bool CheckCollision(Object* obj);
 	bool CollisionPP(Object* obj, Object* obj2);
 	bool CollisionSS(Object* obj, Object* obj2);
@@ -168,8 +160,5 @@ class Physics3D : public IComponent
 	Sphere sphere;
 
 	//2d->3d
-#ifdef _DEBUG
-	void AddPoint(glm::vec3 pos);
-	std::vector<Point3D> points;
-#endif
+
 };

Engine/include/BasicComponents/SkeletalAnimationStateMachine.hpp

@@ -34,6 +34,9 @@ class SkeletalAnimationStateMachine : public IComponent
     std::string GetCurrentStateName() const;
 
 private:
+	void AddStateForQueue(const std::string& name, std::shared_ptr<SkeletalAnimation> anim);
+    void AddStateForQueue(const std::string& name, const std::string& animationFilePath);
+    void ChangeStateForQueue(const std::string& name, bool isLoop = true, float speed = 1.f, float blendDuration = 0.25f);
     // Internal class representing a single animation state
     class State
     {

Engine/include/BasicComponents/SkeletalAnimator.hpp

@@ -8,7 +8,7 @@
 #include "glm/glm.hpp"
 #include "glm/gtc/quaternion.hpp"
 #include <vector>
-#include <memory> 
+#include <memory>
 #include <map>
 #include <string>
 
@@ -25,9 +25,9 @@ enum class PlaybackState
 struct RootMotionBakeOptions
 {
     bool bakePositionX = false;
-    bool bakePositionY = true;
+    bool bakePositionY = true;  // Remove vertical movement by default
     bool bakePositionZ = false;
-    bool bakeRotation = true;
+    bool bakeRotation = true;   // Remove rotation by default
 };
 
 class SkeletalAnimator : public IComponent
@@ -39,16 +39,17 @@ class SkeletalAnimator : public IComponent
     void Update(float dt) override;
     void End() override;
 
+    // Animation Control
     void PlayAnimation(SkeletalAnimation* newAnimation, bool isLoop = true, float speed = 1.f, float blendDuration = 0.25f);
-
     void Play();
     void Pause();
     void Stop();
 
+    // Getters
     SkeletalAnimation* GetCurrentAnimation() const { return currentAnimation; }
-    const std::vector<glm::mat4>& GetFinalBoneMatrices() const;
+    const std::vector<glm::mat4>& GetFinalBoneMatrices()  const { return finalBoneMatrices; }
     const std::map<std::string, glm::mat4>& GetGlobalBoneTransforms() const { return globalBoneTransforms; }
-    float GetCurrentAnimationTime() const;
+    float GetCurrentAnimationTime() const { return currentTime; }
     float GetDuration() const;
     float GetSpeed() const { return animationSpeed; }
     const RootMotionBakeOptions& GetBakeOptions() const { return bakeOptions; }
@@ -59,47 +60,52 @@ class SkeletalAnimator : public IComponent
     const std::string& GetRootBoneName() const { return rootBoneName; }
     bool IsScrubbing() const { return isScrubbing; }
 
-    void SetLooping(bool loop);
-    void SetCurrentAnimationTime(float time);
+    // Setters
+    void SetLooping(bool loop) { isLooping = loop; };
+    void SetCurrentAnimationTime(float time) { currentTime = time; justLooped = false; };
     void SetSpeed(float speed) { animationSpeed = std::max(0.0f, speed); }
     void SetEnableRootMotion(bool enabled) { enableRootMotion = enabled; }
     void SetBakeOptions(const RootMotionBakeOptions& options) { bakeOptions = options; }
     void SetRootBoneName(const std::string& name) { rootBoneName = name; }
     void SetIsScrubbing(bool scrubbing) { isScrubbing = scrubbing; }
 
-    // Immediately updates root motion transform based on absolute time
+    // Apply root motion transform directly for scrubbing or stopping
     void UpdateRootMotionTransformToTime(float time);
 
 private:
-    glm::mat4 CalculateAbsoluteRootMotion(SkeletalAnimation* anim, float time, glm::mat4 startTransform);
+    glm::mat4 GetRootTransformAtTime(SkeletalAnimation* anim, float time);
+    glm::mat4 ExtractRootMotionDelta(SkeletalAnimation* anim, float timeStart, float timeEnd);
+
+    void CalculateBoneTransform(const AssimpNodeData* node, glm::mat4 parentTransform, const glm::mat4& encodeMatrix, bool parentIsDummy = false);
+    bool HasDummyNodeParent(const AssimpNodeData* node, const std::string& boneName) const;
 
-    void CalculateBoneTransform(const AssimpNodeData* node, glm::mat4 parentTransform);
 
-    // Skinning and bone hierarchy
+    // Skinning Data
     std::vector<glm::mat4> finalBoneMatrices;
     std::map<std::string, glm::mat4> globalBoneTransforms;
 
-    // Current animation state
+    // Current Animation State
     SkeletalAnimation* currentAnimation = nullptr;
     PlaybackState playbackState = PlaybackState::Stopped;
     float currentTime = 0.0f;
     float animationSpeed = 1.0f;
-    bool isLooping = true;
-    bool justLooped = false;
+    bool  isLooping = true;
+    bool  justLooped = false;
 
-    // Blending
+    // Blending Data
     SkeletalAnimation* previousAnimation = nullptr;
     float previousTime = 0.0f;
     float blendFactor = 1.0f;
     float currentBlendDuration = 0.0f;
+    float lastRootMotionTime = 0.0f;
 
-    // Root motion
-    bool enableRootMotion = false;
-    bool isScrubbing = false; // Whether the UI slider is being manipulated
+    // Root Motion Data
+    bool        enableRootMotion = false;
+    bool        isScrubbing = false;
     std::string rootBoneName = "";
     RootMotionBakeOptions bakeOptions;
-    glm::mat4 rootMotionStartTransform = glm::mat4(1.0f);
-    glm::mat4 previousRootMotionStartTransform = glm::mat4(1.0f);
+
+    // Hierarchy
 
     const int maxBones = 128;
 };

Engine/include/BufferWrapper.hpp

@@ -194,9 +194,9 @@ struct BufferWrapper
 //			std::unique_ptr<DXConstantBuffer<ThreeDimension::FragmentUniform>>
 //		> fragmentUniformBuffer;
 //		std::variant<
-//			std::monostate,
-//			std::unique_ptr<GLUniformBuffer<ThreeDimension::Material>>,
-//			std::unique_ptr<DXConstantBuffer<ThreeDimension::Material>>
+//		 std::monostate,
+//		 std::unique_ptr<GLUniformBuffer<ThreeDimension::Material>>,
+//		 std::unique_ptr<DXConstantBuffer<ThreeDimension::Material>>
 //		> materialUniformBuffer;
 //
 //		void Initialize()
@@ -279,6 +279,10 @@ struct BufferWrapper
 		std::map<std::string, ThreeDimension::BoneInfo> boneInfoMap;
 		int boneCount = 0;
 
+		// Global inverse transform from the MODEL's root node (not animation file)
+		glm::mat4 modelGlobalInverseTransform{ 1.0f };
+		glm::mat4 meshNormalizationTransform{ 1.0f };
+
 		// GPU Buffers
 		//std::variant<std::monostate, GLBuffer, VKBuffer, DXBuffer> buffer;
 		std::variant<

Engine/include/ComponentTypes.hpp

@@ -25,6 +25,10 @@ inline ComponentTypes StringToComponent(const std::string& string)
         return ComponentTypes::PHYSICS3D;
     else if (string == "LIGHT")
         return ComponentTypes::LIGHT;
+    else if (string == "SKETANIMATOR")
+        return ComponentTypes::SKETANIMATOR;
+    else if (string == "SKETANIMASTATE")
+        return ComponentTypes::SKETANIMASTATE;
 
     return ComponentTypes::INVALID;
 }
@@ -39,6 +43,10 @@ inline std::string ComponentToString(ComponentTypes type)
         return "PHYSICS3D";
     else if (type == ComponentTypes::LIGHT)
         return "LIGHT";
+    else if (type == ComponentTypes::SKETANIMATOR)
+        return "SKETANIMATOR";
+    else if (type == ComponentTypes::SKETANIMASTATE)
+        return "SKETANIMASTATE";
 
     return "INVALID";
 }

Engine/include/Logger.hpp

@@ -24,6 +24,7 @@ enum class LogCategory
 	Level,
 	Object,
 	Physics,
+	SkelAnimation,
 	Sound,
 	Camera,
 	Game,

Engine/include/Material.hpp

@@ -54,13 +54,14 @@ namespace ThreeDimension
 
 	struct alignas(16) Vertex
 	{
-		glm::vec3 position;
-		glm::vec3 normal;
-		glm::vec2 uv;
+		glm::vec3 position{};
+		glm::vec3 normal{};
+		glm::vec2 uv{};
 		int texSubIndex{ 0 };
 
-		int boneIDs[MAX_BONE_INFLUENCE];
-		float weights[MAX_BONE_INFLUENCE];
+		// Initialize bone data with default values
+		int boneIDs[MAX_BONE_INFLUENCE]{ -1, -1, -1, -1 };
+		float weights[MAX_BONE_INFLUENCE]{ 0.0f, 0.0f, 0.0f, 0.0f };
 	};
 
 	// @TODO Should add alignas(16) for 3D pipeline but mesh pipeline does not require alignas(16) for Structured Buffer
@@ -75,8 +76,8 @@ namespace ThreeDimension
 		int texSubIndex{ 0 };
 
 		// Bone IDs and Weights (For simplicity in this guide, we use raw types not packed)
-		glm::ivec4 boneIDs;
-		glm::vec4 weights;
+		int boneIDs[MAX_BONE_INFLUENCE];
+		float weights[MAX_BONE_INFLUENCE];
 	};
 
 	// For StaticSprite, Check Material.hpp ThreeDimension::DynamicQuantizedVertex for StaticQuantizedVertex
@@ -102,7 +103,7 @@ namespace ThreeDimension
 		glm::mat4 decode;
 		glm::vec4 color;
 		// @TODO move to push constants later
-		glm::vec3 viewPosition;
+		glm::vec4 viewPosition;
 
 		// Array of final bone matrices for shader
 		glm::mat4 finalBones[MAX_BONES];