DirectXPso.h

#pragma once
 
// Custom.
#include "render/general/pipeline/Pipeline.h"
#include "shader/hlsl/SpecialRootParameterSlot.hpp"
#include "render/general/resource/frame/FrameResourceManager.h"
#include "render/directx/resource/DirectXResource.h"
 
// External.
#include "directx/d3dx12.h"
 
// OS.
#include <wrl.h>
 
namespace ne {
    using namespace Microsoft::WRL;
 
    class DirectXResource;
    class DirectXRenderer;
 
    class DirectXPso : public Pipeline {
        // Renderer will ask us to bind global shader resource views.
        friend class DirectXRenderer;
 
    public:
        struct InternalResources {
            ComPtr<ID3D12RootSignature> pRootSignature;
 
            ComPtr<ID3D12PipelineState> pPso;
 
            std::unordered_map<std::string, UINT> rootParameterIndices;
 
            std::array<UINT, static_cast<unsigned int>(SpecialRootParameterSlot::SIZE)>
                vSpecialRootParameterIndices;
 
            std::unordered_map<
                UINT,
                std::array<DirectXResource*, FrameResourceManager::getFrameResourceCount()>>
                globalShaderResourceSrvs;
 
            std::unordered_map<UINT, std::unique_ptr<ContinuousDirectXDescriptorRange>>
                descriptorTablesToBind;
 
            bool bIsReadyForUsage = false;
        };
 
        DirectXPso() = delete;
        DirectXPso(const DirectXPso&) = delete;
        DirectXPso& operator=(const DirectXPso&) = delete;
 
        virtual ~DirectXPso() override;
 
        static std::variant<std::shared_ptr<DirectXPso>, Error> createGraphicsPso(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            std::unique_ptr<PipelineConfiguration> pPipelineConfiguration);
 
        static std::variant<std::shared_ptr<DirectXPso>, Error> createComputePso(
            Renderer* pRenderer, PipelineManager* pPipelineManager, const std::string& sComputeShaderName);
 
        std::variant<unsigned int, Error> getRootParameterIndex(const std::string& sShaderResourceName);
 
        std::pair<std::recursive_mutex, InternalResources>* getInternalResources() {
            return &mtxInternalResources;
        }
 
    protected:
        [[nodiscard]] virtual std::optional<Error> releaseInternalResources() override;
 
        [[nodiscard]] virtual std::optional<Error> restoreInternalResources() override;
 
    private:
        explicit DirectXPso(
            Renderer* pRenderer,
            PipelineManager* pPipelineManager,
            std::unique_ptr<PipelineConfiguration> pPipelineConfiguration);
 
        void bindGlobalShaderResourceViews(
            const ComPtr<ID3D12GraphicsCommandList>& pCommandList, size_t iCurrentFrameResourceIndex) const {
            // No need to lock internal resources mutex since the caller is expected to lock that mutex
            // because this function is expected to be called inside of the `draw` function.
 
            // Bind global SRVs.
            for (const auto& [iRootParameterIndex, vResourcesToBind] :
                 mtxInternalResources.second.globalShaderResourceSrvs) {
                // Set view.
                pCommandList->SetGraphicsRootShaderResourceView(
                    iRootParameterIndex,
                    vResourcesToBind[iCurrentFrameResourceIndex]
                        ->getInternalResource()
                        ->GetGPUVirtualAddress());
            }
        }
 
        [[nodiscard]] std::optional<Error> generateGraphicsPso();
 
        [[nodiscard]] std::optional<Error> generateComputePso();
 
        std::pair<std::recursive_mutex, InternalResources> mtxInternalResources;
    };
} // namespace ne