AssetRegistry.h

#pragma once
 
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Asset/AssetRefs.h"
#include "Engine/Audio/AudioAssetRef.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Material/MaterialAssetRef.h"
#include "Engine/Mesh/MeshAssetRef.h"
#include "Engine/Texture/TextureHandle.h"
 
#include <filesystem>
#include <glm/mat4x4.hpp>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>

 
namespace Engine::Assets
{
    class Animation;
    class Skin;
}  // namespace Engine::Assets
 
namespace Engine::Core
{
    class AssetManager;

    struct AnchorPoint
    {
        glm::mat4 modelLocalTransform{ 1.0f };  
    };

    using AnchorPointMap = std::unordered_map<std::string, AnchorPoint>;

    enum class AssetLoadState : uint8_t
    {
        Unloaded,       
        RequestedLoad,  
        Loading,        
        Loaded,         
        Failed,         
    };

    struct GltfRenderableRecord
    {
        Assets::GltfHandle                  gltf;                
        std::string                         nodeName;            
        uint32_t                            nodeIndex = 0;       
        uint32_t                            meshIndex = 0;       
        Assets::GeometryMeshHandle          geometry;            
        std::vector<Assets::MaterialHandle> primitiveMaterials;  
        Ecs::Transform                      authoredTransform;   
        bool                                isStatic = false;    
        AnchorPointMap                      anchorPoints;        
    };

    class GeometryMeshStore
    {
    public:
        explicit GeometryMeshStore( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] Assets::GeometryMeshHandle load( const Asset::MeshPath & meshPath );

        [[nodiscard]] bool isValid( Assets::GeometryMeshHandle handle ) const;

        [[nodiscard]] const Asset::MeshPath * path( Assets::GeometryMeshHandle handle ) const;
 
    private:
        struct Record
        {
            Asset::MeshPath path;                     
            uint32_t        generation          = 1;  
            uint64_t        payloadGeneration   = 0;  
            uint64_t        residencyGeneration = 0;  
        };

        [[nodiscard]] static std::string keyFor( const Asset::MeshPath & meshPath );
 
        AssetManager *                            assetManager_ = nullptr;  
        std::vector<Record>                       records_;                 
        std::unordered_map<std::string, uint32_t> pathToIndex_;             
    };

    class MaterialStore
    {
    public:
        explicit MaterialStore( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] Assets::MaterialHandle load( const Asset::MeshPath & materialPath );

        [[nodiscard]] Assets::MaterialHandle registerRuntimeMaterial( Asset::MeshPath materialPath, std::unique_ptr<Assets::Material> material );

        [[nodiscard]] bool isValid( Assets::MaterialHandle handle ) const;

        [[nodiscard]] const Asset::MeshPath * path( Assets::MaterialHandle handle ) const;
 
    private:
        struct Record
        {
            Asset::MeshPath path;                     
            uint32_t        generation          = 1;  
            uint64_t        payloadGeneration   = 0;  
            uint64_t        residencyGeneration = 0;  
        };

        [[nodiscard]] static std::string keyFor( const Asset::MeshPath & materialPath );
 
        AssetManager *                            assetManager_ = nullptr;  
        std::vector<Record>                       records_;                 
        std::unordered_map<std::string, uint32_t> pathToIndex_;             
    };

    class Texture2DStore
    {
    public:
        explicit Texture2DStore( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] Assets::Texture2DHandle load( const std::filesystem::path & source, Assets::TextureType usage = Assets::TextureType::BaseColor );

        [[nodiscard]] bool isValid( Assets::Texture2DHandle handle ) const;

        [[nodiscard]] const std::filesystem::path * sourcePath( Assets::Texture2DHandle handle ) const;

        [[nodiscard]] Assets::TextureHandle legacyHandle( Assets::Texture2DHandle handle ) const;

        [[nodiscard]] Assets::TextureType usage( Assets::Texture2DHandle handle ) const;
 
    private:
        struct Record
        {
            std::filesystem::path source;                                                
            Assets::TextureHandle legacyHandle;                                          
            Assets::TextureType   usage               = Assets::TextureType::BaseColor;  
            uint32_t              generation          = 1;                               
            uint64_t              payloadGeneration   = 0;                               
            uint64_t              residencyGeneration = 0;                               
        };

        [[nodiscard]] static std::string keyFor( const std::filesystem::path & source, Assets::TextureType usage );
 
        AssetManager *                            assetManager_ = nullptr;  
        std::vector<Record>                       records_;                 
        std::unordered_map<std::string, uint32_t> sourceToIndex_;           
    };

    class AudioClipStore
    {
    public:
        explicit AudioClipStore( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] Assets::AudioClipHandle load( const Asset::Path & source );

        [[nodiscard]] Assets::AudioClipHandle load( const std::filesystem::path & source );

        [[nodiscard]] bool isValid( Assets::AudioClipHandle handle ) const;

        [[nodiscard]] const Asset::Path * sourcePath( Assets::AudioClipHandle handle ) const;

        [[nodiscard]] Asset::LoadState state( Assets::AudioClipHandle handle ) const;

        [[nodiscard]] bool isLoaded( Assets::AudioClipHandle handle ) const;

        [[nodiscard]] bool isLoading( Assets::AudioClipHandle handle ) const;

        [[nodiscard]] Assets::Audio * payload( Assets::AudioClipHandle handle ) const;
 
    private:
        struct Record
        {
            Asset::Path source;                   
            Assets::AudioAssetRef payloadRef;     
            uint32_t    generation          = 1;  
            uint64_t    payloadGeneration   = 0;  
            uint64_t    residencyGeneration = 0;  
        };

        [[nodiscard]] static std::string keyFor( const Asset::Path & source );
 
        AssetManager *                            assetManager_ = nullptr;  
        std::vector<Record>                       records_;                 
        std::unordered_map<std::string, uint32_t> sourceToIndex_;           
    };

    class AnimationClipStore
    {
    public:
        explicit AnimationClipStore( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] Assets::AnimationClipHandle load( const Asset::MeshPath & animationPath );

        [[nodiscard]] Assets::AnimationClipHandle registerRuntimeAnimation(
            Asset::MeshPath animationPath,
            std::unique_ptr<Assets::Animation> animation
        );

        [[nodiscard]] bool isValid( Assets::AnimationClipHandle handle ) const;

        [[nodiscard]] const Asset::MeshPath * path( Assets::AnimationClipHandle handle ) const;

        [[nodiscard]] Assets::Animation * payload( Assets::AnimationClipHandle handle ) const;
 
    private:
        struct Record
        {
            Asset::MeshPath path;                     
            uint32_t        generation          = 1;  
            uint64_t        payloadGeneration   = 0;  
            uint64_t        residencyGeneration = 0;  
        };

        [[nodiscard]] static std::string keyFor( const Asset::MeshPath & animationPath );
 
        AssetManager *                            assetManager_ = nullptr;  
        std::vector<Record>                       records_;                 
        std::unordered_map<std::string, uint32_t> pathToIndex_;             
    };

    class SkinStore
    {
    public:
        explicit SkinStore( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] Assets::SkinHandle load( const Asset::MeshPath & skinPath );

        [[nodiscard]] bool isValid( Assets::SkinHandle handle ) const;

        [[nodiscard]] const Asset::MeshPath * path( Assets::SkinHandle handle ) const;

        [[nodiscard]] Assets::Skin * payload( Assets::SkinHandle handle ) const;
 
    private:
        struct Record
        {
            Asset::MeshPath path;                     
            uint32_t        generation          = 1;  
            uint64_t        payloadGeneration   = 0;  
            uint64_t        residencyGeneration = 0;  
        };

        [[nodiscard]] static std::string keyFor( const Asset::MeshPath & skinPath );
 
        AssetManager *                            assetManager_ = nullptr;  
        std::vector<Record>                       records_;                 
        std::unordered_map<std::string, uint32_t> pathToIndex_;             
    };

    class GltfStore
    {
    public:
        GltfStore( AssetManager * assetManager = nullptr, GeometryMeshStore * geometryMeshes = nullptr, MaterialStore * materials = nullptr );

        void setAssetManager( AssetManager * assetManager );

        void setGeometryMeshStore( GeometryMeshStore * geometryMeshes );

        void setMaterialStore( MaterialStore * materials );

        [[nodiscard]] Assets::GltfHandle load( const std::filesystem::path & source );

        [[nodiscard]] Assets::GltfRenderableHandle renderable( Assets::GltfHandle gltf, std::string_view nodeName );

        [[nodiscard]] Assets::GeometryMeshHandle geometryMesh( Assets::GltfRenderableHandle renderable ) const;

        [[nodiscard]] std::optional<AnchorPoint> anchorPoint(
            Assets::GltfRenderableHandle renderable,
            std::string_view             name
        ) const;

        [[nodiscard]] std::vector<std::string> anchorPointNames( Assets::GltfRenderableHandle renderable ) const;

        [[nodiscard]] const GltfRenderableRecord * get( Assets::GltfRenderableHandle renderable ) const;

        [[nodiscard]] const std::filesystem::path * sourcePath( Assets::GltfHandle gltf ) const;

        [[nodiscard]] bool isValid( Assets::GltfHandle handle ) const;

        [[nodiscard]] bool isValid( Assets::GltfRenderableHandle handle ) const;
 
    private:
        struct GltfRecord
        {
            std::filesystem::path                                         source;                 
            uint32_t                                                      generation        = 1;  
            uint64_t                                                      payloadGeneration = 0;  
            uint64_t                                                      residencyGeneration = 0;  
            std::unordered_map<std::string, Assets::GltfRenderableHandle> renderablesByName;        
        };

        struct RenderableRecord
        {
            GltfRenderableRecord data;                     
            uint32_t             generation          = 1;  
            uint64_t             payloadGeneration   = 0;  
            uint64_t             residencyGeneration = 0;  
        };

        [[nodiscard]] static std::string keyFor( const std::filesystem::path & source );

        [[nodiscard]] static std::string fallbackNodeName( size_t nodeIndex );

        void importMetadata( Assets::GltfHandle gltf );
 
        AssetManager *                            assetManager_   = nullptr;  
        GeometryMeshStore *                       geometryMeshes_ = nullptr;  
        MaterialStore *                           materials_      = nullptr;  
        std::vector<GltfRecord>                   gltfRecords_;               
        std::vector<RenderableRecord>             renderableRecords_;         
        std::unordered_map<std::string, uint32_t> sourceToIndex_;             
    };

    class AssetRegistry
    {
    public:
        explicit AssetRegistry( AssetManager * assetManager = nullptr );

        void setAssetManager( AssetManager * assetManager );

        [[nodiscard]] GltfStore & gltfs()
        {
            return gltfs_;
        }

        [[nodiscard]] const GltfStore & gltfs() const
        {
            return gltfs_;
        }

        [[nodiscard]] GeometryMeshStore & geometryMeshes()
        {
            return geometryMeshes_;
        }

        [[nodiscard]] const GeometryMeshStore & geometryMeshes() const
        {
            return geometryMeshes_;
        }

        [[nodiscard]] MaterialStore & materials()
        {
            return materials_;
        }

        [[nodiscard]] const MaterialStore & materials() const
        {
            return materials_;
        }

        [[nodiscard]] Texture2DStore & texture2Ds()
        {
            return texture2Ds_;
        }

        [[nodiscard]] const Texture2DStore & texture2Ds() const
        {
            return texture2Ds_;
        }

        [[nodiscard]] AudioClipStore & audioClips()
        {
            return audioClips_;
        }

        [[nodiscard]] const AudioClipStore & audioClips() const
        {
            return audioClips_;
        }

        [[nodiscard]] AnimationClipStore & animations()
        {
            return animations_;
        }

        [[nodiscard]] const AnimationClipStore & animations() const
        {
            return animations_;
        }

        [[nodiscard]] SkinStore & skins()
        {
            return skins_;
        }

        [[nodiscard]] const SkinStore & skins() const
         {
            return skins_;
        }

        [[nodiscard]] Assets::GltfHandle resolve( Assets::Authored::GltfAssetRef ref );

        [[nodiscard]] Assets::GltfRenderableHandle resolve( Assets::Authored::GltfRenderableAssetRef ref );

        [[nodiscard]] Assets::GeometryMeshHandle resolve( Assets::Authored::GeometryMeshAssetRef ref );

        [[nodiscard]] Assets::Texture2DHandle resolve( Assets::Authored::Texture2DAssetRef ref );

        [[nodiscard]] Assets::AudioClipHandle resolve( Assets::Authored::AudioAssetRef ref );
 
    private:
        AssetManager *    assetManager_ = nullptr;  
        GeometryMeshStore geometryMeshes_;          
        MaterialStore     materials_;               
        Texture2DStore    texture2Ds_;              
        AudioClipStore    audioClips_;              
        AnimationClipStore animations_;             
        SkinStore         skins_;                   
        GltfStore         gltfs_;                   
    };
}  // namespace Engine::Core