GpuResourceManager.h

#pragma once
 
// Standard.
#include <variant>
#include <memory>
#include <filesystem>
#include <optional>
#include <atomic>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resource/UploadBuffer.h"
#include "material/TextureManager.h"
#include "render/general/resource/shadow/ShadowMapManager.h"
 
namespace ne {
    class Renderer;
    class GpuResource;
    class DynamicCpuWriteShaderResourceArrayManager;
 
    enum class ResourceUsageType {
        VERTEX_BUFFER, 
        INDEX_BUFFER,  
        ARRAY_BUFFER,  
        OTHER
    };
 
    enum class ShaderReadWriteTextureResourceFormat {
        R32G32_UINT,
        // ONLY THE FOLLOWING FORMATS CAN BE ADDED HERE:
        // 1. Formats that are supported as Vulkan storage images on most of the GPUs. Please, make sure you
        // don't add new formats without checking Vulkan Hardware Database (take Intel(R) UHD
        // Graphics 600 on Linux (!) for example, if it supports the format as storage image then it's
        // OK to add it here).
        // 2. Formats that have the same type in both Vulkan and DirectX.
 
        SIZE, //< marks the size of this enum
    };
 
    class GpuResourceManager {
        // Only renderer should be allowed to create resource manager.
        friend class Renderer;
 
        // Creates shadow maps.
        friend class ShadowMapManager;
 
        // Modifies counter of alive GPU resources.
        friend class GpuResource;
 
    public:
        GpuResourceManager() = delete;
 
        virtual ~GpuResourceManager() = default;
 
        virtual size_t getTotalVideoMemoryInMb() const = 0;
 
        virtual size_t getUsedVideoMemoryInMb() const = 0;
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> loadTextureFromDisk(
            const std::string& sResourceName, const std::filesystem::path& pathToTextureFile) = 0;
 
        virtual std::variant<std::unique_ptr<UploadBuffer>, Error> createResourceWithCpuWriteAccess(
            const std::string& sResourceName,
            size_t iElementSizeInBytes,
            size_t iElementCount,
            std::optional<bool> isUsedInShadersAsArrayResource) = 0;
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createResourceWithData(
            const std::string& sResourceName,
            const void* pBufferData,
            size_t iElementSizeInBytes,
            size_t iElementCount,
            ResourceUsageType usage,
            bool bIsShaderReadWriteResource) = 0;
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createResource(
            const std::string& sResourceName,
            size_t iElementSizeInBytes,
            size_t iElementCount,
            ResourceUsageType usage,
            bool bIsShaderReadWriteResource) = 0;
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createShaderReadWriteTextureResource(
            const std::string& sResourceName,
            unsigned int iWidth,
            unsigned int iHeight,
            ShaderReadWriteTextureResourceFormat format) = 0;
 
        virtual std::string getCurrentStateInfo() = 0;
 
        Renderer* getRenderer() const;
 
        TextureManager* getTextureManager() const;
 
        ShadowMapManager* getShadowMapManager() const;
 
        DynamicCpuWriteShaderResourceArrayManager* getDynamicCpuWriteShaderResourceArrayManager() const;
 
        size_t getTotalAliveResourceCount();
 
    protected:
        static std::variant<std::unique_ptr<GpuResourceManager>, Error> create(Renderer* pRenderer);
 
        static std::variant<std::unique_ptr<GpuResourceManager>, Error>
        createRendererSpecificManager(Renderer* pRenderer);
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createShadowMapTexture(
            const std::string& sResourceName, unsigned int iTextureSize, bool bPointLightColorCubemap) = 0;
 
        GpuResourceManager(Renderer* pRenderer);
 
        void resetManagers();
 
    private:
        std::unique_ptr<TextureManager> pTextureManager;
 
        std::unique_ptr<ShadowMapManager> pShadowMapManager;
 
        std::unique_ptr<DynamicCpuWriteShaderResourceArrayManager> pDynamicCpuWriteShaderResourceArrayManager;
 
        std::atomic<size_t> iAliveResourceCount{0};
 
        Renderer* const pRenderer = nullptr;
    };
} // namespace ne