TextureHandleRegistry.h

#pragma once
#include "TextureHandle.h"
#include "TextureIdentity.h"
 
#include <filesystem>
#include <shared_mutex>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace Engine::Assets
{
    class RuntimeTexture;
}  // namespace Engine::Assets
 
namespace Engine::Assets::Textures
{

    class TextureHandleRegistry
    {
    public:
        TextureHandleRegistry()  = default;

        ~TextureHandleRegistry() = default;
 
        // Non-copyable, non-movable (contains mutex)
        TextureHandleRegistry( const TextureHandleRegistry & )             = delete;

        TextureHandleRegistry & operator=( const TextureHandleRegistry & ) = delete;

        TextureHandleRegistry( TextureHandleRegistry && )                  = delete;

        TextureHandleRegistry & operator=( TextureHandleRegistry && )      = delete;

        template <TextureType Type>
        TypedTextureHandle<Type> getOrCreateHandle( const std::filesystem::path & path )
        {
            TextureHandle base = getOrCreateHandle( path, Type );
            return TypedTextureHandle<Type>( base );
        }

        [[nodiscard]] TextureHandle getOrCreateHandle( const std::filesystem::path & path, TextureType type );

        [[nodiscard]] uint32_t resolveDescriptorIndex( TextureHandle handle ) const;

        [[nodiscard]] uint32_t resolveDescriptorSlot( TextureHandle handle ) const;

        [[nodiscard]] bool isResident( TextureHandle handle ) const;

        [[nodiscard]] RuntimeTexture * resolveTexture( TextureHandle handle ) const;

        void setDescriptorSlot( TextureHandle handle, uint32_t descriptorIndex );

        [[nodiscard]] TextureIdentityKey getIdentityForHandle( TextureHandle handle ) const;

        [[nodiscard]] TextureType getTextureType( TextureHandle handle ) const;

        [[nodiscard]] TextureType getTextureTypeForPath( const std::filesystem::path & path ) const;

        void onTextureLoaded(
            const std::filesystem::path & path,
            TextureType                   type,
            RuntimeTexture *              texture,
            uint32_t                      descriptorIndex
        );

        void onTextureLoaded(
            const TextureIdentityKey & identity,
            RuntimeTexture *           texture,
            uint32_t                   descriptorIndex
        );

        void onTextureLoaded(
            const std::filesystem::path & path,
            RuntimeTexture *              texture,
            uint32_t                      descriptorIndex
        );

        void onTextureUnloaded( const std::filesystem::path & path );
        void onTextureUnloaded( const std::filesystem::path & path, TextureType type );

        [[nodiscard]] size_t getHandleCount() const;

        [[nodiscard]] std::filesystem::path getPathForHandle( TextureHandle handle ) const;

        void clear();
 
    private:
        TextureHandle getOrCreateHandleImpl( const std::filesystem::path & path, TextureType type );

        struct Entry
        {
            std::filesystem::path path;
            TextureIdentityKey    identity;
            TextureType           type            = TextureType::Unknown;
            RuntimeTexture *      texture         = nullptr;
            uint32_t              descriptorIndex = TextureHandle::INVALID_ID;
            bool                  resident        = false;
        };
 
        std::vector<Entry> entries_;
        std::unordered_map<TextureIdentityKey, uint32_t, TextureIdentityKeyHash> identityToHandleId_;
        std::unordered_map<std::string, std::vector<uint32_t>>                   pathToHandleIds_;
        mutable std::shared_mutex                                               mutex_;
    };
 
}  // namespace Engine::Assets::Textures