AssetRegistry.h

Go to the documentation of this file.

#pragma once
 
#include "Engine/Asset/AssetHandles.h"
#include "Engine/Asset/AssetRefs.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Audio/AudioAssetRef.h"
#include "Engine/Files/AssetPath.h"
#include "Engine/Material/MaterialAssetRef.h"
#include "Engine/Mesh/MeshAssetRef.h"
#include "Engine/Texture/TextureHandle.h"
 
#include <filesystem>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace Engine::Core
{
    class AssetManager;
 
    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;
    };
 
    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;
        [[nodiscard]] Assets::MeshAssetRef ref(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]] bool isValid(Assets::MaterialHandle handle) const;
        [[nodiscard]] const Asset::MeshPath* path(Assets::MaterialHandle handle) const;
        [[nodiscard]] Assets::MaterialAssetRef ref(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);
 
        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]] Assets::AudioAssetRef ref(Assets::AudioClipHandle handle) const;
 
    private:
        struct Record
        {
            Asset::Path source;
            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 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]] 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]] 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_;
        GltfStore gltfs_;
    };
}  // namespace Engine::Core