fix bin animation, fix interpolate, make animation formats more generalized

Author: Astral-C

include/io/BinIO.hpp

@@ -9,15 +9,6 @@
 
 namespace BIN {
 
-    struct AnimInfo {
-    	bool mLoop { 0 };
-    	bool mPlaying { false };
-    	bool mLoaded { false };
-    	float mCurrentFrame { 0.0f }; // float so that we can change speed more easily
-    	float mPlaybackSpeed { 0.5f };
-    	uint32_t mFrameCount { 0 };
-    };
-
     #pragma pack(push, 1)
     struct Header {
         uint8_t Version { 0x02 };
@@ -192,12 +183,13 @@ namespace BIN {
     void InitShaders();
     void DestroyShaders();
 
+    class Animation;
+
     class Model
     {
     public:
         Header mHeader;
 
-        AnimInfo mAnim;
 
         std::map<uint16_t, TextureHeader> mTextureHeaders;
 
@@ -206,22 +198,18 @@ namespace BIN {
 
         std::map<uint16_t, Material> mMaterials;
         std::map<uint16_t, SceneGraphNode> mGraphNodes;
-        std::map<uint16_t, GraphNodeTrack> mAnimationTracks;
 
         std::vector<glm::vec3> mPositions;
         std::vector<glm::vec3> mNormals;
         std::vector<glm::vec2> mTexCoords;
         std::vector<glm::vec4> mColors;
 
         void ReadSceneGraphNode(bStream::CStream* stream, uint32_t index);
-        void DrawScenegraphNode(uint32_t idx, glm::mat4 transform);
+        void DrawScenegraphNode(uint32_t idx, glm::mat4 transform, Animation* animation);
 
         glm::vec3 bbMax {0, 0, 0}, bbMin {0, 0, 0};
 
-        void LoadAnimation(bStream::CStream* stream);
-        void ClearAnimation();
-
-        void Draw(glm::mat4* transform, int32_t id, bool selected);
+        void Draw(glm::mat4* transform, int32_t id, bool selected, Animation* animation = nullptr);
 
         void Load(bStream::CStream* stream);
         void Write(bStream::CStream* stream);
@@ -233,4 +221,29 @@ namespace BIN {
         ~Model();
     };
 
+    class Animation
+    {
+        bool mLoop { 0 };
+        bool mPlaying { false };
+        bool mLoaded { false };
+        float mTime { 0.0f }; // float so that we can change speed more easily
+        uint32_t mFrameCount { 0 };
+
+        std::map<uint16_t, GraphNodeTrack> mAnimationTracks;
+
+    public:
+        bool Playing() { return mPlaying; }
+        void ResetTracks();
+        void Play();
+        void Stop();    
+
+        glm::mat4 GetNodeFrame(uint16_t node);
+        void Step(float dt) { mTime += dt * 10; if(mTime >= mFrameCount && mLoop) { mTime = 0.0f; ResetTracks(); } else if(mTime >= mFrameCount) { mPlaying = false; } }
+
+        void Load(Model* model, bStream::CStream* stream);
+        
+        Animation(){}
+        ~Animation(){}
+    };
+
 }

include/io/KeyframeIO.hpp

@@ -15,8 +15,8 @@ struct LKeyframeCommon
 {
     float frame;
     float value;
-    float inslope { 1.0f };
-    float outslope { 1.0f };
+    float inslope { 0.0f };
+    float outslope { 0.0f };
 };
 
 class LTrackCommon

include/io/MdlIO.hpp

@@ -145,6 +145,7 @@ namespace MDL {
     };
 
     struct Bone {
+        int32_t ParentIndex { -1 };
         Bone* Parent { nullptr };
         glm::vec3 Translation;
         glm::quat Rotation;
@@ -154,6 +155,14 @@ namespace MDL {
             return glm::scale(glm::mat4(1.0f), Scale) * glm::toMat4(Rotation) * glm::translate(glm::mat4(1.0f), Translation);
         }
 
+        glm::mat4 ParentTransform(){
+            if(Parent != nullptr){
+                return Transform() * Parent->ParentTransform();
+            } else {
+                return Transform();
+            }
+        }
+
     };
 
     struct Weight {
@@ -208,15 +217,14 @@ namespace MDL {
     private:
         float mTime { 0.0f };
         float mSpeed { 0.1f };
-
-        uint32_t mPreviousKeyframe { 0 };
-        uint32_t mNextKeyframe { 1 };
+        float mEnd { 0.0f };
 
         std::vector<JointTrack> mJointAnimations;
     public:
-        void Step(){ mSpeed += mTime; }
+        void ResetTracks();
         glm::mat4 GetJoint(uint32_t id);
         void Load(bStream::CStream* stream);
+        void Step(float dt){ mTime += dt; if(mTime > mEnd){ mTime = 0.0f; ResetTracks(); } }
         Animation(){}
         ~Animation(){}
     };
@@ -245,8 +253,7 @@ namespace MDL {
         std::vector<Weight> mWeights;
         std::vector<Bone> mSkeleton;
 
-        void ConvertBonesToLocalSpace();
-        void ConvertBonesToWorldSpace();
+        void SetupInverseBindPose();
         void BuildScenegraphSkeleton(uint32_t index, uint32_t parentIndex);
         void InitSkeletonRenderer(uint32_t index, uint32_t parentIndex);
 

include/io/Util.hpp

@@ -78,4 +78,4 @@ struct Readable {
 };
 
 float InterpolateHermite(float factor, float timeA, float valueA, float outTangent, float timeB, float valueB, float inTangent);
-float MixTrack(LTrackCommon& track, uint32_t frameCount, float time, uint32_t& previousKey, uint32_t& nextKey);
+float MixTrack(LTrackCommon& track, float time, uint32_t& previousKey, uint32_t& nextKey);

include/scene/ModelViewer.hpp

@@ -25,7 +25,7 @@ namespace PreviewWidget {
 
     void InitPreview();
     void CleanupPreview();
-    void RenderPreview();
+    void RenderPreview(float dt);
 
     void PlayAnimation();
     void PauseAnimation();

src/DOM/BGRenderDOMNode.cpp

@@ -34,6 +34,7 @@ void LBGRenderDOMNode::RenderBG(float dt)
 		glm::vec3 skew;
 		glm::vec4 persp;
 		glm::decompose(*mTransform.get(), mScale, rotQuat, mPosition, skew, persp);
+		rotQuat = glm::conjugate(rotQuat);
 
 		glm::vec3 rot = glm::eulerAngles(rotQuat);
 		mRotation.x = (glm::degrees(rot.x) == 180.0f ? 0.0f : glm::degrees(rot.x));

src/UIUtil.cpp

@@ -234,6 +234,7 @@ void LUIUtility::RenderTransformUI(glm::mat4* transform, glm::vec3& translation,
 	glm::vec4 persp;
 
 	glm::decompose(*transform, oldScale, oldRot, oldPos, skew, persp);
+	oldRot = glm::conjugate(oldRot);
 
 	if (ImGui::TreeNode("Transform"))
 	{