AssetRegistry.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <glm/vec3.hpp>
#include <string>
#include <unordered_map>
#include <vector>

enum class AssetRole : uint8_t
{
    Map,    
    Prop,   
    Entity, 
    Effect, 
};

struct AssetEntry
{
    std::string name;                      
    std::string filename;                  
    AssetRole role = AssetRole::Entity;
    glm::vec3 renderScale{1.0f};           
    glm::vec3 renderTranslation{0.0f};     
    glm::vec3 renderRotationDegrees{0.0f}; 
    int32_t modelIndex = -1;               
    bool hasCollision = false;             
};

class AssetRegistry
{
public:
    int add(const std::string& name,
            const std::string& filename = "",
            AssetRole role = AssetRole::Entity,
            glm::vec3 renderScale = glm::vec3{1.0f},
            glm::vec3 renderTranslation = glm::vec3{0.0f},
            glm::vec3 renderRotationDegrees = glm::vec3{0.0f})
    {
        const int id = static_cast<int>(entries_.size());
        entries_.push_back({.name = name,
                            .filename = filename,
                            .role = role,
                            .renderScale = renderScale,
                            .renderTranslation = renderTranslation,
                            .renderRotationDegrees = renderRotationDegrees});
        nameToId_[name] = id;
        return id;
    }

    void setModelIndex(int assetId, int32_t modelIndex)
    {
        if (assetId >= 0 && assetId < static_cast<int>(entries_.size()))
            entries_[static_cast<size_t>(assetId)].modelIndex = modelIndex;
    }

    void setHasCollision(int assetId, bool v = true)
    {
        if (assetId >= 0 && assetId < static_cast<int>(entries_.size()))
            entries_[static_cast<size_t>(assetId)].hasCollision = v;
    }

    [[nodiscard]] int32_t modelIndex(const std::string& name) const
    {
        const auto it = nameToId_.find(name);
        if (it == nameToId_.end())
            return -1;
        return entries_[static_cast<size_t>(it->second)].modelIndex;
    }

    [[nodiscard]] int32_t modelIndex(int assetId) const
    {
        if (assetId < 0 || assetId >= static_cast<int>(entries_.size()))
            return -1;
        return entries_[static_cast<size_t>(assetId)].modelIndex;
    }

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

    [[nodiscard]] const AssetEntry& entry(int assetId) const { return entries_[static_cast<size_t>(assetId)]; }

    [[nodiscard]] int count() const { return static_cast<int>(entries_.size()); }

    [[nodiscard]] const std::vector<AssetEntry>& entries() const { return entries_; }
 
private:
    std::vector<AssetEntry> entries_;
    std::unordered_map<std::string, int> nameToId_;
};