TextureHandleRegistry.h

Go to the documentation of this file.

#pragma once
#include "TextureHandle.h"
 
#include <filesystem>
#include <shared_mutex>
#include <unordered_map>
#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 = getOrCreateHandleImpl( path, Type );
            return TypedTextureHandle<Type>( base );
        }

        [[nodiscard]] uint32_t resolveDescriptorIndex( 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,
            RuntimeTexture *              texture,
            uint32_t                      descriptorIndex
        );

        void onTextureUnloaded( const std::filesystem::path & path );

        [[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;
            TextureType           type            = TextureType::Unknown;
            RuntimeTexture *      texture         = nullptr;
            uint32_t              descriptorIndex = TextureHandle::INVALID_ID;
        };
 
        std::vector<Entry>                        entries_;
        std::unordered_map<std::string, uint32_t> pathToHandleId_;
        mutable std::shared_mutex                 mutex_;
    };
 
}  // namespace Engine::Assets::Textures