pose_buffer.h

#pragma once
 
#include <cstdint>
#include <vector>
 
#include <glm/glm.hpp>
 
#include "ecs/entity.h"
 
namespace Vkm::Engine {

struct PoseSlice {
    uint32_t first = 0;
    uint32_t count = 0;
 
    glm::vec3 originMin{0.0f};  
    glm::vec3 originMax{0.0f};
 
    float maxBoneScale = 1.0f;  
};

struct PoseWrite {
    PoseSlice* slice   = nullptr;
    glm::mat4* global  = nullptr;
    glm::mat4* palette = nullptr;
};

class PoseBuffer {
    public:
        PoseBuffer() = default;
        ~PoseBuffer() = default;
 
        PoseBuffer(const PoseBuffer& other) = delete;
        PoseBuffer& operator=(const PoseBuffer& other) = delete;
 
        PoseBuffer(PoseBuffer && other) = delete;
        PoseBuffer& operator=(PoseBuffer && other) = delete;
 
    public:
        void clear();

        uint32_t addSlice(uint32_t boneCount);

        void mapEntity(EntityId entity, uint32_t slice);

        PoseWrite writeTo(uint32_t slice);

        const PoseSlice* sliceOf(EntityId entity) const;
 
        const std::vector<PoseSlice>& slices()  const { return m_slices; }
        const std::vector<glm::mat4>& global()  const { return m_global; }
        const std::vector<glm::mat4>& palette() const { return m_palette; }
 
    private:
        struct Mapping {
            EntityId entity{};
            uint32_t slice = 0;
        };
 
    private:
        std::vector<glm::mat4> m_global;   
        std::vector<glm::mat4> m_palette;  
        std::vector<PoseSlice> m_slices;
        std::vector<Mapping>   m_sliceOfEntity;  
};

void finishSlice(const PoseWrite& out);
 
} // namespace Vkm::Engine