DirectXResource.h

#pragma once
 
// Standard.
#include <variant>
#include <memory>
#include <array>
#include <optional>
#include <mutex>
 
// Custom.
#include "misc/Error.h"
#include "render/general/resource/GpuResource.h"
#include "render/directx/descriptors/DirectXDescriptor.h"
#include "render/directx/descriptors/DirectXDescriptorType.hpp"
 
// External.
#include "directx/d3dx12.h"
#include "D3D12MemoryAllocator/include/D3D12MemAlloc.h"
 
// OS.
#include <wrl.h>
 
namespace ne {
    using namespace Microsoft::WRL;
 
    class DirectXRenderer;
    class DirectXDescriptorHeap;
    class DirectXResourceManager;
    class ContinuousDirectXDescriptorRange;
 
    class DirectXResource : public GpuResource {
        // If descriptor heap of a used descriptor (see field of this class) was recreated
        // then descriptor heap will update our descriptors with new descriptor information.
        friend class DirectXDescriptorHeap;
 
        // Only resource manager can create this resource
        // (simply because only manager has a memory allocator object).
        friend class DirectXResourceManager;
 
    public:
        DirectXResource() = delete;
        DirectXResource(const DirectXResource&) = delete;
        DirectXResource& operator=(const DirectXResource&) = delete;
 
        virtual ~DirectXResource() override;
 
        [[nodiscard]] std::optional<Error> bindDescriptor(
            DirectXDescriptorType descriptorType,
            const std::shared_ptr<ContinuousDirectXDescriptorRange>& pRange = nullptr,
            bool bBindDescriptorsToCubemapFaces = true);
 
        std::optional<D3D12_CPU_DESCRIPTOR_HANDLE>
        getBindedDescriptorCpuHandle(DirectXDescriptorType descriptorType);
 
        std::optional<D3D12_CPU_DESCRIPTOR_HANDLE> getBindedCubemapFaceDescriptorCpuHandle(
            DirectXDescriptorType descriptorType, size_t iCubemapFaceIndex);
 
        std::optional<D3D12_GPU_DESCRIPTOR_HANDLE>
        getBindedDescriptorGpuHandle(DirectXDescriptorType descriptorType);
 
        ID3D12Resource* getInternalResource() const { return pInternalResource; }
 
        DirectXDescriptor* getDescriptor(DirectXDescriptorType descriptorType);
 
    private:
        struct DescriptorsSameType {
            std::unique_ptr<DirectXDescriptor> pResource;
 
            std::array<std::unique_ptr<DirectXDescriptor>, 6> // NOLINT: 1 per cubemap face (if cubemap)
                vCubemapFaces;
        };
 
        DirectXResource(
            DirectXResourceManager* pResourceManager,
            const std::string& sResourceName,
            UINT iElementSizeInBytes,
            UINT iElementCount);
 
        static std::variant<std::unique_ptr<DirectXResource>, Error> create(
            DirectXResourceManager* pResourceManager,
            const std::string& sResourceName,
            D3D12MA::Allocator* pMemoryAllocator,
            const D3D12MA::ALLOCATION_DESC& allocationDesc,
            const D3D12_RESOURCE_DESC& resourceDesc,
            const D3D12_RESOURCE_STATES& initialResourceState,
            std::optional<D3D12_CLEAR_VALUE> resourceClearValue,
            size_t iElementSizeInBytes = 0,
            size_t iElementCount = 0);
 
        static std::variant<std::unique_ptr<DirectXResource>, Error> createResourceFromSwapChainBuffer(
            DirectXResourceManager* pResourceManager,
            DirectXDescriptorHeap* pRtvHeap,
            const ComPtr<ID3D12Resource>& pSwapChainBuffer);
 
        std::pair<
            std::recursive_mutex,
            std::array<DescriptorsSameType, static_cast<size_t>(DirectXDescriptorType::END)>>
            mtxHeapDescriptors;
 
        ComPtr<D3D12MA::Allocation> pAllocatedResource;
 
        ComPtr<ID3D12Resource> pSwapChainBuffer;
 
        ID3D12Resource* pInternalResource = nullptr;
    };
} // namespace ne