dx12.hpp

#pragma once
 
#include <litefx/rendering.hpp>
 
#include "dx12_api.hpp"
#include "dx12_formatters.hpp"
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    class LITEFX_DIRECTX12_API DirectX12VertexBufferLayout : public IVertexBufferLayout {
        LITEFX_IMPLEMENTATION(DirectX12VertexBufferLayoutImpl);
        LITEFX_BUILDER(DirectX12VertexBufferLayoutBuilder);
 
    public:
        explicit DirectX12VertexBufferLayout(const size_t& vertexSize, const UInt32& binding = 0);
        DirectX12VertexBufferLayout(DirectX12VertexBufferLayout&&) = delete;
        DirectX12VertexBufferLayout(const DirectX12VertexBufferLayout&) = delete;
        virtual ~DirectX12VertexBufferLayout() noexcept;
 
        // IVertexBufferLayout interface.
    public:
        virtual Array<const BufferAttribute*> attributes() const noexcept override;
 
        // IBufferLayout interface.
    public:
        virtual size_t elementSize() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const BufferType& type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12IndexBufferLayout : public IIndexBufferLayout {
        LITEFX_IMPLEMENTATION(DirectX12IndexBufferLayoutImpl);
 
    public:
        explicit DirectX12IndexBufferLayout(const IndexType& type);
        DirectX12IndexBufferLayout(DirectX12IndexBufferLayout&&) = delete;
        DirectX12IndexBufferLayout(const DirectX12IndexBufferLayout&) = delete;
        virtual ~DirectX12IndexBufferLayout() noexcept;
 
        // IIndexBufferLayout interface.
    public:
        virtual const IndexType& indexType() const noexcept override;
 
        // IBufferLayout interface.
    public:
        virtual size_t elementSize() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const BufferType& type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12Buffer : public virtual IBuffer, public virtual IResource<ComPtr<ID3D12Resource>> {
    public:
        virtual ~IDirectX12Buffer() noexcept = default;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12VertexBuffer : public virtual VertexBuffer<DirectX12VertexBufferLayout>, public virtual IDirectX12Buffer {
    public:
        virtual ~IDirectX12VertexBuffer() noexcept = default;
 
    public:
        virtual const D3D12_VERTEX_BUFFER_VIEW& view() const noexcept = 0;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12IndexBuffer : public virtual IndexBuffer<DirectX12IndexBufferLayout>, public virtual IDirectX12Buffer {
    public:
        virtual ~IDirectX12IndexBuffer() noexcept = default;
 
    public:
        virtual const D3D12_INDEX_BUFFER_VIEW& view() const noexcept = 0;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12Image : public virtual IImage, public virtual IResource<ComPtr<ID3D12Resource>> {
    public:
        virtual ~IDirectX12Image() noexcept = default;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12Sampler : public virtual ISampler {
    public:
        virtual ~IDirectX12Sampler() noexcept = default;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Barrier : public Barrier<IDirectX12Buffer, IDirectX12Image> {
        LITEFX_IMPLEMENTATION(DirectX12BarrierImpl);
 
    public:
        explicit DirectX12Barrier() noexcept;
        DirectX12Barrier(const DirectX12Barrier&) = delete;
        DirectX12Barrier(DirectX12Barrier&&) = delete;
        virtual ~DirectX12Barrier() noexcept;
 
        // Barrier interface.
    public:
        virtual void transition(IDirectX12Buffer& buffer, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Buffer& buffer, const UInt32& element, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Buffer& buffer, const ResourceState& sourceState, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Buffer& buffer, const ResourceState& sourceState, const UInt32& element, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Image& image, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Image& image, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Image& image, const ResourceState& sourceState, const ResourceState& targetState) override;
 
        virtual void transition(IDirectX12Image& image, const ResourceState& sourceState, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) override;
 
        virtual void waitFor(const IDirectX12Buffer& buffer) override;
 
        virtual void waitFor(const IDirectX12Image& image) override;
 
    public:
        virtual void execute(const DirectX12CommandBuffer& commandBuffer, const D3D12_RESOURCE_BARRIER_FLAGS& flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) const noexcept;
 
        virtual void executeInverse(const DirectX12CommandBuffer& commandBuffer, const D3D12_RESOURCE_BARRIER_FLAGS& flags = D3D12_RESOURCE_BARRIER_FLAG_NONE) const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ShaderModule : public IShaderModule, public ComResource<IDxcBlob> {
        LITEFX_IMPLEMENTATION(DirectX12ShaderModuleImpl);
 
    public:
        explicit DirectX12ShaderModule(const DirectX12Device& device, const ShaderStage& type, const String& fileName, const String& entryPoint = "main");
 
        explicit DirectX12ShaderModule(const DirectX12Device& device, const ShaderStage& type, std::istream& stream, const String& name, const String& entryPoint = "main");
        DirectX12ShaderModule(const DirectX12ShaderModule&) noexcept = delete;
        DirectX12ShaderModule(DirectX12ShaderModule&&) noexcept = delete;
        virtual ~DirectX12ShaderModule() noexcept;
 
        // IShaderModule interface.
    public:
        virtual const String& fileName() const noexcept override;
 
        virtual const String& entryPoint() const noexcept override;
 
        virtual const ShaderStage& type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ShaderProgram : public ShaderProgram<DirectX12ShaderModule> {
        LITEFX_IMPLEMENTATION(DirectX12ShaderProgramImpl);
        LITEFX_BUILDER(DirectX12ShaderProgramBuilder);
 
    public:
        explicit DirectX12ShaderProgram(const DirectX12Device& device, Array<UniquePtr<DirectX12ShaderModule>>&& modules) noexcept;
        DirectX12ShaderProgram(DirectX12ShaderProgram&&) noexcept = delete;
        DirectX12ShaderProgram(const DirectX12ShaderProgram&) noexcept = delete;
        virtual ~DirectX12ShaderProgram() noexcept;
 
    private:
        explicit DirectX12ShaderProgram(const DirectX12Device& device) noexcept;
 
    public:
        virtual Array<const DirectX12ShaderModule*> modules() const noexcept override;
 
        virtual SharedPtr<DirectX12PipelineLayout> reflectPipelineLayout() const;
 
    private:
        virtual SharedPtr<IPipelineLayout> parsePipelineLayout() const override {
            return std::static_pointer_cast<IPipelineLayout>(this->reflectPipelineLayout());
        }
 
    public:
        static void suppressMissingRootSignatureWarning(bool disableWarning = true) noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12DescriptorSet : public DescriptorSet<IDirectX12Buffer, IDirectX12Image, IDirectX12Sampler> {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorSetImpl);
 
    public:
        explicit DirectX12DescriptorSet(const DirectX12DescriptorSetLayout& layout, ComPtr<ID3D12DescriptorHeap>&& bufferHeap, ComPtr<ID3D12DescriptorHeap>&& samplerHeap);
        DirectX12DescriptorSet(DirectX12DescriptorSet&&) = delete;
        DirectX12DescriptorSet(const DirectX12DescriptorSet&) = delete;
        virtual ~DirectX12DescriptorSet() noexcept;
 
    public:
        virtual const DirectX12DescriptorSetLayout& layout() const noexcept;
 
    public:
        virtual void update(const UInt32& binding, const IDirectX12Buffer& buffer, const UInt32& bufferElement = 0, const UInt32& elements = 1, const UInt32& firstDescriptor = 0) const override;
 
        virtual void update(const UInt32& binding, const IDirectX12Image& texture, const UInt32& descriptor = 0, const UInt32& firstLevel = 0, const UInt32& levels = 0, const UInt32& firstLayer = 0, const UInt32& layers = 0) const override;
 
        virtual void update(const UInt32& binding, const IDirectX12Sampler& sampler, const UInt32& descriptor = 0) const override;
 
        virtual void attach(const UInt32& binding, const IDirectX12Image& image) const override;
 
    public:
        virtual const ComPtr<ID3D12DescriptorHeap>& bufferHeap() const noexcept;
 
        virtual const UInt32& bufferOffset() const noexcept;
 
        virtual const ComPtr<ID3D12DescriptorHeap>& samplerHeap() const noexcept;
 
        virtual const UInt32& samplerOffset() const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12DescriptorLayout : public IDescriptorLayout {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorLayoutImpl);
 
    public:
        explicit DirectX12DescriptorLayout(const DescriptorType& type, const UInt32& binding, const size_t& elementSize, const UInt32& descriptors = 1);
 
        explicit DirectX12DescriptorLayout(UniquePtr<IDirectX12Sampler>&& staticSampler, const UInt32& binding);
 
        DirectX12DescriptorLayout(DirectX12DescriptorLayout&&) = delete;
        DirectX12DescriptorLayout(const DirectX12DescriptorLayout&) = delete;
        virtual ~DirectX12DescriptorLayout() noexcept;
 
        // IDescriptorLayout interface.
    public:
        virtual const DescriptorType& descriptorType() const noexcept override;
 
        virtual const UInt32& descriptors() const noexcept override;
 
        virtual const IDirectX12Sampler* staticSampler() const noexcept override;
 
        // IBufferLayout interface.
    public:
        virtual size_t elementSize() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const BufferType& type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12DescriptorSetLayout : public DescriptorSetLayout<DirectX12DescriptorLayout, DirectX12DescriptorSet> {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorSetLayoutImpl);
        LITEFX_BUILDER(DirectX12DescriptorSetLayoutBuilder);
        friend class DirectX12PipelineLayout;
 
    public:
        explicit DirectX12DescriptorSetLayout(const DirectX12Device& device, Array<UniquePtr<DirectX12DescriptorLayout>>&& descriptorLayouts, const UInt32& space, const ShaderStage& stages);
        DirectX12DescriptorSetLayout(DirectX12DescriptorSetLayout&&) = delete;
        DirectX12DescriptorSetLayout(const DirectX12DescriptorSetLayout&) = delete;
        virtual ~DirectX12DescriptorSetLayout() noexcept;
 
    private:
        explicit DirectX12DescriptorSetLayout(const DirectX12Device& device) noexcept;
 
    public:
        virtual const UInt32& rootParameterIndex() const noexcept;
 
        virtual UInt32 descriptorOffsetForBinding(const UInt32& binding) const;
 
        virtual const DirectX12Device& device() const noexcept;
 
    protected:
        virtual UInt32& rootParameterIndex() noexcept;
 
        virtual bool isRuntimeArray() const noexcept;
 
    public:
        virtual Array<const DirectX12DescriptorLayout*> descriptors() const noexcept override;
 
        virtual const DirectX12DescriptorLayout& descriptor(const UInt32& binding) const override;
 
        virtual const UInt32& space() const noexcept override;
 
        virtual const ShaderStage& shaderStages() const noexcept override;
 
        virtual UInt32 uniforms() const noexcept override;
 
        virtual UInt32 storages() const noexcept override;
 
        virtual UInt32 images() const noexcept override;
 
        virtual UInt32 buffers() const noexcept override;
 
        virtual UInt32 samplers() const noexcept override;
 
        virtual UInt32 staticSamplers() const noexcept override;
 
        virtual UInt32 inputAttachments() const noexcept override;
 
    public:
        virtual UniquePtr<DirectX12DescriptorSet> allocate(const UInt32& descriptors = 0) const override;
 
        virtual Array<UniquePtr<DirectX12DescriptorSet>> allocateMultiple(const UInt32& descriptorSets, const UInt32& descriptors = 0) const override;
 
        virtual void free(const DirectX12DescriptorSet& descriptorSet) const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PushConstantsRange : public IPushConstantsRange {
        LITEFX_IMPLEMENTATION(DirectX12PushConstantsRangeImpl);
        friend class DirectX12PipelineLayout;
 
    public:
        explicit DirectX12PushConstantsRange(const ShaderStage& shaderStages, const UInt32& offset, const UInt32& size, const UInt32& space, const UInt32& binding);
        DirectX12PushConstantsRange(const DirectX12PushConstantsRange&) = delete;
        DirectX12PushConstantsRange(DirectX12PushConstantsRange&&) = delete;
        virtual ~DirectX12PushConstantsRange() noexcept;
 
    public:
        virtual const UInt32& space() const noexcept override;
 
        virtual const UInt32& binding() const noexcept override;
 
        virtual const UInt32& offset() const noexcept override;
 
        virtual const UInt32& size() const noexcept override;
 
        virtual const ShaderStage& stage() const noexcept override;
 
    public:
        virtual const UInt32& rootParameterIndex() const noexcept;
 
    protected:
        virtual UInt32& rootParameterIndex() noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PushConstantsLayout : public PushConstantsLayout<DirectX12PushConstantsRange> {
        LITEFX_IMPLEMENTATION(DirectX12PushConstantsLayoutImpl);
        LITEFX_BUILDER(DirectX12PushConstantsLayoutBuilder);
        friend class DirectX12PipelineLayout;
 
    public:
        explicit DirectX12PushConstantsLayout(Array<UniquePtr<DirectX12PushConstantsRange>>&& ranges, const UInt32& size);
        DirectX12PushConstantsLayout(const DirectX12PushConstantsLayout&) = delete;
        DirectX12PushConstantsLayout(DirectX12PushConstantsLayout&&) = delete;
        virtual ~DirectX12PushConstantsLayout() noexcept;
 
    private:
        explicit DirectX12PushConstantsLayout(const UInt32& size);
 
    public:
        virtual const UInt32& size() const noexcept override;
 
        virtual const DirectX12PushConstantsRange& range(const ShaderStage& stage) const override;
 
        virtual Array<const DirectX12PushConstantsRange*> ranges() const noexcept override;
 
    protected:
        virtual Array<DirectX12PushConstantsRange*> ranges() noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PipelineLayout : public PipelineLayout<DirectX12DescriptorSetLayout, DirectX12PushConstantsLayout>, public ComResource<ID3D12RootSignature> {
        LITEFX_IMPLEMENTATION(DirectX12PipelineLayoutImpl);
        LITEFX_BUILDER(DirectX12PipelineLayoutBuilder);
 
    public:
        explicit DirectX12PipelineLayout(const DirectX12Device& device, Array<UniquePtr<DirectX12DescriptorSetLayout>>&& descriptorSetLayouts, UniquePtr<DirectX12PushConstantsLayout>&& pushConstantsLayout);
 
        DirectX12PipelineLayout(DirectX12PipelineLayout&&) noexcept = delete;
        DirectX12PipelineLayout(const DirectX12PipelineLayout&) noexcept = delete;
        virtual ~DirectX12PipelineLayout() noexcept;
 
    private:
        explicit DirectX12PipelineLayout(const DirectX12Device& device) noexcept;
 
    public:
        virtual const DirectX12Device& device() const noexcept;
 
        // PipelineLayout interface.
    public:
        virtual const DirectX12DescriptorSetLayout& descriptorSet(const UInt32& space) const override;
 
        virtual Array<const DirectX12DescriptorSetLayout*> descriptorSets() const noexcept override;
 
        virtual const DirectX12PushConstantsLayout* pushConstants() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12InputAssembler : public InputAssembler<DirectX12VertexBufferLayout, DirectX12IndexBufferLayout> {
        LITEFX_IMPLEMENTATION(DirectX12InputAssemblerImpl);
        LITEFX_BUILDER(DirectX12InputAssemblerBuilder);
 
    public:
        explicit DirectX12InputAssembler(Array<UniquePtr<DirectX12VertexBufferLayout>>&& vertexBufferLayouts, UniquePtr<DirectX12IndexBufferLayout>&& indexBufferLayout, const PrimitiveTopology& primitiveTopology = PrimitiveTopology::TriangleList);
        DirectX12InputAssembler(DirectX12InputAssembler&&) noexcept = delete;
        DirectX12InputAssembler(const DirectX12InputAssembler&) noexcept = delete;
        virtual ~DirectX12InputAssembler() noexcept;
 
    private:
        explicit DirectX12InputAssembler() noexcept;
 
    public:
        virtual Array<const DirectX12VertexBufferLayout*> vertexBufferLayouts() const noexcept override;
 
        virtual const DirectX12VertexBufferLayout& vertexBufferLayout(const UInt32& binding) const override;
 
        virtual const DirectX12IndexBufferLayout& indexBufferLayout() const override;
 
        virtual const PrimitiveTopology& topology() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Rasterizer : public Rasterizer {
        LITEFX_BUILDER(DirectX12RasterizerBuilder);
 
    public:
        explicit DirectX12Rasterizer(const PolygonMode& polygonMode, const CullMode& cullMode, const CullOrder& cullOrder, const Float& lineWidth = 1.f, const DepthStencilState& depthStencilState = {}) noexcept;
        DirectX12Rasterizer(DirectX12Rasterizer&&) noexcept = delete;
        DirectX12Rasterizer(const DirectX12Rasterizer&) noexcept = delete;
        virtual ~DirectX12Rasterizer() noexcept;
 
    private:
        explicit DirectX12Rasterizer() noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PipelineState : public virtual Pipeline<DirectX12PipelineLayout, DirectX12ShaderProgram>, public ComResource<ID3D12PipelineState> {
    public:
        using ComResource<ID3D12PipelineState>::ComResource;
        virtual ~DirectX12PipelineState() noexcept = default;
 
    public:
        virtual void use(const DirectX12CommandBuffer& commandBuffer) const noexcept = 0;
    };
 
    class LITEFX_DIRECTX12_API DirectX12CommandBuffer : public CommandBuffer<IDirectX12Buffer, IDirectX12VertexBuffer, IDirectX12IndexBuffer, IDirectX12Image, DirectX12Barrier, DirectX12PipelineState>, public ComResource<ID3D12GraphicsCommandList4> {
        LITEFX_IMPLEMENTATION(DirectX12CommandBufferImpl);
 
    public:
        explicit DirectX12CommandBuffer(const DirectX12Queue& queue, const bool& begin = false);
        DirectX12CommandBuffer(const DirectX12CommandBuffer&) = delete;
        DirectX12CommandBuffer(DirectX12CommandBuffer&&) = delete;
        virtual ~DirectX12CommandBuffer() noexcept;
 
        // CommandBuffer interface.
    public:
        virtual void begin() const override;
 
        virtual void end() const override;
 
        virtual void generateMipMaps(IDirectX12Image& image) noexcept override;
 
        virtual void barrier(const DirectX12Barrier& barrier, const bool& invert = false) const noexcept override;
 
        virtual void transfer(const IDirectX12Buffer& source, const IDirectX12Buffer& target, const UInt32& sourceElement = 0, const UInt32& targetElement = 0, const UInt32& elements = 1) const override;
 
        virtual void transfer(const IDirectX12Buffer& source, const IDirectX12Image& target, const UInt32& sourceElement = 0, const UInt32& firstSubresource = 0, const UInt32& elements = 1) const override;
 
        virtual void transfer(const IDirectX12Image& source, const IDirectX12Image& target, const UInt32& sourceSubresource = 0, const UInt32& targetSubresource = 0, const UInt32& subresources = 1) const override;
 
        virtual void transfer(const IDirectX12Image& source, const IDirectX12Buffer& target, const UInt32& firstSubresource = 0, const UInt32& targetElement = 0, const UInt32& subresources = 1) const override;
 
        virtual void use(const DirectX12PipelineState& pipeline) const noexcept override;
 
        virtual void bind(const DirectX12DescriptorSet& descriptorSet, const DirectX12PipelineState& pipeline) const noexcept override;
 
        virtual void bind(const IDirectX12VertexBuffer& buffer) const noexcept override;
 
        virtual void bind(const IDirectX12IndexBuffer& buffer) const noexcept override;
 
        virtual void dispatch(const Vector3u& threadCount) const noexcept override;
 
        virtual void draw(const UInt32& vertices, const UInt32& instances = 1, const UInt32& firstVertex = 0, const UInt32& firstInstance = 0) const noexcept override;
 
        virtual void drawIndexed(const UInt32& indices, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const noexcept override;
        
        virtual void pushConstants(const DirectX12PushConstantsLayout& layout, const void* const memory) const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RenderPipeline : public virtual DirectX12PipelineState, public RenderPipeline<DirectX12PipelineLayout, DirectX12ShaderProgram, DirectX12InputAssembler, DirectX12Rasterizer> {
        LITEFX_IMPLEMENTATION(DirectX12RenderPipelineImpl);
        LITEFX_BUILDER(DirectX12RenderPipelineBuilder);
 
    public:
        explicit DirectX12RenderPipeline(const DirectX12RenderPass& renderPass, SharedPtr<DirectX12PipelineLayout> layout, SharedPtr<DirectX12ShaderProgram> shaderProgram, SharedPtr<DirectX12InputAssembler> inputAssembler, SharedPtr<DirectX12Rasterizer> rasterizer, Array<SharedPtr<IViewport>>&& viewports, Array<SharedPtr<IScissor>>&& scissors, const bool enableAlphaToCoverage = false, const String& name = "");
        DirectX12RenderPipeline(DirectX12RenderPipeline&&) noexcept = delete;
        DirectX12RenderPipeline(const DirectX12RenderPipeline&) noexcept = delete;
        virtual ~DirectX12RenderPipeline() noexcept;
 
    private:
        DirectX12RenderPipeline(const DirectX12RenderPass& renderPass, const String& name = "") noexcept;
 
        // Pipeline interface.
    public:
        virtual SharedPtr<const DirectX12ShaderProgram> program() const noexcept override;
 
        virtual SharedPtr<const DirectX12PipelineLayout> layout() const noexcept override;
 
        // RenderPipeline interface.
    public:
        virtual SharedPtr<DirectX12InputAssembler> inputAssembler() const noexcept override;
 
        virtual SharedPtr<DirectX12Rasterizer> rasterizer() const noexcept override;
 
        virtual Array<const IViewport*> viewports() const noexcept override;
 
        virtual Array<const IScissor*> scissors() const noexcept override;
 
        virtual UInt32& stencilRef() const noexcept override;
 
        virtual Vector4f& blendFactors() const noexcept override;
 
        virtual const bool& alphaToCoverage() const noexcept override;
 
        // DirectX12PipelineState interface.
    public:
        virtual void use(const DirectX12CommandBuffer& commandBuffer) const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ComputePipeline : public virtual DirectX12PipelineState, public ComputePipeline<DirectX12PipelineLayout, DirectX12ShaderProgram> {
        LITEFX_IMPLEMENTATION(DirectX12ComputePipelineImpl);
        LITEFX_BUILDER(DirectX12ComputePipelineBuilder);
 
    public:
        explicit DirectX12ComputePipeline(const DirectX12Device& device, SharedPtr<DirectX12PipelineLayout> layout, SharedPtr<DirectX12ShaderProgram> shaderProgram, const String& name = "");
        DirectX12ComputePipeline(DirectX12ComputePipeline&&) noexcept = delete;
        DirectX12ComputePipeline(const DirectX12ComputePipeline&) noexcept = delete;
        virtual ~DirectX12ComputePipeline() noexcept;
 
    private:
        DirectX12ComputePipeline(const DirectX12Device& device) noexcept;
 
        // Pipeline interface.
    public:
        virtual SharedPtr<const DirectX12ShaderProgram> program() const noexcept override;
 
        virtual SharedPtr<const DirectX12PipelineLayout> layout() const noexcept override;
 
        // DirectX12PipelineState interface.
    public:
        virtual void use(const DirectX12CommandBuffer& commandBuffer) const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12FrameBuffer : public FrameBuffer<DirectX12CommandBuffer> {
        LITEFX_IMPLEMENTATION(DirectX12FrameBufferImpl);
 
    public:
        DirectX12FrameBuffer(const DirectX12RenderPass& renderPass, const UInt32& bufferIndex, const Size2d& renderArea, const UInt32& commandBuffers = 1);
        DirectX12FrameBuffer(const DirectX12FrameBuffer&) noexcept = delete;
        DirectX12FrameBuffer(DirectX12FrameBuffer&&) noexcept = delete;
        virtual ~DirectX12FrameBuffer() noexcept;
 
        // DirectX 12 FrameBuffer
    public:
        virtual ID3D12DescriptorHeap* renderTargetHeap() const noexcept;
 
        virtual ID3D12DescriptorHeap* depthStencilTargetHeap() const noexcept;
 
        virtual const UInt32& renderTargetDescriptorSize() const noexcept;
 
        virtual const UInt32& depthStencilTargetDescriptorSize() const noexcept;
 
        virtual UInt64& lastFence() const noexcept;
 
        // FrameBuffer interface.
    public:
        virtual const UInt32& bufferIndex() const noexcept override;
 
        virtual const Size2d& size() const noexcept override;
 
        virtual size_t getWidth() const noexcept override;
 
        virtual size_t getHeight() const noexcept override;
 
        virtual Array<const DirectX12CommandBuffer*> commandBuffers() const noexcept override;
 
        virtual const DirectX12CommandBuffer& commandBuffer(const UInt32& index) const override;
 
        virtual Array<const IDirectX12Image*> images() const noexcept override;
 
        virtual const IDirectX12Image& image(const UInt32& location) const override;
 
    public:
        virtual void resize(const Size2d& renderArea) override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RenderPass : public RenderPass<DirectX12RenderPipeline, DirectX12FrameBuffer, DirectX12InputAttachmentMapping> {
        LITEFX_IMPLEMENTATION(DirectX12RenderPassImpl);
        LITEFX_BUILDER(DirectX12RenderPassBuilder);
 
    public:
        explicit DirectX12RenderPass(const DirectX12Device& device, Span<RenderTarget> renderTargets, const UInt32& commandBuffers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, Span<DirectX12InputAttachmentMapping> inputAttachments = { });
 
        explicit DirectX12RenderPass(const DirectX12Device& device, const String& name, Span<RenderTarget> renderTargets, const UInt32& commandBuffers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, Span<DirectX12InputAttachmentMapping> inputAttachments = { });
 
        DirectX12RenderPass(const DirectX12RenderPass&) = delete;
        DirectX12RenderPass(DirectX12RenderPass&&) = delete;
        virtual ~DirectX12RenderPass() noexcept;
 
    private:
        explicit DirectX12RenderPass(const DirectX12Device& device, const String& name = "") noexcept;
 
        // IInputAttachmentMappingSource interface.
    public:
        virtual const DirectX12FrameBuffer& frameBuffer(const UInt32& buffer) const override;
 
        // RenderPass interface.
    public:
        virtual const DirectX12Device& device() const noexcept;
 
        virtual const DirectX12FrameBuffer& activeFrameBuffer() const override;
 
        virtual Array<const DirectX12FrameBuffer*> frameBuffers() const noexcept override;
 
        virtual Array<const DirectX12RenderPipeline*> pipelines() const noexcept override;
 
        virtual const RenderTarget& renderTarget(const UInt32& location) const override;
 
        virtual Span<const RenderTarget> renderTargets() const noexcept override;
 
        virtual bool hasPresentTarget() const noexcept override;
 
        virtual Span<const DirectX12InputAttachmentMapping> inputAttachments() const noexcept override;
 
        virtual const MultiSamplingLevel& multiSamplingLevel() const noexcept override;
 
    public:
        virtual void begin(const UInt32& buffer) override;
 
        virtual void end() const override;
 
        virtual void resizeFrameBuffers(const Size2d& renderArea) override;
 
        virtual void changeMultiSamplingLevel(const MultiSamplingLevel& samples) override;
 
        virtual void updateAttachments(const DirectX12DescriptorSet& descriptorSet) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12InputAttachmentMapping : public IInputAttachmentMapping<DirectX12RenderPass> {
        LITEFX_IMPLEMENTATION(DirectX12InputAttachmentMappingImpl);
 
    public:
        DirectX12InputAttachmentMapping() noexcept;
 
        DirectX12InputAttachmentMapping(const DirectX12RenderPass& renderPass, const RenderTarget& renderTarget, const UInt32& location);
 
        DirectX12InputAttachmentMapping(const DirectX12InputAttachmentMapping&) noexcept;
 
        DirectX12InputAttachmentMapping(DirectX12InputAttachmentMapping&&) noexcept;
 
        virtual ~DirectX12InputAttachmentMapping() noexcept;
 
    public:
        inline DirectX12InputAttachmentMapping& operator=(const DirectX12InputAttachmentMapping&) noexcept;
 
        inline DirectX12InputAttachmentMapping& operator=(DirectX12InputAttachmentMapping&&) noexcept;
 
    public:
        virtual const DirectX12RenderPass* inputAttachmentSource() const noexcept override;
 
        virtual const RenderTarget& renderTarget() const noexcept override;
 
        virtual const UInt32& location() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12SwapChain : public SwapChain<IDirectX12Image, DirectX12FrameBuffer>, public ComResource<IDXGISwapChain4> {
        LITEFX_IMPLEMENTATION(DirectX12SwapChainImpl);
 
    public:
        explicit DirectX12SwapChain(const DirectX12Device& device, const Format& surfaceFormat = Format::B8G8R8A8_SRGB, const Size2d& renderArea = { 800, 600 }, const UInt32& buffers = 3);
        DirectX12SwapChain(const DirectX12SwapChain&) = delete;
        DirectX12SwapChain(DirectX12SwapChain&&) = delete;
        virtual ~DirectX12SwapChain() noexcept;
 
        // DirectX 12 swap chain.
    public:
        virtual const bool& supportsVariableRefreshRate() const noexcept;
 
        // SwapChain interface.
    public:
        virtual const Format& surfaceFormat() const noexcept override;
 
        virtual const UInt32& buffers() const noexcept override;
 
        virtual const Size2d& renderArea() const noexcept override;
 
        virtual Array<const IDirectX12Image*> images() const noexcept override;
 
        virtual void present(const DirectX12FrameBuffer& frameBuffer) const override;
 
    public:
        virtual Array<Format> getSurfaceFormats() const noexcept override;
 
        virtual void reset(const Format& surfaceFormat, const Size2d& renderArea, const UInt32& buffers) override;
 
        [[nodiscard]] virtual UInt32 swapBackBuffer() const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Queue : public CommandQueue<DirectX12CommandBuffer>, public ComResource<ID3D12CommandQueue> {
        LITEFX_IMPLEMENTATION(DirectX12QueueImpl);
 
    public:
        explicit DirectX12Queue(const DirectX12Device& device, const QueueType& type, const QueuePriority& priority);
        DirectX12Queue(const DirectX12Queue&) = delete;
        DirectX12Queue(DirectX12Queue&&) = delete;
        virtual ~DirectX12Queue() noexcept;
 
        // DirectX12CommandQueue interface.
    public:
        virtual const DirectX12Device& device() const noexcept;
 
        // CommandQueue interface.
    public:
        virtual bool isBound() const noexcept override;
 
        virtual const QueuePriority& priority() const noexcept override;
 
        virtual const QueueType& type() const noexcept override;
 
    public:
        virtual void bind() override;
 
        virtual void release() override;
 
        virtual UniquePtr<DirectX12CommandBuffer> createCommandBuffer(const bool& beginRecording = false) const override;
 
        virtual UInt64 submit(const DirectX12CommandBuffer& commandBuffer) const override;
 
        virtual UInt64 submit(const Array<const DirectX12CommandBuffer*>& commandBuffers) const override;
 
        virtual void waitFor(const UInt64& fence) const noexcept override;
 
        virtual UInt64 currentFence() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12GraphicsFactory : public GraphicsFactory<DirectX12DescriptorLayout, IDirectX12Buffer, IDirectX12VertexBuffer, IDirectX12IndexBuffer, IDirectX12Image, IDirectX12Sampler> {
        LITEFX_IMPLEMENTATION(DirectX12GraphicsFactoryImpl);
 
    public:
        explicit DirectX12GraphicsFactory(const DirectX12Device& device);
        DirectX12GraphicsFactory(const DirectX12GraphicsFactory&) = delete;
        DirectX12GraphicsFactory(DirectX12GraphicsFactory&&) = delete;
        virtual ~DirectX12GraphicsFactory() noexcept;
 
    public:
        virtual UniquePtr<IDirectX12Buffer> createBuffer(const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const override;
 
        virtual UniquePtr<IDirectX12Buffer> createBuffer(const String& name, const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const override;
 
        virtual UniquePtr<IDirectX12VertexBuffer> createVertexBuffer(const DirectX12VertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements = 1) const override;
 
        virtual UniquePtr<IDirectX12VertexBuffer> createVertexBuffer(const String& name, const DirectX12VertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements = 1) const override;
 
        virtual UniquePtr<IDirectX12IndexBuffer> createIndexBuffer(const DirectX12IndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override;
 
        virtual UniquePtr<IDirectX12IndexBuffer> createIndexBuffer(const String& name, const DirectX12IndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override;
 
        virtual UniquePtr<IDirectX12Image> createAttachment(const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const override;
 
        virtual UniquePtr<IDirectX12Image> createAttachment(const String& name, const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const override;
 
        virtual UniquePtr<IDirectX12Image> createTexture(const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const override;
 
        virtual UniquePtr<IDirectX12Image> createTexture(const String& name, const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const override;
 
        virtual Array<UniquePtr<IDirectX12Image>> createTextures(const UInt32& elements, const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const override;
 
        virtual UniquePtr<IDirectX12Sampler> createSampler(const FilterMode& magFilter = FilterMode::Nearest, const FilterMode& minFilter = FilterMode::Nearest, const BorderMode& borderU = BorderMode::Repeat, const BorderMode& borderV = BorderMode::Repeat, const BorderMode& borderW = BorderMode::Repeat, const MipMapMode& mipMapMode = MipMapMode::Nearest, const Float& mipMapBias = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const override;
 
        virtual UniquePtr<IDirectX12Sampler> createSampler(const String& name, const FilterMode& magFilter = FilterMode::Nearest, const FilterMode& minFilter = FilterMode::Nearest, const BorderMode& borderU = BorderMode::Repeat, const BorderMode& borderV = BorderMode::Repeat, const BorderMode& borderW = BorderMode::Repeat, const MipMapMode& mipMapMode = MipMapMode::Nearest, const Float& mipMapBias = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const override;
 
        virtual Array<UniquePtr<IDirectX12Sampler>> createSamplers(const UInt32& elements, const FilterMode& magFilter = FilterMode::Nearest, const FilterMode& minFilter = FilterMode::Nearest, const BorderMode& borderU = BorderMode::Repeat, const BorderMode& borderV = BorderMode::Repeat, const BorderMode& borderW = BorderMode::Repeat, const MipMapMode& mipMapMode = MipMapMode::Nearest, const Float& mipMapBias = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Device : public GraphicsDevice<DirectX12GraphicsFactory, DirectX12Surface, DirectX12GraphicsAdapter, DirectX12SwapChain, DirectX12Queue, DirectX12RenderPass, DirectX12ComputePipeline, DirectX12Barrier>, public ComResource<ID3D12Device5> {
        LITEFX_IMPLEMENTATION(DirectX12DeviceImpl);
 
    public:
        explicit DirectX12Device(const DirectX12Backend& backend, const DirectX12GraphicsAdapter& adapter, UniquePtr<DirectX12Surface>&& surface);
 
        explicit DirectX12Device(const DirectX12Backend& backend, const DirectX12GraphicsAdapter& adapter, UniquePtr<DirectX12Surface>&& surface, const Format& format, const Size2d& frameBufferSize, const UInt32& frameBuffers, const UInt32& globalBufferHeapSize = 524287, const UInt32& globalSamplerHeapSize = 2048);
 
        DirectX12Device(const DirectX12Device&) = delete;
        DirectX12Device(DirectX12Device&&) = delete;
        virtual ~DirectX12Device() noexcept;
 
        // DirectX 12 Device interface.
    public:
        virtual const DirectX12Backend& backend() const noexcept;
 
        virtual const ID3D12DescriptorHeap* globalBufferHeap() const noexcept;
 
        virtual const ID3D12DescriptorHeap* globalSamplerHeap() const noexcept;
 
        virtual void allocateGlobalDescriptors(const DirectX12DescriptorSet& descriptorSet, UInt32& bufferOffset, UInt32& samplerOffset) const;
 
        virtual void releaseGlobalDescriptors(const DirectX12DescriptorSet& descriptorSet) const noexcept;
 
        virtual void updateBufferDescriptors(const DirectX12DescriptorSet& descriptorSet, const UInt32& firstDescriptor, const UInt32& descriptors) const noexcept;
 
        virtual void updateSamplerDescriptors(const DirectX12DescriptorSet& descriptorSet, const UInt32& firstDescriptor, const UInt32& descriptors) const noexcept;
 
        virtual void bindDescriptorSet(const DirectX12CommandBuffer& commandBuffer, const DirectX12DescriptorSet& descriptorSet, const DirectX12PipelineState& pipeline) const noexcept;
 
        virtual void bindGlobalDescriptorHeaps(const DirectX12CommandBuffer& commandBuffer) const noexcept;
 
        virtual DirectX12ComputePipeline& blitPipeline() const noexcept;
 
        // GraphicsDevice interface.
    public:
        virtual DeviceState& state() const noexcept override;
 
        virtual const DirectX12SwapChain& swapChain() const noexcept override;
 
        virtual DirectX12SwapChain& swapChain() noexcept override;
 
        virtual const DirectX12Surface& surface() const noexcept override;
 
        virtual const DirectX12GraphicsAdapter& adapter() const noexcept override;
 
        virtual const DirectX12GraphicsFactory& factory() const noexcept override;
 
        virtual const DirectX12Queue& graphicsQueue() const noexcept override;
 
        virtual const DirectX12Queue& transferQueue() const noexcept override;
 
        virtual const DirectX12Queue& bufferQueue() const noexcept override;
 
        virtual const DirectX12Queue& computeQueue() const noexcept override;
 
        virtual UniquePtr<DirectX12Barrier> makeBarrier() const noexcept override;
 
        virtual MultiSamplingLevel maximumMultiSamplingLevel(const Format& format) const noexcept override;
 
    public:
        virtual void wait() const override;
 
#if defined(BUILD_DEFINE_BUILDERS)
    public:
        [[nodiscard]] virtual DirectX12RenderPassBuilder buildRenderPass(const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const UInt32& commandBuffers = 1) const override;
 
        [[nodiscard]] virtual DirectX12RenderPassBuilder buildRenderPass(const String& name, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const UInt32& commandBuffers = 1) const override;
 
        //[[nodiscard]] virtual DirectX12RenderPipelineBuilder buildRenderPipeline(const String& name) const override;
 
        [[nodiscard]] virtual DirectX12RenderPipelineBuilder buildRenderPipeline(const DirectX12RenderPass& renderPass, const String& name) const override;
 
        [[nodiscard]] virtual DirectX12ComputePipelineBuilder buildComputePipeline(const String& name) const override;
        
        [[nodiscard]] virtual DirectX12PipelineLayoutBuilder buildPipelineLayout() const override;
 
        [[nodiscard]] virtual DirectX12InputAssemblerBuilder buildInputAssembler() const override;
 
        [[nodiscard]] virtual DirectX12RasterizerBuilder buildRasterizer() const override;
 
        [[nodiscard]] virtual DirectX12ShaderProgramBuilder buildShaderProgram() const override;
#endif // defined(BUILD_DEFINE_BUILDERS)
    };
    
    class LITEFX_DIRECTX12_API DirectX12Backend : public RenderBackend<DirectX12Backend, DirectX12Device>, public ComResource<IDXGIFactory7> {
        LITEFX_IMPLEMENTATION(DirectX12BackendImpl);
 
    public:
        explicit DirectX12Backend(const App& app, const bool& advancedSoftwareRasterizer = false);
        DirectX12Backend(const DirectX12Backend&) noexcept = delete;
        DirectX12Backend(DirectX12Backend&&) noexcept = delete;
        virtual ~DirectX12Backend();
 
        // IBackend interface.
    public:
        virtual BackendType type() const noexcept override;
 
        virtual String name() const noexcept override;
 
    protected:
        virtual void activate() override;
 
        virtual void deactivate() override;
 
        // RenderBackend interface.
    public:
        virtual Array<const DirectX12GraphicsAdapter*> listAdapters() const override;
 
        virtual const DirectX12GraphicsAdapter* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const override;
 
        virtual void registerDevice(String name, UniquePtr<DirectX12Device>&& device) override;
 
        virtual void releaseDevice(const String& name) override;
 
        virtual DirectX12Device* device(const String& name) noexcept override;
 
        virtual const DirectX12Device* device(const String& name) const noexcept override;
 
    public:
        UniquePtr<DirectX12Surface> createSurface(const HWND& hwnd) const;
 
        virtual void enableAdvancedSoftwareRasterizer(const bool& enable = false);
    };
}