MeshManager.hpp

#pragma once
 
#include "VulkanMesh.hpp"
#include "components/GameComponents/BasicComponents.hpp"
#include "components/GameObjects/ModelObject.hpp"
#include "components/Mesh.hpp"
#include "components/VirtualFileSystem.hpp"
 
#include "Engine.hpp"
 
#include <unordered_map>
#include <components/Types.hpp>
#include <vector>
#include <memory>
#include "components/ECS/ECS.hpp"
#include <string>
#include <iostream>
#include <cstring>
#include <algorithm>
 
namespace vex {
    class MeshManager {
    public:
        MeshManager(VulkanContext& context, std::unique_ptr<VulkanResources>& resources, VirtualFileSystem* vfs);
        ~MeshManager();

        void init(Engine* engine){
            m_p_engine = engine;
 
            auto& registry = m_p_engine->getRegistry();
            registry.on_create<MeshComponent>([this](vex::Entity entity, MeshComponent& comp) {
                onMeshComponentConstruct(m_p_engine->getRegistry(), entity);
            });
            registry.on_destroy<MeshComponent>([this](vex::Entity entity, MeshComponent& comp) {
                onMeshComponentDestroy(m_p_engine->getRegistry(), entity);
            });
        }

        MeshComponent loadMesh(const std::string& path);

        ModelObject* createModel(const std::string& name, MeshComponent meshComponent, TransformComponent transformComponent, vex::Entity parent);

        void destroyModel(std::string& name, MeshComponent meshComponent);

        void registerVulkanMesh(MeshComponent& meshComponent);

        std::unique_ptr<VulkanMesh>& getVulkanMeshByMesh(MeshComponent& meshComponent);

        void loadMeshesAsync(const std::vector<MeshComponent*>& pendingComponents);

        bool isMeshLoaded(const std::string& path) const {
            return m_vulkanMeshes.find(path) != m_vulkanMeshes.end();
        }

        void clearState();
 
    private:
        VulkanContext& m_r_context;
        Engine* m_p_engine = nullptr;
        VirtualFileSystem* m_vfs;
        std::unique_ptr<VulkanResources>& m_p_resources;
        vex_map<std::string, std::unique_ptr<VulkanMesh>> m_vulkanMeshes;
        std::vector<uint32_t> m_freeModelIds;
        uint32_t m_nextModelId = 0;
 
        std::unordered_map<uint32_t, std::string> m_installedPaths;
        std::unordered_map<std::string, std::pair<glm::vec3, float>> m_meshBoundsCache;

        void onMeshComponentConstruct(vex::Registry& registry, vex::Entity entity);

        void onMeshComponentDestroy(vex::Registry& registry, vex::Entity entity);

        void releaseMeshReference(const std::string& path, MeshComponent& ownerComp);
    };
}