Skeleton.hpp

Go to the documentation of this file.

// Written by Koen Buitenhuis
#pragma once

#include <ThirdParty/glm/glm/glm.hpp>
#include <ThirdParty/glm/glm/gtc/quaternion.hpp>
#include <ThirdParty/assimp/include/assimp/scene.h>
#include <ThirdParty/assimp/include/assimp/Importer.hpp>

#include <ThirdParty/EASTL-master/include/EASTL/shared_ptr.h>
#include <ThirdParty/EASTL-master/include/EASTL/vector.h>
#include <ThirdParty/EASTL-master/include/EASTL/map.h>

#include "Engine/Texture/Texture.hpp"

namespace Engine {

    class ENGINE_API Skeleton
    {
    protected:

        struct AnimationNode;

    public:
        Skeleton(const aiScene* scene);

        void LoadAnimationSet(const aiScene* scene, eastl::vector<eastl::string> names = {});

        virtual ~Skeleton();

        eastl::vector<eastl::string> GetAnimations();

        void SetAnimation(eastl::string animation, bool resetTime);

        float GetAnimationDuration(size_t animation);
        
        bool HasAnimations();

        Texture* GetAnimationData(size_t animation);

        size_t GetAnimationIndex(eastl::string animation);

        float GetAnimationTicksPerSecond(size_t animation);

        typedef struct Bone {
            eastl::string name;
            int boneDataIndex;
            glm::mat4 transform;
            glm::mat4 defaultTransform;
            glm::mat4 offset;
            struct Bone* parent;
            aiNode* node;
            eastl::vector<struct Bone*> childBones;
        }Bone_t;

        eastl::map<eastl::string, Bone_t*> GetBoneMap();

        Bone_t* GetRootBone();

        void SetName(eastl::string name);

        eastl::string GetName();

    protected:

        bool animated;

        typedef struct Animation {
            eastl::string name;
            eastl::vector<struct AnimationNode> nodes;
            float duration; // In ticks
            float ticksPerSecond;
            eastl::shared_ptr<Texture> texture;
        }Animation_t;

        typedef struct {
            glm::mat4 transform;
        }BoneData_t;

        typedef struct {
            float time;
            glm::vec3 position;
        }AnimationPositionKey_t;

        typedef struct {
            float time;
            glm::quat rotation;
        }AnimationRotationKey_t;

        typedef struct {
            float time;
            glm::vec3 scale;
        }AnimationScalingKey_t;

        typedef struct AnimationNode {
            Bone_t* bone;
            eastl::vector<AnimationPositionKey_t> positionKeys;
            eastl::vector<AnimationRotationKey_t> rotationKeys;
            eastl::vector<AnimationScalingKey_t>    scalingKeys;
            aiAnimBehaviour preAnimBehaviour;
            aiAnimBehaviour postAnimBehaviour;
        }AnimationNode_t;

        Bone_t * rootBone;

        eastl::vector<BoneData_t> boneData;

        eastl::map<eastl::string, size_t> animationMap;

        eastl::vector<Animation_t*> animations;

        const aiScene* scene;

        Animation_t* currentAnimation;

        size_t currentAnimationIndex;

        float time;

        float speed;

        bool paused;

        bool looping;

        eastl::map<eastl::string, Bone_t*> boneMap;

        eastl::string name;

        void ReadBones(Bone_t* bone, aiNode* node);

        void DestroyBone(Bone_t* bone);

        void SetBoneTransform(eastl::string bone, glm::mat4 transform);

        void SetBoneTransform(Bone_t* bone, glm::mat4 transform);

        void UpdateBoneTransformData(Bone_t* bone);

        void UpdateBoneTreeTransformData();

        void Update(float deltaTime);

        virtual void UpdateBoneBuffers();

        glm::mat4 InterpolateScale(float time, AnimationNode_t node);
        glm::mat4 InterpolateRotation(float time, AnimationNode_t node);
        glm::mat4 InterpolatePosition(float time, AnimationNode_t node);

        glm::mat4 TransformToMat4(aiMatrix4x4 transform);
    };

}