SkinAsset.h

#pragma once
 
#include "Engine/Core/Asset.h"
#include "Engine/Files/AssetPath.h"
 
#include <cstdint>
#include <glm/mat4x4.hpp>
#include <glm/gtc/quaternion.hpp>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace Engine::Assets
{
    struct Joint {
        int32_t parentIndex = -1;  
        glm::mat4 inverseBindMatrix = glm::mat4(1.0f);  
        std::string name;  
        glm::vec3 restTranslation = glm::vec3(0.0f);  
        glm::quat restRotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);  
        glm::vec3 restScale = glm::vec3(1.0f);  
    };

    class Skin : public Asset::AssetBase {
    public:
        Skin();

        [[nodiscard]] uint32_t getBoneCount() const { return static_cast<uint32_t>(joints_.size()); }

        [[nodiscard]] const Joint& getJoint(uint32_t index) const { return joints_[index]; }

        [[nodiscard]] const std::vector<Joint>& getJoints() const { return joints_; }

        [[nodiscard]] int32_t getSkeletonRootIndex() const { return skeletonRootIndex_; }

        [[nodiscard]] int32_t findJointByName(const std::string& name) const {
            auto it = jointNameMap_.find(name);
            return it != jointNameMap_.end() ? it->second : -1;
        }

        void buildNameIndex() {
            jointNameMap_.clear();
            jointNameMap_.reserve(joints_.size());
            for (uint32_t i = 0; i < joints_.size(); ++i) {
                jointNameMap_[joints_[i].name] = static_cast<int32_t>(i);
            }
        }
 
        // TODO: These variables should be private as indicated by the underscore in the naming. No need for them to be publicly visible
        std::vector<Joint> joints_;  
        int32_t skeletonRootIndex_ = -1;  
        glm::mat4 armatureTransform_ = glm::mat4(1.0f);  
 
    private:
        std::unordered_map<std::string, int32_t> jointNameMap_;
    };

    class SkinAssetManager : public Asset::AssetManager<Asset::MeshPath, Skin>
    {
    public:
        SkinAssetManager() = default;
    };
}