SkinnedMeshEntity.hpp

#pragma once
#ifndef KJY_ANIM_ENGINE_SKINNED_MESH_HPP_
#define KJY_ANIM_ENGINE_SKINNED_MESH_HPP_

#include <vector>
#include <glm/glm.hpp>
#include <OOOGL/MidLevel/Geometry.hpp>
#include "EntitiesBase.hpp"
#include "MeshEntity.hpp"
#include "Skeleton.hpp"
#include <components/attachable/SkeletonAnimator.hpp>

using namespace OOOGL;

/* A `TriangleMesh` with an added vertex weights buffer.
 * Attributes are layed out as follows:
 *    0: vec3 vertex position
 *    1: vec3 vertex normals
 *    2: vec2 texture coordinates
 *    3: ivec4 Vertex joint assignments
 *    4: vec4 Vertex weights
*/
class SkinnedTriangleMesh : public TriangleMesh{
 public:
    SkinnedTriangleMesh();
    SkinnedTriangleMesh(
        const std::vector<glm::vec3>& vertices, const std::vector<GLuint> elements,
        const std::vector<glm::vec3>& normals, const std::vector<glm::vec2>& texcoords,
        const std::vector<glm::uvec4>& joints, const std::vector<glm::vec4>& weights, bool skip_gpu_upload = false
    );

    virtual const std::vector<glm::uvec4>& getJoints() const {return(cpu_joints_buffer_);}
    virtual std::vector<glm::uvec4>& getMutableJoints() {return(cpu_joints_buffer_); sync_status_ = GpuSyncStatus::GPU_STALE;}
    virtual void replaceJoints(const std::vector<glm::uvec4>& new_buffer) {cpu_joints_buffer_ = new_buffer; sync_status_ = GpuSyncStatus::GPU_STALE;}
    
    virtual const std::vector<glm::vec4>& getVertexWeights() const {return(cpu_weights_buffer_);}
    virtual std::vector<glm::vec4>& getMutableVertexWeights() {return(cpu_weights_buffer_); sync_status_ = GpuSyncStatus::GPU_STALE;}
    virtual void replaceVertexWeights(const std::vector<glm::vec4>& new_buffer) {cpu_weights_buffer_ = new_buffer; sync_status_ = GpuSyncStatus::GPU_STALE;}

    ArrayBuffer vertex_joints_buffer;
    ArrayBuffer vertex_weights_buffer;

   /* Leaving these public to avoid headache of writing accessors. It'll just be a warning if materials indices are nonsense */
   std::vector<MaterialInterface*> materials; 
   std::vector<int> material_indices;

 protected:

    virtual void _uploadData() override;

    std::vector<glm::uvec4> cpu_joints_buffer_;
    std::vector<glm::vec4> cpu_weights_buffer_;
};

class SkinnedMeshEntity : public MeshEntity {
 public:
   virtual void draw(const MVPset& MVP, Program* shader = nullptr) override;
   virtual bool canOverrideShader() const override {return(true);}
   virtual bool requiresOverrideShader() const override {return(false);}
   virtual const Pose& getPose() const override; 
   virtual Pose& getMutablePose();
   virtual void setPose(const Pose& pose) override;
   virtual void assignSkeleton(Skeleton* skeleton);
   virtual size_t numBones() {return(_skeleton != nullptr ? _skeleton->numBones() : 0);}

   virtual void setAllAnimatorsTime(key_time_t time);
   virtual void updatePoseFromAnimators();
   virtual void updatePoseFromSingleAnimator(int index);

   std::vector<SkinnedTriangleMesh> geometry;
   std::vector<SkinKeyframeAnimator> skin_animators;

 protected:
   Skeleton* _skeleton = nullptr;
};

#endif