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 EngineCore {
 
class Texture;

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, Texture* 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;
        Texture* 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 EngineCore