dx12_api.hpp

#pragma once
 
#include <litefx/config.h>
 
#if !defined (LITEFX_DIRECTX12_API)
#  if defined(LiteFX_Backends_DirectX12_EXPORTS) && (defined _WIN32 || defined WINCE)
#    define LITEFX_DIRECTX12_API __declspec(dllexport)
#  elif (defined(LiteFX_Backends_DirectX12_EXPORTS) || defined(__APPLE__)) && defined __GNUC__ && __GNUC__ >= 4
#    define LITEFX_DIRECTX12_API __attribute__ ((visibility ("default")))
#  elif !defined(LiteFX_Backends_DirectX12_EXPORTS) && (defined _WIN32 || defined WINCE)
#    define LITEFX_DIRECTX12_API __declspec(dllimport)
#  endif
#endif 
 
#ifndef LITEFX_DIRECTX12_API
#  define LITEFX_DIRECTX12_API
#endif
 
#if (!defined _WIN32 && !defined WINCE)
#  pragma message ("DirectX12: The DirectX backend requires Windows to be built on.")
#endif
 
#ifdef LITEFX_DEFINE_GLOBAL_EXPORTS
#include <d3d12agility.hpp>
#endif // LITEFX_DEFINE_GLOBAL_EXPORTS
 
#include <directx/d3d12.h>
#include <directx/dxcore.h>
#include <directx/d3dx12.h>
#include <dxguids/dxguids.h>
#include <dxgi1_6.h>
#include <dxcapi.h>
#include <comdef.h>
 
#include <wrl.h>
using namespace Microsoft::WRL;
 
#include <litefx/rendering.hpp>
#include "dx12_formatters.hpp"
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    constexpr StringView DIRECTX12_LOG = "Backend::DirectX12"sv;
 
    // Forward declarations.
    class DirectX12VertexBufferLayout;
    class DirectX12IndexBufferLayout;
    class DirectX12DescriptorLayout;
    class DirectX12DescriptorSetLayout;
    class DirectX12DescriptorSet;
    class DirectX12PushConstantsRange;
    class DirectX12PushConstantsLayout;
    class DirectX12PipelineLayout;
    class DirectX12ShaderModule;
    class DirectX12ShaderProgram;
    class DirectX12CommandBuffer;
    class DirectX12Barrier;
    class DirectX12InputAssembler;
    class DirectX12Rasterizer;
    class DirectX12PipelineState;
    class DirectX12RenderPipeline;
    class DirectX12ComputePipeline;
    class DirectX12RayTracingPipeline;
    class DirectX12FrameBuffer;
    class DirectX12RenderPass;
    class DirectX12SwapChain;
    class DirectX12Queue;
    class DirectX12GraphicsFactory;
    class DirectX12Device;
    class DirectX12Backend;
 
    // Interface declarations.
    class IDirectX12Buffer;
    class IDirectX12VertexBuffer;
    class IDirectX12IndexBuffer;
    class IDirectX12Image;
    class IDirectX12Sampler;
    class IDirectX12AccelerationStructure;
    class DirectX12BottomLevelAccelerationStructure;
    class DirectX12TopLevelAccelerationStructure;
 
#if defined(LITEFX_BUILD_DEFINE_BUILDERS)
    // Builder declarations.
    class DirectX12VertexBufferLayoutBuilder;
    class DirectX12DescriptorSetLayoutBuilder;
    class DirectX12PushConstantsLayoutBuilder;
    class DirectX12PipelineLayoutBuilder;
    class DirectX12ShaderProgramBuilder;
    class DirectX12InputAssemblerBuilder;
    class DirectX12RasterizerBuilder;
    class DirectX12RenderPipelineBuilder;
    class DirectX12ComputePipelineBuilder;
    class DirectX12RayTracingPipelineBuilder;
    class DirectX12RenderPassBuilder;
    class DirectX12BarrierBuilder;
#endif // defined(LITEFX_BUILD_DEFINE_BUILDERS)
 
    template <class THandle>
    using ComResource = Resource<ComPtr<THandle>>;
    // TODO: We could overwrite the handle() methods here and return `.AsWeak` from the ComPtr and create an overload to get a reference-counted handle, if required.
 
    namespace DX12
    {
        Format LITEFX_DIRECTX12_API getFormat(const DXGI_FORMAT& format);
 
        DXGI_FORMAT LITEFX_DIRECTX12_API getFormat(Format format);
 
        DXGI_FORMAT LITEFX_DIRECTX12_API getFormat(BufferFormat format);
 
        bool LITEFX_DIRECTX12_API isSRGB(Format format);
 
        D3D12_RESOURCE_DIMENSION LITEFX_DIRECTX12_API getImageType(ImageDimensions dimensions);
 
        PolygonMode LITEFX_DIRECTX12_API getPolygonMode(const D3D12_FILL_MODE& mode);
 
        D3D12_FILL_MODE LITEFX_DIRECTX12_API getPolygonMode(PolygonMode mode);
 
        CullMode LITEFX_DIRECTX12_API getCullMode(const D3D12_CULL_MODE& mode);
 
        D3D12_CULL_MODE LITEFX_DIRECTX12_API getCullMode(CullMode mode);
 
        PrimitiveTopology LITEFX_DIRECTX12_API getPrimitiveTopology(const D3D12_PRIMITIVE_TOPOLOGY& topology);
 
        D3D12_PRIMITIVE_TOPOLOGY LITEFX_DIRECTX12_API getPrimitiveTopology(PrimitiveTopology topology);
 
        D3D12_PRIMITIVE_TOPOLOGY_TYPE LITEFX_DIRECTX12_API getPrimitiveTopologyType(PrimitiveTopology topology);
 
        LPCTSTR LITEFX_DIRECTX12_API getSemanticName(AttributeSemantic semantic);
 
        String LITEFX_DIRECTX12_API getVendorName(UInt32 vendorId);
 
        D3D12_COMPARISON_FUNC LITEFX_DIRECTX12_API getCompareOp(CompareOperation compareOp);
 
        D3D12_STENCIL_OP LITEFX_DIRECTX12_API getStencilOp(StencilOperation stencilOp);
 
        D3D12_BLEND LITEFX_DIRECTX12_API getBlendFactor(BlendFactor blendFactor);
 
        D3D12_BLEND_OP LITEFX_DIRECTX12_API getBlendOperation(BlendOperation blendOperation);
 
        D3D12_BARRIER_SYNC LITEFX_DIRECTX12_API getPipelineStage(PipelineStage pipelineStage);
 
        D3D12_BARRIER_ACCESS LITEFX_DIRECTX12_API getResourceAccess(ResourceAccess resourceAccess);
 
        D3D12_BARRIER_LAYOUT LITEFX_DIRECTX12_API getImageLayout(ImageLayout imageLayout);
    }
 
    class LITEFX_DIRECTX12_API DirectX12GraphicsAdapter final : public IGraphicsAdapter, public ComResource<IDXGIAdapter4> {
        LITEFX_IMPLEMENTATION(DirectX12GraphicsAdapterImpl);
        friend struct SharedObject::Allocator<DirectX12GraphicsAdapter>;
 
    private:
        explicit DirectX12GraphicsAdapter(ComPtr<IDXGIAdapter4> adapter);
 
        DirectX12GraphicsAdapter(DirectX12GraphicsAdapter&&) noexcept = delete;
 
        DirectX12GraphicsAdapter(const DirectX12GraphicsAdapter&) = delete;
 
        DirectX12GraphicsAdapter& operator=(DirectX12GraphicsAdapter&&) noexcept = delete;
 
        DirectX12GraphicsAdapter& operator=(const DirectX12GraphicsAdapter&) = delete;
 
    public:
        ~DirectX12GraphicsAdapter() noexcept override;
 
    public:
        static inline auto create(ComPtr<IDXGIAdapter4> adapter) {
            return SharedObject::create<DirectX12GraphicsAdapter>(std::move(adapter));
        }
 
    public:
        String name() const override;
 
        UInt64 uniqueId() const noexcept override;
 
        UInt32 vendorId() const noexcept override;
 
        UInt32 deviceId() const noexcept override;
 
        GraphicsAdapterType type() const noexcept override;
 
        UInt64 driverVersion() const noexcept override;
 
        UInt32 apiVersion() const noexcept override;
 
        UInt64 dedicatedMemory() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Surface final : public ISurface, public Resource<HWND> {
    public:
        explicit DirectX12Surface(const HWND& hwnd) noexcept;
 
        DirectX12Surface(const DirectX12Surface&) = delete;
        
        DirectX12Surface(DirectX12Surface&&) noexcept = default;
        
        DirectX12Surface& operator=(const DirectX12Surface&) = delete;
        
        DirectX12Surface& operator=(DirectX12Surface&&) noexcept = default;
 
        ~DirectX12Surface() noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DX12PlatformException : public RuntimeException {
    private:
        HRESULT m_code;
        _com_error m_error;
 
    public:
        explicit DX12PlatformException(HRESULT result) :
            RuntimeException("{1} (HRESULT 0x{0:08X})", static_cast<unsigned>(result), _com_error(result).ErrorMessage()), m_code(result), m_error(result) { }
 
        explicit DX12PlatformException(HRESULT result, StringView message) :
            RuntimeException("{2} {1} (HRESULT 0x{0:08X})", static_cast<unsigned>(result), _com_error(result).ErrorMessage(), message), m_code(result), m_error(result) { }
 
        template <typename ...TArgs>
        explicit DX12PlatformException(HRESULT result, std::format_string<TArgs...> format, TArgs&&... args) :
            DX12PlatformException(result, std::format(format, std::forward<TArgs>(args)...)) { }
 
        DX12PlatformException(DX12PlatformException&&) noexcept = default;
 
        DX12PlatformException(const DX12PlatformException&) = default;
 
        DX12PlatformException& operator=(DX12PlatformException&&) noexcept = default;
        
        DX12PlatformException& operator=(const DX12PlatformException&) = default;
        
        ~DX12PlatformException() noexcept override = default;
 
    public:
        const _com_error& error() const noexcept {
            return m_error;
        }
 
        HRESULT code() const noexcept {
            return m_code;
        }
    };
 
    template <typename ...TArgs>
    static inline void raiseIfFailed(HRESULT hr, std::format_string<TArgs...> message, TArgs&&... args) {
        if (SUCCEEDED(hr)) [[likely]]
            return;
        else
            throw DX12PlatformException(hr, message, std::forward<TArgs>(args)...);
    }
}