DirectXRenderer.h

#pragma once
 
// Standard.
#include <optional>
#include <variant>
#include <vector>
#include <mutex>
#include <atomic>
#include <memory>
 
// Custom.
#include "render/Renderer.h"
#include "misc/Error.h"
#include "render/directx/resources/DirectXResource.h"
 
// External.
#include "directx/d3dx12.h"
 
// OS.
#include <wrl.h>
#include <dxgi1_4.h>
 
namespace ne {
    using namespace Microsoft::WRL;
 
    class GameManager;
    class DirectXResourceManager;
    class Material;
    class CameraProperties;
    class DirectXPso;
    struct QueuedForExecutionComputeShaders;
    class ComputeShaderInterface;
    struct DirectXFrameResource;
 
    class DirectXRenderer : public Renderer {
    public:
        DirectXRenderer() = delete;
        DirectXRenderer(const DirectXRenderer&) = delete;
        DirectXRenderer& operator=(const DirectXRenderer&) = delete;
 
        virtual ~DirectXRenderer() override;
 
        static std::variant<std::unique_ptr<Renderer>, std::pair<Error, std::string>>
        create(GameManager* pGameManager, const std::vector<std::string>& vBlacklistedGpuNames);
 
        static constexpr DXGI_FORMAT getBackBufferFormat() { return backBufferFormat; }
 
        static constexpr DXGI_FORMAT getDepthStencilBufferFormat() { return depthStencilBufferFormat; }
 
        static constexpr DXGI_FORMAT getDepthBufferFormatNoMultisampling() {
            return depthBufferNoMultisamplingFormat;
        }
 
        static constexpr DXGI_FORMAT getShadowMapFormat() { return shadowMapFormat; }
 
        static constexpr DXGI_FORMAT getShadowMappingPointLightColorTargetFormat() {
            return shadowMappingPointLightColorTargetFormat;
        }
 
        virtual std::vector<std::string> getSupportedGpuNames() const override;
 
        virtual std::variant<std::set<std::pair<unsigned int, unsigned int>>, Error>
        getSupportedRenderResolutions() const override;
 
        virtual std::variant<std::set<std::pair<unsigned int, unsigned int>>, Error>
        getSupportedRefreshRates() const override;
 
        virtual std::string getCurrentlyUsedGpuName() const override;
 
        virtual void waitForGpuToFinishWorkUpToThisPoint() override;
 
        virtual RendererType getType() const override;
 
        virtual std::string getUsedApiVersion() const override;
 
        ID3D12Device* getD3dDevice() const;
 
        ID3D12GraphicsCommandList* getD3dCommandList();
 
        ID3D12CommandQueue* getD3dCommandQueue();
 
        IDXGIAdapter3* getVideoAdapter() const;
 
        UINT getMsaaQualityLevel() const;
 
        virtual GpuResource* getDepthTextureNoMultisampling() override;
 
        virtual std::pair<unsigned int, unsigned int> getRenderTargetSize() const override;
 
    protected:
        DirectXRenderer(GameManager* pGameManager);
 
        virtual void drawShadowMappingPass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            PipelineManager::GraphicsPipelineRegistry* pGraphicsPipelines) override;
 
        virtual void drawMeshesDepthPrepass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vOpaquePipelines) override;
 
        virtual void executeComputeShadersOnGraphicsQueue(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            ComputeExecutionStage stage) override;
 
        virtual void drawMeshesMainPass(
            FrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vOpaquePipelines,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& vTransparentPipelines)
            override;
 
        virtual void
        present(FrameResource* pCurrentFrameResource, size_t iCurrentFrameResourceIndex) override;
 
        void drawMeshesMainPassSpecificPipelines(
            DirectXFrameResource* pCurrentFrameResource,
            size_t iCurrentFrameResourceIndex,
            const std::vector<Renderer::MeshesInFrustum::PipelineInFrustumInfo>& pipelinesOfSpecificType,
            D3D12_GPU_DESCRIPTOR_HANDLE directionalShadowMapsHandle,
            D3D12_GPU_DESCRIPTOR_HANDLE spotShadowMapsHandle,
            D3D12_GPU_DESCRIPTOR_HANDLE pointShadowMapsGpuHandle,
            const bool bIsDrawingTransparentMeshes);
 
        [[nodiscard]] virtual std::optional<Error> onRenderSettingsChangedDerived() override;
 
        virtual void waitForGpuToFinishUsingFrameResource(FrameResource* pFrameResource) override;
 
        virtual std::variant<AntialiasingQuality, Error> getMaxSupportedAntialiasingQuality() const override;
 
        virtual bool isInitialized() const override;
 
    private:
        [[nodiscard]] std::optional<Error> initialize(const std::vector<std::string>& vBlacklistedGpuNames);
 
#if defined(DEBUG)
        [[nodiscard]] std::optional<Error> enableDebugLayer();
#endif
 
        [[nodiscard]] std::optional<Error> createDepthStencilBuffer();
 
        [[nodiscard]] std::optional<Error>
        pickVideoAdapter(const std::vector<std::string>& vBlacklistedGpuNames);
 
        static size_t rateGpuSuitability(DXGI_ADAPTER_DESC1 adapterDesc);
 
        [[nodiscard]] std::optional<Error> setOutputAdapter();
 
        [[nodiscard]] std::optional<Error> createCommandQueue();
 
        [[nodiscard]] std::optional<Error> createCommandList();
 
        [[nodiscard]] std::optional<Error> createSwapChain();
 
        [[nodiscard]] std::optional<Error>
        initializeDirectX(const std::vector<std::string>& vBlacklistedGpuNames);
 
        virtual void prepareForDrawingNextFrame(
            CameraProperties* pCameraProperties, FrameResource* pCurrentFrameResource) override;
 
        void resetCommandListForGraphics(DirectXFrameResource* pCurrentFrameResource);
 
        void executeGraphicsCommandList(ID3D12GraphicsCommandList* pCommandListToExecute);
 
        [[nodiscard]] std::optional<Error> updateMsaaQualityLevelCount();
 
        void waitForFenceValue(UINT64 iFenceToWaitFor);
 
        void dispatchComputeShadersOnGraphicsQueue(
            ID3D12CommandAllocator* pCommandAllocator,
            std::unordered_map<Pipeline*, std::unordered_set<ComputeShaderInterface*>>&
                computePipelinesToSubmit);
 
        std::variant<std::vector<DXGI_MODE_DESC>, Error> getSupportedDisplayModes() const;
 
        DirectXResource* getCurrentBackBufferResource();
 
        ComPtr<IDXGIFactory4> pFactory;
 
        ComPtr<ID3D12Device> pDevice;
 
        ComPtr<IDXGIAdapter3> pVideoAdapter;
 
        ComPtr<IDXGIOutput> pOutputAdapter;
 
        ComPtr<IDXGISwapChain3> pSwapChain;
 
        ComPtr<ID3D12CommandQueue> pCommandQueue;
 
        ComPtr<ID3D12GraphicsCommandList> pCommandList;
 
        ComPtr<ID3D12GraphicsCommandList> pComputeCommandList;
 
        ComPtr<ID3D12Fence> pFence;
 
#if defined(DEBUG)
        ComPtr<ID3D12InfoQueue1> pInfoQueue;
 
        ComPtr<ID3D12Debug> pDebugController;
#endif
 
        std::pair<std::recursive_mutex, UINT64> mtxCurrentFenceValue;
 
        std::vector<std::unique_ptr<DirectXResource>> vSwapChainBuffers;
 
        std::unique_ptr<DirectXResource> pDepthStencilBuffer;
 
        std::unique_ptr<DirectXResource> pDepthBufferNoMultisampling;
 
        float backBufferFillColor[4] = {0.0F, 0.0F, 0.0F, 1.0F};
 
        std::unique_ptr<DirectXResource> pMsaaRenderBuffer;
 
        std::vector<std::string> vSupportedGpuNames;
 
        std::pair<unsigned int, unsigned int> renderTargetSize = {0, 0};
 
        UINT iMsaaQualityLevelsCount = 0;
 
        D3D12_VIEWPORT screenViewport;
 
        D3D12_RECT scissorRect;
 
        std::string sUsedVideoAdapter;
 
        UINT iPresentSyncInterval = 0;
 
        UINT iPresentFlags = 0;
 
        bool bIsUsingMsaaRenderTarget = true;
 
        bool bIsDirectXInitialized = false;
 
        static constexpr DXGI_FORMAT backBufferFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
 
        static constexpr DXGI_FORMAT depthStencilBufferFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
 
        static constexpr DXGI_FORMAT shadowMapFormat = DXGI_FORMAT_D24_UNORM_S8_UINT;
 
        static constexpr DXGI_FORMAT shadowMappingPointLightColorTargetFormat = DXGI_FORMAT_R32_FLOAT;
 
        static constexpr DXGI_FORMAT depthBufferNoMultisamplingFormat = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
 
        static constexpr DXGI_MODE_SCALING usedScaling = DXGI_MODE_SCALING_UNSPECIFIED;
 
        static constexpr DXGI_MODE_SCANLINE_ORDER usedScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE;
 
        static constexpr D3D_FEATURE_LEVEL rendererD3dFeatureLevel =
            D3D_FEATURE_LEVEL::D3D_FEATURE_LEVEL_12_1;
    };
} // namespace ne