Skeleton.hpp

#pragma once 
#ifndef KJY_ANIM_ENGINE_SKELETON_HPP_
#define KJY_ANIM_ENGINE_SKELETON_HPP_

#include <vector>
#include <glm/glm.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/rotate_vector.hpp>
#include <components/inheritable/drawable.hpp>
#include <components/attachable/KeyframeAnimation.hpp>
#include "EntitiesBase.hpp"

#pragma warning(disable: 4250) // Disable warnings about dominance in MSVC

class Bone : virtual public WorldEntity, virtual public PoseableComponent, virtual public DrawableInterfaceComponent{
 public:
   Bone(){}
   Bone(const glm::mat4& inverse_bind);
   Bone(const glm::mat4& inverse_bind, const Pose& pose);
   Bone(const glm::vec3& head, const glm::vec3& tail, float roll);

   glm::vec3 getHead() const;
   glm::vec3 getTail() const;
   float getLength() const;
   virtual void draw(const MVPset& MVP, Program* shader = nullptr) override;
   virtual bool isHidden() const override {return(true);}
   virtual bool canOverrideShader() const override {return(false);}
   virtual bool requiresOverrideShader() const override {return(false);}

   virtual void configureDrawScale(Pose* pose) const {(*pose)*= glm::scale(glm::vec3(getLength()));}

   // FML
   virtual const Pose& getPose() const override {return(_pose);}
   virtual void setPose(const Pose& pose) override {_pose = pose;_cached_joint_dirty = true;}

   virtual void unlink() override;
   virtual void link(Entity* parent) override;
   virtual bool hasParentBone() const {return(_parent_bone != nullptr);}

   virtual glm::mat4 getBoneLocalTransform() const;
   virtual glm::mat4 getBoneWorldTransform() const;
   virtual glm::mat4 getInverseBindTransform() const;
   virtual glm::mat4 getJointTransform() const;
   virtual glm::mat4 getJointTransform();

   int legacy_parent = -1;
   std::vector<int> legacy_children;

   int joint_index = -1;

   enum class DrawMode{lines, axes /*TODO: Add octohedron*/};
   DrawMode draw_mode = DrawMode::lines;

   bool use_edit_color = false;
   const static glm::vec3 edit_color;
   const static glm::vec3 pose_color;

 protected:
   friend class Skeleton;

   void _update_joint_transform_cache();

   Pose _pose;
   glm::mat4 _inverse_bind;
   float _length = 1.0;

   Bone* _parent_bone = nullptr;
   bool _cached_joint_dirty = true;
   glm::mat4 _cached_joint_transform;
};

class Skeleton : virtual public WorldEntity, virtual public PoseableComponent{
 public:
    virtual const Pose& getPose() const override {return(skeleton_entity_pose);}
    virtual Pose& getMutablePose() {return(skeleton_entity_pose);}
    virtual void setPose(const Pose& pose) override {this->skeleton_entity_pose = pose;}

    virtual Pose getBoneSkinningPose(size_t index) const = 0;

    virtual void addBone(Bone* bone) {bones.push_back(bone); addChild(bone);}
    virtual void setBonePose(size_t index, const Pose& pose) = 0;
    virtual Bone* getBone(size_t index) {return(bones.at(index));}
    virtual const Bone* getBone(size_t index) const {return(bones.at(index));}
    virtual const std::vector<Bone*>& getBonesArray() const {return(bones);}
    virtual size_t numBones() const {return(bones.size());}

    virtual void resetPose() = 0;

 protected:
  /* Collection of bones creating a hierarchical skeleton. All bones are also
   * standard child entities of the skeleton, but this allows faster access for
   * some operations. */
  std::vector<Bone*> bones;

  /* World pose of the entire skeleton entity */
  Pose skeleton_entity_pose; 
};

/* WARNING LocalTransformSkeleton is DEPRICATED, try to use GlobalTransformSkeleton where possible */
class LocalTransformSkeleton : public Skeleton{
 public:
    /* Upload skeleton pose into the active shader at at location of `uniform mat4 skeletonPose[SKELETON_SIZE];`
     * or if parameter uniform_name is provided, at location of `uniform mat4 <uniform_name>[SKELETON_SIZE];`
     */
   // Move to SkinnedMeshEntity // virtual void uploadSkeletonPose(Program* shader = nullptr, const std::string& uniform_name = std::string()) const;

    /* Draw the skeleton. This function does not enforce depth checking so that
     * the caller can choose whether or not to make the skeleton visible through
     * other rendered elements. */
    virtual void drawSkeletonRestPose(const MVPset& MVP);
    virtual void drawSkeletonFinalPose(const MVPset& MVP);


    /* Get world space `Pose` as originally set when skeleton was created. */
    virtual Pose getBoneRestPose(size_t index) const;
    /* Get final world space `Pose` of a bone after posing. */
    virtual Pose getBoneFinalPose(size_t index) const;
    /* Get `Pose` for transforming things skinned by bone at `index` */
    virtual Pose getBoneSkinningPose(size_t index) const override;

    virtual void addBone(Bone* bone) override {bones.push_back(bone); addChild(bone); bone_poses.emplace_back();}
    virtual void setBonePose(size_t index, const Pose& pose) override {bone_poses.at(index) = pose;}

    virtual void resetPose() override;

 protected:
    /* Get the world space pose of the bone at index, but without applying the rest pose
    * transformation of the bone */
    virtual Pose getWorldBoneTransform(size_t index) const;

    /* Collection of Poses which are applied on top of the rest pose of the
     * skeleton to allow the skeleton to be posed hierarchically */
    std::vector<Pose> bone_poses;
};

class GlobalTransformSkeleton : public Skeleton{
 public:

   virtual Pose getBoneSkinningPose(size_t index) const override;

   virtual void init();

   virtual void addBone(Bone* bone) override {bones.push_back(bone);}

   /* Construct skeleton with root bone `root`, and all it's children. Completely erases existing skeleton */
   virtual void setBonesRecursive(Bone* root);

   virtual Bone* getBone(size_t index) override {return(bones.at(index));}
   virtual const Bone* getBone(size_t index) const override {return(bones.at(index));}
   virtual size_t numBones() const override {return(bones.size());}

   virtual Bone* getRootBone() {return(root);}

   virtual void setBonePose(size_t index, const Pose& pose) override {bones.at(index)->setPose(pose);}

   virtual void resetPose() override;
   /* Removes all bones from Entity */
   virtual void clearSkeleton();

 protected:

  virtual void _addBonesRecursive(Bone* bone);

   Bone* root = nullptr;

 protected:
   bool _inited = false;
};

#endif