DirectXResourceManager.h

#pragma once
 
// Standard.
#include <memory>
#include <variant>
 
// Custom.
#include "misc/Error.h"
#include "render/directx/descriptors/DirectXDescriptorHeap.h"
#include "render/general/resource/GpuResourceManager.h"
#include "material/TextureFilteringPreference.h"
 
// External.
#include "directx/d3dx12.h"
#include "D3D12MemoryAllocator/include/D3D12MemAlloc.h"
 
// OS.
#include <wrl.h>
 
namespace ne {
    using namespace Microsoft::WRL;
 
    class DirectXResource;
    class DirectXRenderer;
    class UploadBuffer;
 
    class DirectXResourceManager : public GpuResourceManager {
    public:
        DirectXResourceManager() = delete;
        DirectXResourceManager(const DirectXResourceManager&) = delete;
        DirectXResourceManager& operator=(const DirectXResourceManager&) = delete;
 
        virtual ~DirectXResourceManager() override;
 
        static DXGI_FORMAT
        convertTextureResourceFormatToDxFormat(ShaderReadWriteTextureResourceFormat format);
 
        static std::variant<std::unique_ptr<DirectXResourceManager>, Error>
        create(DirectXRenderer* pRenderer);
 
        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 size_t getTotalVideoMemoryInMb() const override;
 
        virtual size_t getUsedVideoMemoryInMb() const override;
 
        std::variant<std::unique_ptr<DirectXResource>, Error> createResource(
            const std::string& sResourceName,
            const D3D12MA::ALLOCATION_DESC& allocationDesc,
            const D3D12_RESOURCE_DESC& resourceDesc,
            const D3D12_RESOURCE_STATES& initialResourceState,
            const std::optional<D3D12_CLEAR_VALUE>& resourceClearValue);
 
        std::variant<std::vector<std::unique_ptr<DirectXResource>>, Error>
        makeRtvResourcesFromSwapChainBuffer(IDXGISwapChain3* pSwapChain, unsigned int iSwapChainBufferCount);
 
        DirectXDescriptorHeap* getRtvHeap() const;
 
        DirectXDescriptorHeap* getDsvHeap() const;
 
        DirectXDescriptorHeap* getCbvSrvUavHeap() const;
 
        DirectXDescriptorHeap* getSamplerHeap() const { return pSamplerHeap.get(); }
 
        virtual std::string getCurrentStateInfo() override;
 
    private:
        DirectXResourceManager(
            DirectXRenderer* pRenderer,
            ComPtr<D3D12MA::Allocator>&& pMemoryAllocator,
            std::unique_ptr<DirectXDescriptorHeap>&& pRtvHeap,
            std::unique_ptr<DirectXDescriptorHeap>&& pDsvHeap,
            std::unique_ptr<DirectXDescriptorHeap>&& pCbvSrvUavHeap,
            std::unique_ptr<DirectXDescriptorHeap>&& pSamplerHeap);
 
        static inline size_t makeMultipleOf256(size_t iNumber) {
            // We are adding 255 and then masking off
            // the lower 2 bytes which store all bits < 256.
 
            // Example: Suppose iNumber = 300.
            // (300 + 255) & ~255
            // 555 & ~255
            // 0x022B & ~0x00ff
            // 0x022B & 0xff00
            // 0x0200
            // 512
            return (iNumber + 255) & ~255; // NOLINT
        }
 
        virtual std::variant<std::unique_ptr<GpuResource>, Error> createShadowMapTexture(
            const std::string& sResourceName,
            unsigned int iTextureSize,
            bool bPointLightColorCubemap) override;
 
        std::variant<std::unique_ptr<GpuResource>, Error> createResourceWithData(
            const std::string& sResourceName,
            const D3D12_RESOURCE_DESC& finalResourceDescription,
            const std::vector<D3D12_SUBRESOURCE_DATA>& vSubresourcesToCopy,
            const D3D12_RESOURCE_DESC& uploadResourceDescription,
            bool bIsTextureResource,
            size_t iElementSizeInBytes = 0,
            size_t iElementCount = 0,
            TextureFilteringPreference filteringPreference =
                TextureFilteringPreference::FROM_RENDER_SETTINGS);
 
        ComPtr<D3D12MA::Allocator> pMemoryAllocator;
 
        std::unique_ptr<DirectXDescriptorHeap> pRtvHeap;
 
        std::unique_ptr<DirectXDescriptorHeap> pDsvHeap;
 
        std::unique_ptr<DirectXDescriptorHeap> pCbvSrvUavHeap;
 
        std::unique_ptr<DirectXDescriptorHeap> pSamplerHeap;
    };
} // namespace ne