TextureManager.h

#pragma once
 
// Standard.
#include <unordered_map>
#include <string>
#include <mutex>
#include <memory>
#include <variant>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resource/GpuResource.h"
#include "material/TextureHandle.h"
 
namespace ne {
    class TextureManager;
    class GpuResourceManager;
 
    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;
    };
}