skin.h

#ifndef OE_SCENE_SKIN_H
#define OE_SCENE_SKIN_H
 
#include <vector>
#include <string>
#include <glm/mat4x4.hpp>
 
#include "mesh.h"
#include "node_ptr.h"
#include "vertex.h"
 
namespace oe::scene::skin
{
    struct Bone
    {
        scene::NodePtr node = {};
 
        glm::mat4 inverse_bind_matrix = glm::mat4(1.0);
 
        AABB raw_bounding_box;
 
        AABB bounding_box;
    };
 
    struct BlendShapeData
    {
        index_t index;
 
        glm::vec3 position;
 
        // Todo, normals, etc...
    };
 
    class BlendShapeManager
    {
        public:
            BlendShapeManager(size_t count, size_t vertices);
 
            std::vector<uint8_t> getPackedData();
 
            size_t getIdFromName(const std::string& name);
 
            void addBlendShape(const std::string& name, const std::vector<BlendShapeData>& blendshape_data/*, const size_t idSubMesh = 0*/);
 
            void setWeight(const std::string& name, const float weight);
 
            const std::vector<float>& getAllWeights() const { return _weights; }
 
            void resetWeights();
 
            inline uint32_t getCount() { return _count; }
            inline uint32_t getTotalAffectedVerticesCount() { return _vertices_count; }
 
        private:
            uint32_t _count = 0;
            uint32_t _vertices_count = 0;
            std::vector<float> _blendshape_raw_data;
 
            std::vector<std::string> _names;
            std::vector<float> _weights;
    };
 
    template <IsSkinnedVertex VertexType>
    AABB generateBoneBoundingBox(const scene::Mesh<VertexType>& mesh, const int32_t id_bone)
    {
        return generateBoundingBoxFromPredicate(mesh, [&id_bone] (const VertexType& v) -> bool
        {
            const auto& bones = v.bones;
            const auto& weights = v.weights;
 
            return (bones.x == id_bone && weights.x > 0.f)
                || (bones.y == id_bone && weights.y > 0.f)
                || (bones.z == id_bone && weights.z > 0.f)
                || (bones.w == id_bone && weights.w > 0.f);
        });
    }
 
    struct Armature
    {
        void addBone(NodePtr node, const AABB& bone_bbox, const glm::mat4& inverse_bind_matrix)
        {
            bones_matrices.push_back(glm::mat4(1.0));
 
            bones.push_back({
                .node = node,
                .inverse_bind_matrix = inverse_bind_matrix,
                .raw_bounding_box = bone_bbox,
                .bounding_box = bone_bbox
            });
        }
 
        void update();
 
        scene::NodePtr root_node;
 
        std::vector<Bone> bones;
        std::vector<glm::mat4> bones_matrices;
 
        //BlendShapeManager blendshapes
    };
}
 
#endif