VulkanResourceManager.h

#pragma once
 
// Standard.
#include <atomic>
#include <optional>
 
// Custom.
#include "render/general/resources/GpuResourceManager.h"
 
// External.
#include "VulkanMemoryAllocator/include/vk_mem_alloc.h"
 
namespace ne {
    class VulkanRenderer;
    class VulkanResource;
 
    class VulkanResourceManager : public GpuResourceManager {
        // Resource will request a memory allocator object during destruction.
        friend class VulkanResource;
 
        // Upload buffer needs access to memory allocator object for map/unmap operations.
        friend class UploadBuffer;
 
        // Uses memory allocator to load KTX textures.
        friend class KtxLoadingCallbackManager;
 
    public:
        VulkanResourceManager() = delete;
        VulkanResourceManager(const VulkanResourceManager&) = delete;
        VulkanResourceManager& operator=(const VulkanResourceManager&) = delete;
 
        virtual ~VulkanResourceManager() override;
 
        static VkFormat convertTextureResourceFormatToVkFormat(ShaderReadWriteTextureResourceFormat format);
 
        static std::variant<std::unique_ptr<VulkanResourceManager>, Error> create(VulkanRenderer* pRenderer);
 
        virtual size_t getTotalVideoMemoryInMb() const override;
 
        virtual size_t getUsedVideoMemoryInMb() const override;
 
        std::variant<std::unique_ptr<VulkanResource>, Error> createBuffer(
            const std::string& sResourceName,
            const VkBufferCreateInfo& bufferInfo,
            const VmaAllocationCreateInfo& allocationInfo,
            unsigned int iElementSizeInBytes,
            unsigned int iElementCount);
 
        std::variant<std::unique_ptr<VulkanResource>, Error> createImage(
            const std::string& sResourceName,
            uint32_t iImageWidth,
            uint32_t iImageHeight,
            uint32_t iTextureMipLevelCount,
            VkSampleCountFlagBits sampleCount,
            VkFormat imageFormat,
            VkImageTiling imageTilingMode,
            VkImageUsageFlags imageUsage,
            std::optional<VkImageAspectFlags> viewDescription,
            bool bIsCubeMap = false);
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> loadTextureFromDisk(
            const std::string& sResourceName, const std::filesystem::path& pathToTextureFile) override;
 
        virtual std::variant<std::unique_ptr<UploadBuffer>, Error> createResourceWithCpuWriteAccess(
            const std::string& sResourceName,
            size_t iElementSizeInBytes,
            size_t iElementCount,
            std::optional<bool> isUsedInShadersAsArrayResource) override;
 
        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) override;
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createResource(
            const std::string& sResourceName,
            size_t iElementSizeInBytes,
            size_t iElementCount,
            ResourceUsageType usage,
            bool bIsShaderReadWriteResource) override;
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createShaderReadWriteTextureResource(
            const std::string& sResourceName,
            unsigned int iWidth,
            unsigned int iHeight,
            ShaderReadWriteTextureResourceFormat format) override;
 
        virtual std::string getCurrentStateInfo() override;
 
    private:
        VulkanResourceManager(VulkanRenderer* pRenderer, VmaAllocator pMemoryAllocator);
 
        static std::optional<VkBufferUsageFlagBits>
        convertResourceUsageTypeToVkBufferUsageType(ResourceUsageType usage);
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createShadowMapTexture(
            const std::string& sResourceName,
            unsigned int iTextureSize,
            bool bPointLightColorCubemap) override;
 
        std::variant<std::unique_ptr<VulkanResource>, Error> createBuffer(
            const std::string& sResourceName,
            VkDeviceSize iBufferSize,
            VkBufferUsageFlags bufferUsage,
            bool bAllowCpuWrite,
            unsigned int iElementSizeInBytes,
            unsigned int iElementCount);
 
        VmaAllocator pMemoryAllocator = nullptr;
    };
} // namespace ne