TextureManager.h

#pragma once
 
// Standard.
#include <unordered_map>
#include <string>
#include <mutex>
#include <memory>
#include <variant>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resources/GpuResource.h"
 
namespace ne {
 
    class TextureManager;
    class GpuResourceManager;
 
    class TextureHandle {
        // We expect that only texture manager will create texture handles.
        friend class TextureManager;
 
    public:
        TextureHandle() = delete;
 
        TextureHandle(const TextureHandle&) = delete;
        TextureHandle& operator=(const TextureHandle&) = delete;
 
        TextureHandle(TextureHandle&&) = delete;
        TextureHandle& operator=(TextureHandle&&) = delete;
 
        GpuResource* getResource();
 
        std::string getPathToResourceRelativeRes();
 
        ~TextureHandle();
 
    private:
        TextureHandle(
            TextureManager* pTextureManager,
            const std::string& sPathToResourceRelativeRes,
            GpuResource* pTexture);
 
        std::string sPathToResourceRelativeRes;
 
        TextureManager* pTextureManager = nullptr;
 
        GpuResource* pTexture = nullptr;
    };
 
    class TextureManager {
        // Texture handles will notify texture manager in destructor to mark referenced texture resource
        // as not used so that texture manager can release the texture resource from memory
        // if no texture handle is referencing it.
        friend class TextureHandle;
 
    public:
        TextureManager(const TextureManager&) = delete;
        TextureManager& operator=(const TextureManager&) = delete;
 
        TextureManager() = delete;
 
        TextureManager(GpuResourceManager* pResourceManager);
 
        ~TextureManager();
 
        size_t getTextureInMemoryCount();
 
        std::variant<std::unique_ptr<TextureHandle>, Error>
        getTexture(const std::string& sPathToResourceRelativeRes);
 
    private:
        struct TextureResource {
            std::unique_ptr<GpuResource> pTexture;
 
            size_t iActiveTextureHandleCount = 0;
        };
 
        void releaseTextureResourceIfNotUsed(const std::string& sPathToResourceRelativeRes);
 
        void determineTextureFormatExtension();
 
        std::unique_ptr<TextureHandle> createNewTextureHandle(const std::string& sPathToResourceRelativeRes);
 
        std::variant<std::unique_ptr<TextureHandle>, Error>
        loadTextureAndCreateNewTextureHandle(const std::string& sPathToResourceRelativeRes);
 
        std::pair<std::recursive_mutex, std::unordered_map<std::string, TextureResource>> mtxTextureResources;
 
        std::string sTextureFormatExtension;
 
        GpuResourceManager* const pResourceManager = nullptr;
    };
}