dx12.hpp

#pragma once
 
#include <litefx/rendering.hpp>
 
#include "dx12_api.hpp"
#include "dx12_formatters.hpp"
 
#pragma warning(push)
#pragma warning(disable:4250) // Base class members are inherited via dominance.
 
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    class LITEFX_DIRECTX12_API DirectX12VertexBufferLayout final : public IVertexBufferLayout {
        LITEFX_IMPLEMENTATION(DirectX12VertexBufferLayoutImpl);
        LITEFX_BUILDER(DirectX12VertexBufferLayoutBuilder);
        friend struct SharedObject::Allocator<DirectX12VertexBufferLayout>;
 
    private:
        explicit DirectX12VertexBufferLayout(size_t vertexSize, UInt32 binding = 0);
 
        explicit DirectX12VertexBufferLayout(size_t vertexSize, const Enumerable<BufferAttribute>& attributes, UInt32 binding = 0);
 
    private:
        DirectX12VertexBufferLayout(DirectX12VertexBufferLayout&&) noexcept = delete;
 
        DirectX12VertexBufferLayout(const DirectX12VertexBufferLayout&);
 
        DirectX12VertexBufferLayout& operator=(DirectX12VertexBufferLayout&&) noexcept = delete;
 
        DirectX12VertexBufferLayout& operator=(const DirectX12VertexBufferLayout&) = delete;
 
    public:
        ~DirectX12VertexBufferLayout() noexcept override;
 
    public:
        static inline auto create(size_t vertexSize, UInt32 binding = 0) {
            return SharedObject::create<DirectX12VertexBufferLayout>(vertexSize, binding);
        }
 
        static inline auto create(size_t vertexSize, const Enumerable<BufferAttribute>& attributes, UInt32 binding = 0) {
            return SharedObject::create<DirectX12VertexBufferLayout>(vertexSize, attributes, binding);
        }
 
        static inline auto create(const DirectX12VertexBufferLayout& other) {
            return SharedObject::create<DirectX12VertexBufferLayout>(other);
        }
 
        // IVertexBufferLayout interface.
    public:
        const Array<BufferAttribute>& attributes() const override;
 
        // IBufferLayout interface.
    public:
        size_t elementSize() const noexcept override;
 
        UInt32 binding() const noexcept override;
 
        BufferType type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12IndexBufferLayout final : public IIndexBufferLayout {
        LITEFX_IMPLEMENTATION(DirectX12IndexBufferLayoutImpl);
        friend struct SharedObject::Allocator<DirectX12IndexBufferLayout>;
 
    private:
        explicit DirectX12IndexBufferLayout(IndexType type);
 
    private:
        DirectX12IndexBufferLayout(DirectX12IndexBufferLayout&&) noexcept = delete;
 
        DirectX12IndexBufferLayout(const DirectX12IndexBufferLayout&);
 
        DirectX12IndexBufferLayout& operator=(DirectX12IndexBufferLayout&&) noexcept = delete;
 
        DirectX12IndexBufferLayout& operator=(const DirectX12IndexBufferLayout&) = delete;
 
    public:
        ~DirectX12IndexBufferLayout() noexcept override;
 
    public:
        static inline auto create(IndexType type) {
            return SharedObject::create<DirectX12IndexBufferLayout>(type);
        }
 
        static inline auto create(const DirectX12IndexBufferLayout& other) {
            return SharedObject::create<DirectX12IndexBufferLayout>(other);
        }
 
        // IIndexBufferLayout interface.
    public:
        IndexType indexType() const noexcept override;
 
        // IBufferLayout interface.
    public:
        size_t elementSize() const noexcept override;
 
        UInt32 binding() const noexcept override;
 
        BufferType type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12Buffer : public virtual IBuffer, public virtual IResource<ComPtr<ID3D12Resource>> {
    protected:
        IDirectX12Buffer() noexcept = default;
        IDirectX12Buffer(IDirectX12Buffer&&) noexcept = default;
        IDirectX12Buffer(const IDirectX12Buffer&) = delete;
        IDirectX12Buffer& operator=(IDirectX12Buffer&&) noexcept = default;
        IDirectX12Buffer& operator=(const IDirectX12Buffer&) = delete;
 
    public:
        ~IDirectX12Buffer() noexcept override = default;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12VertexBuffer : public virtual VertexBuffer<DirectX12VertexBufferLayout>, public virtual IDirectX12Buffer {
    protected:
        IDirectX12VertexBuffer() noexcept = default;
        IDirectX12VertexBuffer(IDirectX12VertexBuffer&&) noexcept = default;
        IDirectX12VertexBuffer(const IDirectX12VertexBuffer&) = delete;
        IDirectX12VertexBuffer& operator=(IDirectX12VertexBuffer&&) noexcept = default;
        IDirectX12VertexBuffer& operator=(const IDirectX12VertexBuffer&) = delete;
 
    public:
        ~IDirectX12VertexBuffer() noexcept override = default;
 
    public:
        virtual const D3D12_VERTEX_BUFFER_VIEW& view() const noexcept = 0;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12IndexBuffer : public virtual IndexBuffer<DirectX12IndexBufferLayout>, public virtual IDirectX12Buffer {
    protected:
        IDirectX12IndexBuffer() noexcept = default;
        IDirectX12IndexBuffer(IDirectX12IndexBuffer&&) noexcept = default;
        IDirectX12IndexBuffer(const IDirectX12IndexBuffer&) = delete;
        IDirectX12IndexBuffer& operator=(IDirectX12IndexBuffer&&) noexcept = default;
        IDirectX12IndexBuffer& operator=(const IDirectX12IndexBuffer&) = delete;
 
    public:
        ~IDirectX12IndexBuffer() noexcept override = 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>> {
    protected:
        IDirectX12Image() noexcept = default;
        IDirectX12Image(IDirectX12Image&&) noexcept = default;
        IDirectX12Image(const IDirectX12Image&) = delete;
        IDirectX12Image& operator=(IDirectX12Image&&) noexcept = default;
        IDirectX12Image& operator=(const IDirectX12Image&) = delete;
 
    public:
        ~IDirectX12Image() noexcept override = default;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12Sampler : public virtual ISampler {
    protected:
        IDirectX12Sampler() noexcept = default;
        IDirectX12Sampler(IDirectX12Sampler&&) noexcept = default;
        IDirectX12Sampler(const IDirectX12Sampler&) = delete;
        IDirectX12Sampler& operator=(IDirectX12Sampler&&) noexcept = default;
        IDirectX12Sampler& operator=(const IDirectX12Sampler&) = delete;
 
    public:
        ~IDirectX12Sampler() noexcept override = default;
    };
 
    class LITEFX_DIRECTX12_API IDirectX12AccelerationStructure : public virtual IAccelerationStructure {
    protected:
        IDirectX12AccelerationStructure() noexcept = default;
        IDirectX12AccelerationStructure(IDirectX12AccelerationStructure&&) noexcept = default;
        IDirectX12AccelerationStructure(const IDirectX12AccelerationStructure&) = delete;
        IDirectX12AccelerationStructure& operator=(IDirectX12AccelerationStructure&&) noexcept = default;
        IDirectX12AccelerationStructure& operator=(const IDirectX12AccelerationStructure&) = delete;
 
    public:
        ~IDirectX12AccelerationStructure() noexcept override = default;
    };
 
    class LITEFX_DIRECTX12_API DirectX12BottomLevelAccelerationStructure final : public IBottomLevelAccelerationStructure, public virtual StateResource, public virtual IDirectX12AccelerationStructure {
        LITEFX_IMPLEMENTATION(DirectX12BottomLevelAccelerationStructureImpl);
        friend class DirectX12Device;
        friend class DirectX12CommandBuffer;
 
        using IAccelerationStructure::build;
        using IAccelerationStructure::update;
        using IBottomLevelAccelerationStructure::copy;
 
    public:
        explicit DirectX12BottomLevelAccelerationStructure(AccelerationStructureFlags flags = AccelerationStructureFlags::None, StringView name = "");
        
        DirectX12BottomLevelAccelerationStructure(DirectX12BottomLevelAccelerationStructure&&) noexcept;
 
        DirectX12BottomLevelAccelerationStructure(const DirectX12BottomLevelAccelerationStructure&) = delete;
 
        DirectX12BottomLevelAccelerationStructure& operator=(DirectX12BottomLevelAccelerationStructure&&) noexcept;
 
        DirectX12BottomLevelAccelerationStructure& operator=(const DirectX12BottomLevelAccelerationStructure&) = delete;
 
        ~DirectX12BottomLevelAccelerationStructure() noexcept override;
 
        // IAccelerationStructure interface.
    public:
        AccelerationStructureFlags flags() const noexcept override;
 
        SharedPtr<const IDirectX12Buffer> buffer() const noexcept;
 
        void build(const DirectX12CommandBuffer& commandBuffer, const SharedPtr<const IDirectX12Buffer>& scratchBuffer = nullptr, const SharedPtr<const IDirectX12Buffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);
 
        void update(const DirectX12CommandBuffer& commandBuffer, const SharedPtr<const IDirectX12Buffer>& scratchBuffer = nullptr, const SharedPtr<const IDirectX12Buffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);
 
        void copy(const DirectX12CommandBuffer& commandBuffer, DirectX12BottomLevelAccelerationStructure& destination, bool compress = false, const SharedPtr<const IDirectX12Buffer>& buffer = nullptr, UInt64 offset = 0, bool copyBuildInfo = true) const;
 
        UInt64 offset() const noexcept override;
 
        UInt64 size() const noexcept override;
 
        // IBottomLevelAccelerationStructure interface.
    public:
        const Array<TriangleMesh>& triangleMeshes() const noexcept override;
 
        void addTriangleMesh(const TriangleMesh& mesh) override;
 
        const Array<BoundingBoxes>& boundingBoxes() const noexcept override;
 
        void addBoundingBox(const BoundingBoxes& aabb) override;
        
        void clear() noexcept override;
 
        bool remove(const TriangleMesh& mesh) noexcept override;
 
        bool remove(const BoundingBoxes& aabb) noexcept override;
 
    private:
        Array<D3D12_RAYTRACING_GEOMETRY_DESC> buildInfo() const;
 
    private:
        SharedPtr<const IBuffer> getBuffer() const noexcept override;
        void doBuild(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doUpdate(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doCopy(const ICommandBuffer& commandBuffer, IBottomLevelAccelerationStructure& destination, bool compress, const SharedPtr<const IBuffer>& buffer, UInt64 offset, bool copyBuildInfo) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12TopLevelAccelerationStructure final : public ITopLevelAccelerationStructure, public virtual StateResource, public virtual IDirectX12AccelerationStructure {
        LITEFX_IMPLEMENTATION(DirectX12TopLevelAccelerationStructureImpl);
        friend class DirectX12Device;
        friend class DirectX12CommandBuffer;
 
        using IAccelerationStructure::build;
        using IAccelerationStructure::update;
        using ITopLevelAccelerationStructure::copy;
 
    public:
        explicit DirectX12TopLevelAccelerationStructure(AccelerationStructureFlags flags = AccelerationStructureFlags::None, StringView name = "");
 
        DirectX12TopLevelAccelerationStructure(DirectX12TopLevelAccelerationStructure&&) noexcept;
 
        DirectX12TopLevelAccelerationStructure(const DirectX12TopLevelAccelerationStructure&) = delete;
 
        DirectX12TopLevelAccelerationStructure& operator=(DirectX12TopLevelAccelerationStructure&&) noexcept;
 
        DirectX12TopLevelAccelerationStructure& operator=(const DirectX12TopLevelAccelerationStructure&) = delete;
 
        ~DirectX12TopLevelAccelerationStructure() noexcept override;
 
        // IAccelerationStructure interface.
    public:
        AccelerationStructureFlags flags() const noexcept override;
 
        SharedPtr<const IDirectX12Buffer> buffer() const noexcept;
 
        void build(const DirectX12CommandBuffer& commandBuffer, const SharedPtr<const IDirectX12Buffer>& scratchBuffer = nullptr, const SharedPtr<const IDirectX12Buffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);
 
        void update(const DirectX12CommandBuffer& commandBuffer, const SharedPtr<const IDirectX12Buffer>& scratchBuffer = nullptr, const SharedPtr<const IDirectX12Buffer>& buffer = nullptr, UInt64 offset = 0, UInt64 maxSize = 0);
 
        void copy(const DirectX12CommandBuffer& commandBuffer, DirectX12TopLevelAccelerationStructure& destination, bool compress = false, const SharedPtr<const IDirectX12Buffer>& buffer = nullptr, UInt64 offset = 0, bool copyBuildInfo = true) const;
 
        UInt64 offset() const noexcept override;
 
        UInt64 size() const noexcept override;
 
        // ITopLevelAccelerationStructure interface.
    public:
        const Array<Instance>& instances() const noexcept override;
 
        void addInstance(const Instance& instance) override;
 
        void clear() noexcept override;
 
        bool remove(const Instance& instance) noexcept override;
 
    private:
        Array<D3D12_RAYTRACING_INSTANCE_DESC> buildInfo() const;
 
    private:
        SharedPtr<const IBuffer> getBuffer() const noexcept override;
        void doBuild(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doUpdate(const ICommandBuffer& commandBuffer, const SharedPtr<const IBuffer>& scratchBuffer, const SharedPtr<const IBuffer>& buffer, UInt64 offset, UInt64 maxSize) override;
        void doCopy(const ICommandBuffer& commandBuffer, ITopLevelAccelerationStructure& destination, bool compress, const SharedPtr<const IBuffer>& buffer, UInt64 offset, bool copyBuildInfo) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Barrier final : public Barrier<IDirectX12Buffer, IDirectX12Image> {
        LITEFX_IMPLEMENTATION(DirectX12BarrierImpl);
        LITEFX_BUILDER(DirectX12BarrierBuilder);
 
    public:
        using base_type = Barrier<IDirectX12Buffer, IDirectX12Image>;
        using base_type::transition;
 
    public:
        explicit DirectX12Barrier(PipelineStage syncBefore, PipelineStage syncAfter) noexcept;
 
        DirectX12Barrier(DirectX12Barrier&&) noexcept;
 
        DirectX12Barrier(const DirectX12Barrier&);
 
        DirectX12Barrier& operator=(DirectX12Barrier&&) noexcept;
 
        DirectX12Barrier& operator=(const DirectX12Barrier&);
 
        ~DirectX12Barrier() noexcept override;
 
    private:
        explicit DirectX12Barrier() noexcept;
        PipelineStage& syncBefore() noexcept;
        PipelineStage& syncAfter() noexcept;
 
        // Barrier interface.
    public:
        PipelineStage syncBefore() const noexcept override;
 
        PipelineStage syncAfter() const noexcept override;
 
        void wait(ResourceAccess accessBefore, ResourceAccess accessAfter) override;
 
        void transition(const IDirectX12Buffer& buffer, ResourceAccess accessBefore, ResourceAccess accessAfter) override;
 
        void transition(const IDirectX12Buffer& buffer, UInt32 element, ResourceAccess accessBefore, ResourceAccess accessAfter) override;
 
        void transition(const IDirectX12Image& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) override;
 
        void transition(const IDirectX12Image& image, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) override;
 
        void transition(const IDirectX12Image& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout layout) override;
 
        void transition(const IDirectX12Image& image, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane, ResourceAccess accessBefore, ResourceAccess accessAfter, ImageLayout fromLayout, ImageLayout toLayout) override;
 
    public:
        void execute(const DirectX12CommandBuffer& commandBuffer) const;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ShaderModule final : public IShaderModule, public ComResource<IDxcBlob> {
        LITEFX_IMPLEMENTATION(DirectX12ShaderModuleImpl);
 
    public:
        explicit DirectX12ShaderModule(const DirectX12Device& device, ShaderStage type, const String& fileName, const String& entryPoint = "main", const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt);
 
        explicit DirectX12ShaderModule(const DirectX12Device& device, ShaderStage type, std::istream& stream, const String& name, const String& entryPoint = "main", const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt);
 
        DirectX12ShaderModule(DirectX12ShaderModule&&) noexcept;
 
        DirectX12ShaderModule(const DirectX12ShaderModule&) = delete;
 
        DirectX12ShaderModule& operator=(DirectX12ShaderModule&&) noexcept;
 
        DirectX12ShaderModule& operator=(const DirectX12ShaderModule&) = delete;
 
        ~DirectX12ShaderModule() noexcept override;
 
        // IShaderModule interface.
    public:
        const String& fileName() const noexcept override;
 
        const String& entryPoint() const noexcept override;
 
        ShaderStage type() const noexcept override;
 
        const Optional<DescriptorBindingPoint>& shaderLocalDescriptor() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ShaderProgram final : public ShaderProgram<DirectX12ShaderModule> {
        LITEFX_IMPLEMENTATION(DirectX12ShaderProgramImpl);
        LITEFX_BUILDER(DirectX12ShaderProgramBuilder);
        friend struct SharedObject::Allocator<DirectX12ShaderProgram>;
 
    private:
        explicit DirectX12ShaderProgram(const DirectX12Device& device, Enumerable<UniquePtr<DirectX12ShaderModule>>&& modules);
 
        explicit DirectX12ShaderProgram(const DirectX12Device& device) noexcept;
 
    private:
        DirectX12ShaderProgram(DirectX12ShaderProgram&&) noexcept = delete;
 
        DirectX12ShaderProgram(const DirectX12ShaderProgram&) = delete;
 
        DirectX12ShaderProgram& operator=(DirectX12ShaderProgram&&) noexcept = delete;
 
        DirectX12ShaderProgram& operator=(const DirectX12ShaderProgram&) = delete;
 
    public:
        ~DirectX12ShaderProgram() noexcept override;
 
        // Factory method.
    public:
        static inline auto create(const DirectX12Device& device, Enumerable<UniquePtr<DirectX12ShaderModule>>&& modules) -> SharedPtr<DirectX12ShaderProgram> {
            return SharedObject::create<DirectX12ShaderProgram>(device, std::move(modules));
        }
 
    private:
        static inline auto create(const DirectX12Device& device) {
            return SharedObject::create<DirectX12ShaderProgram>(device);
        }
 
    public:
        const Array<UniquePtr<const DirectX12ShaderModule>>& modules() const noexcept override;
 
        virtual SharedPtr<DirectX12PipelineLayout> reflectPipelineLayout() const;
 
    private:
        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 final : public DescriptorSet<IDirectX12Buffer, IDirectX12Image, IDirectX12Sampler, IDirectX12AccelerationStructure> {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorSetImpl);
 
    public:
        using base_type = DescriptorSet<IDirectX12Buffer, IDirectX12Image, IDirectX12Sampler, IDirectX12AccelerationStructure>;
        using base_type::update;
 
    public:
        explicit DirectX12DescriptorSet(const DirectX12DescriptorSetLayout& layout, ComPtr<ID3D12DescriptorHeap>&& bufferHeap, ComPtr<ID3D12DescriptorHeap>&& samplerHeap);
 
        DirectX12DescriptorSet(DirectX12DescriptorSet&&) noexcept = delete;
        
        DirectX12DescriptorSet(const DirectX12DescriptorSet&) = delete;
        
        DirectX12DescriptorSet& operator=(DirectX12DescriptorSet&&) noexcept = delete;
        
        DirectX12DescriptorSet& operator=(const DirectX12DescriptorSet&) = delete;
        
        ~DirectX12DescriptorSet() noexcept override;
 
    public:
        virtual const DirectX12DescriptorSetLayout& layout() const noexcept;
 
    public:
        void update(UInt32 binding, const IDirectX12Buffer& buffer, UInt32 bufferElement = 0, UInt32 elements = 0, UInt32 firstDescriptor = 0) const override;
 
        void update(UInt32 binding, const IDirectX12Image& texture, UInt32 descriptor = 0, UInt32 firstLevel = 0, UInt32 levels = 0, UInt32 firstLayer = 0, UInt32 layers = 0) const override;
 
        void update(UInt32 binding, const IDirectX12Sampler& sampler, UInt32 descriptor = 0) const override;
 
        void update(UInt32 binding, const IDirectX12AccelerationStructure& accelerationStructure, UInt32 descriptor = 0) const override;
 
    public:
        virtual const ComPtr<ID3D12DescriptorHeap>& bufferHeap() const noexcept;
 
        virtual UInt32 bufferOffset() const noexcept;
 
        virtual const ComPtr<ID3D12DescriptorHeap>& samplerHeap() const noexcept;
 
        virtual UInt32 samplerOffset() const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12DescriptorLayout final : public IDescriptorLayout {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorLayoutImpl);
 
    public:
        DirectX12DescriptorLayout(DescriptorType type, UInt32 binding, size_t elementSize, UInt32 descriptors = 1, bool local = false);
 
        DirectX12DescriptorLayout(const IDirectX12Sampler& staticSampler, UInt32 binding, bool local = false);
        
        DirectX12DescriptorLayout(DirectX12DescriptorLayout&&) noexcept;
 
        DirectX12DescriptorLayout(const DirectX12DescriptorLayout&);
 
        DirectX12DescriptorLayout& operator=(DirectX12DescriptorLayout&&) noexcept;
 
        DirectX12DescriptorLayout& operator=(const DirectX12DescriptorLayout&);
 
        ~DirectX12DescriptorLayout() noexcept override;
 
        // DirectX 12 descriptor layout.
    public:
        bool local() const noexcept;
 
        // IDescriptorLayout interface.
    public:
        DescriptorType descriptorType() const noexcept override;
 
        UInt32 descriptors() const noexcept override;
 
        const IDirectX12Sampler* staticSampler() const noexcept override;
 
        // IBufferLayout interface.
    public:
        size_t elementSize() const noexcept override;
 
        UInt32 binding() const noexcept override;
 
        BufferType type() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12DescriptorSetLayout final : public DescriptorSetLayout<DirectX12DescriptorLayout, DirectX12DescriptorSet> {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorSetLayoutImpl);
        LITEFX_BUILDER(DirectX12DescriptorSetLayoutBuilder);
        friend class DirectX12PipelineLayout;
        friend struct SharedObject::Allocator<DirectX12DescriptorSetLayout>;
 
    public:
        using base_type = DescriptorSetLayout<DirectX12DescriptorLayout, DirectX12DescriptorSet>;
        using base_type::free;
        using base_type::allocate;
 
    private:
        explicit DirectX12DescriptorSetLayout(const DirectX12Device& device, const Enumerable<DirectX12DescriptorLayout>& descriptorLayouts, UInt32 space, ShaderStage stages);
 
        explicit DirectX12DescriptorSetLayout(const DirectX12Device& device);
 
    private:
        DirectX12DescriptorSetLayout(DirectX12DescriptorSetLayout&&) noexcept = delete;
 
        DirectX12DescriptorSetLayout(const DirectX12DescriptorSetLayout& other);
 
        DirectX12DescriptorSetLayout& operator=(DirectX12DescriptorSetLayout&&) noexcept = delete;
 
        DirectX12DescriptorSetLayout& operator=(const DirectX12DescriptorSetLayout&) = delete;
 
    public:
        ~DirectX12DescriptorSetLayout() noexcept override;
 
    public:
        static inline auto create(const DirectX12Device& device, const Enumerable<DirectX12DescriptorLayout>& descriptorLayouts, UInt32 space, ShaderStage stages) {
            return SharedObject::create<DirectX12DescriptorSetLayout>(device, descriptorLayouts, space, stages);
        }
 
        static inline auto create(const DirectX12DescriptorSetLayout& other) {
            return SharedObject::create<DirectX12DescriptorSetLayout>(other);
        }
 
    private:
        static inline auto create(const DirectX12Device& device) {
            return SharedObject::create<DirectX12DescriptorSetLayout>(device);
        }
 
    public:
        virtual UInt32 descriptorOffsetForBinding(UInt32 binding) const;
 
        virtual SharedPtr<const DirectX12Device> device() const noexcept;
 
    protected:
        virtual bool isRuntimeArray() const noexcept;
 
    public:
        const Array<DirectX12DescriptorLayout>& descriptors() const noexcept override;
 
        const DirectX12DescriptorLayout& descriptor(UInt32 binding) const override;
 
        UInt32 space() const noexcept override;
 
        ShaderStage shaderStages() const noexcept override;
 
        UInt32 uniforms() const noexcept override;
 
        UInt32 storages() const noexcept override;
 
        UInt32 images() const noexcept override;
 
        UInt32 buffers() const noexcept override;
 
        UInt32 samplers() const noexcept override;
 
        UInt32 staticSamplers() const noexcept override;
 
        UInt32 inputAttachments() const noexcept override;
 
    public:
        UniquePtr<DirectX12DescriptorSet> allocate(UInt32 descriptors, std::initializer_list<DescriptorBinding> bindings) const override;
 
        UniquePtr<DirectX12DescriptorSet> allocate(UInt32 descriptors, Span<DescriptorBinding> bindings) const override;
 
        UniquePtr<DirectX12DescriptorSet> allocate(UInt32 descriptors, Generator<DescriptorBinding> bindings) const override;
 
        Generator<UniquePtr<DirectX12DescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::initializer_list<std::initializer_list<DescriptorBinding>> bindings = { }) const override;
 
#ifdef __cpp_lib_mdspan
        Generator<UniquePtr<DirectX12DescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::mdspan<DescriptorBinding, std::dextents<size_t, 2>> bindings) const override;
#endif
 
        Generator<UniquePtr<DirectX12DescriptorSet>> allocate(UInt32 descriptorSets, UInt32 descriptors, std::function<Generator<DescriptorBinding>(UInt32)> bindingFactory) const override;
 
        void free(const DirectX12DescriptorSet& descriptorSet) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PushConstantsRange final : public IPushConstantsRange {
        LITEFX_IMPLEMENTATION(DirectX12PushConstantsRangeImpl);
        friend class DirectX12PipelineLayout;
 
    public:
        explicit DirectX12PushConstantsRange(ShaderStage shaderStages, UInt32 offset, UInt32 size, UInt32 space, UInt32 binding);
 
        DirectX12PushConstantsRange(DirectX12PushConstantsRange&&) noexcept;
 
        DirectX12PushConstantsRange(const DirectX12PushConstantsRange&);
 
        DirectX12PushConstantsRange& operator=(DirectX12PushConstantsRange&&) noexcept;
 
        DirectX12PushConstantsRange& operator=(const DirectX12PushConstantsRange&);
 
        ~DirectX12PushConstantsRange() noexcept override;
 
    public:
        UInt32 space() const noexcept override;
 
        UInt32 binding() const noexcept override;
 
        UInt32 offset() const noexcept override;
 
        UInt32 size() const noexcept override;
 
        ShaderStage stage() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PushConstantsLayout final : public PushConstantsLayout<DirectX12PushConstantsRange> {
        LITEFX_IMPLEMENTATION(DirectX12PushConstantsLayoutImpl);
        LITEFX_BUILDER(DirectX12PushConstantsLayoutBuilder);
        friend class DirectX12PipelineLayout;
 
    public:
        explicit DirectX12PushConstantsLayout(Enumerable<UniquePtr<DirectX12PushConstantsRange>>&& ranges, UInt32 size);
 
        DirectX12PushConstantsLayout(DirectX12PushConstantsLayout&&) noexcept;
 
        DirectX12PushConstantsLayout(const DirectX12PushConstantsLayout&) = delete;
 
        DirectX12PushConstantsLayout& operator=(DirectX12PushConstantsLayout&&) noexcept;
 
        DirectX12PushConstantsLayout& operator=(const DirectX12PushConstantsLayout&) = delete;
 
        ~DirectX12PushConstantsLayout() noexcept override;
 
    private:
        explicit DirectX12PushConstantsLayout(UInt32 size);
 
    public:
        UInt32 size() const noexcept override;
 
        const DirectX12PushConstantsRange& range(ShaderStage stage) const override;
 
        const Array<UniquePtr<DirectX12PushConstantsRange>>& ranges() const override;
 
    protected:
        Array<UniquePtr<DirectX12PushConstantsRange>>& ranges();
    };
 
    class LITEFX_DIRECTX12_API DirectX12PipelineLayout final : public PipelineLayout<DirectX12DescriptorSetLayout, DirectX12PushConstantsLayout>, public ComResource<ID3D12RootSignature> {
        LITEFX_IMPLEMENTATION(DirectX12PipelineLayoutImpl);
        LITEFX_BUILDER(DirectX12PipelineLayoutBuilder);
        friend struct SharedObject::Allocator<DirectX12PipelineLayout>;
 
    private:
        explicit DirectX12PipelineLayout(const DirectX12Device& device, const Enumerable<SharedPtr<DirectX12DescriptorSetLayout>>& descriptorSetLayouts, UniquePtr<DirectX12PushConstantsLayout>&& pushConstantsLayout);
 
        explicit DirectX12PipelineLayout(const DirectX12Device& device);
 
    private:
        DirectX12PipelineLayout(DirectX12PipelineLayout&&) noexcept = delete;
 
        DirectX12PipelineLayout(const DirectX12PipelineLayout&) = delete;
 
        DirectX12PipelineLayout& operator=(DirectX12PipelineLayout&&) noexcept = delete;
 
        DirectX12PipelineLayout& operator=(const DirectX12PipelineLayout&) = delete;
 
    public:
        ~DirectX12PipelineLayout() noexcept override;
 
    public:
        static inline auto create(const DirectX12Device& device, const Enumerable<SharedPtr<DirectX12DescriptorSetLayout>>& descriptorSetLayouts, UniquePtr<DirectX12PushConstantsLayout>&& pushConstantsLayout) {
            return SharedObject::create<DirectX12PipelineLayout>(device, descriptorSetLayouts, std::move(pushConstantsLayout));
        }
 
    private:
        static inline auto create(const DirectX12Device& device) {
            return SharedObject::create<DirectX12PipelineLayout>(device);
        }
 
        // PipelineLayout interface.
    public:
        const DirectX12Device& device() const noexcept /*override*/;
 
        const DirectX12DescriptorSetLayout& descriptorSet(UInt32 space) const override;
 
        const Array<SharedPtr<const DirectX12DescriptorSetLayout>>& descriptorSets() const override;
 
        const DirectX12PushConstantsLayout* pushConstants() const noexcept override;
 
    public:
        Optional<UInt32> rootParameterIndex(const DirectX12DescriptorSetLayout& layout) const noexcept;
 
        Optional<UInt32> rootParameterIndex(const DirectX12PushConstantsRange& range) const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12InputAssembler final : public InputAssembler<DirectX12VertexBufferLayout, DirectX12IndexBufferLayout> {
        LITEFX_IMPLEMENTATION(DirectX12InputAssemblerImpl);
        LITEFX_BUILDER(DirectX12InputAssemblerBuilder);
        friend struct SharedObject::Allocator<DirectX12InputAssembler>;
 
    private:
        explicit DirectX12InputAssembler(Enumerable<SharedPtr<DirectX12VertexBufferLayout>>&& vertexBufferLayouts, SharedPtr<DirectX12IndexBufferLayout>&& indexBufferLayout, PrimitiveTopology primitiveTopology = PrimitiveTopology::TriangleList);
 
        explicit DirectX12InputAssembler();
 
    private:
        DirectX12InputAssembler(DirectX12InputAssembler&&) noexcept;
 
        DirectX12InputAssembler(const DirectX12InputAssembler&);
 
        DirectX12InputAssembler& operator=(DirectX12InputAssembler&&) noexcept;
 
        DirectX12InputAssembler& operator=(const DirectX12InputAssembler&) = delete;
 
    public:
        ~DirectX12InputAssembler() noexcept override;
 
    public:
        static inline auto create(Enumerable<SharedPtr<DirectX12VertexBufferLayout>>&& vertexBufferLayouts, SharedPtr<DirectX12IndexBufferLayout>&& indexBufferLayout, PrimitiveTopology primitiveTopology = PrimitiveTopology::TriangleList) {
            return SharedObject::create<DirectX12InputAssembler>(std::move(vertexBufferLayouts), std::move(indexBufferLayout), primitiveTopology);
        }
 
        static inline auto create(const DirectX12InputAssembler& other) {
            return SharedObject::create<DirectX12InputAssembler>(other);
        }
 
    private:
        static inline auto create() {
            return SharedObject::create<DirectX12InputAssembler>();
        }
 
    public:
        Enumerable<const DirectX12VertexBufferLayout&> vertexBufferLayouts() const override;
 
        const DirectX12VertexBufferLayout& vertexBufferLayout(UInt32 binding) const override;
 
        const DirectX12IndexBufferLayout* indexBufferLayout() const noexcept override;
 
        PrimitiveTopology topology() const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Rasterizer final : public Rasterizer {
        LITEFX_BUILDER(DirectX12RasterizerBuilder);
        friend struct SharedObject::Allocator<DirectX12Rasterizer>;
 
    private:
        explicit DirectX12Rasterizer(PolygonMode polygonMode, CullMode cullMode, CullOrder cullOrder, Float lineWidth = 1.f, const DepthStencilState& depthStencilState = {}) noexcept;
        
        explicit DirectX12Rasterizer() noexcept;
 
    private:        
        DirectX12Rasterizer(DirectX12Rasterizer&&) noexcept = delete;
        
        DirectX12Rasterizer(const DirectX12Rasterizer&) = default;
 
        DirectX12Rasterizer& operator=(DirectX12Rasterizer&&) noexcept = delete;
 
        DirectX12Rasterizer& operator=(const DirectX12Rasterizer&) = delete;
 
    public:
        ~DirectX12Rasterizer() noexcept override = default;
 
    public:
        static inline auto create(PolygonMode polygonMode, CullMode cullMode, CullOrder cullOrder, Float lineWidth = 1.f, const DepthStencilState& depthStencilState = {}) {
            return SharedObject::create<DirectX12Rasterizer>(polygonMode, cullMode, cullOrder, lineWidth, depthStencilState);
        }
 
        static inline auto create(const DirectX12Rasterizer& other) {
            return SharedObject::create<DirectX12Rasterizer>(other);
        }
 
    private:
        static inline auto create() {
            return SharedObject::create<DirectX12Rasterizer>();
        }
    };
 
    class LITEFX_DIRECTX12_API DirectX12PipelineState : public virtual Pipeline<DirectX12PipelineLayout, DirectX12ShaderProgram>, public ComResource<ID3D12PipelineState> {
    protected:
        using ComResource<ID3D12PipelineState>::ComResource;
 
        DirectX12PipelineState(DirectX12PipelineState&&) noexcept = default;
        DirectX12PipelineState(const DirectX12PipelineState&) = delete;
        DirectX12PipelineState& operator=(DirectX12PipelineState&&) noexcept = default;
        DirectX12PipelineState& operator=(const DirectX12PipelineState&) = delete;
        
    public:
        ~DirectX12PipelineState() noexcept override = default;
 
    public:
        virtual void use(const DirectX12CommandBuffer& commandBuffer) const = 0;
    };
 
    class LITEFX_DIRECTX12_API DirectX12CommandBuffer final : public CommandBuffer<DirectX12CommandBuffer, IDirectX12Buffer, IDirectX12VertexBuffer, IDirectX12IndexBuffer, IDirectX12Image, DirectX12Barrier, DirectX12PipelineState, DirectX12BottomLevelAccelerationStructure, DirectX12TopLevelAccelerationStructure>, public ComResource<ID3D12GraphicsCommandList7> {
        LITEFX_IMPLEMENTATION(DirectX12CommandBufferImpl);
        friend struct SharedObject::Allocator<DirectX12CommandBuffer>;
 
    public:
        using base_type = CommandBuffer<DirectX12CommandBuffer, IDirectX12Buffer, IDirectX12VertexBuffer, IDirectX12IndexBuffer, IDirectX12Image, DirectX12Barrier, DirectX12PipelineState, DirectX12BottomLevelAccelerationStructure, DirectX12TopLevelAccelerationStructure>;
        using base_type::dispatch;
        using base_type::dispatchIndirect;
        using base_type::dispatchMesh;
        using base_type::draw;
        using base_type::drawIndirect;
        using base_type::drawIndexed;
        using base_type::drawIndexedIndirect;
        using base_type::barrier;
        using base_type::transfer;
        using base_type::bind;
        using base_type::use;
        using base_type::pushConstants;
        using base_type::buildAccelerationStructure;
        using base_type::updateAccelerationStructure;
        using base_type::copyAccelerationStructure;
 
    private:
        explicit DirectX12CommandBuffer(const DirectX12Queue& queue, bool begin = false, bool primary = true);
 
    private:
        DirectX12CommandBuffer(DirectX12CommandBuffer&&) noexcept = delete;
 
        DirectX12CommandBuffer(const DirectX12CommandBuffer&) = delete;
 
        DirectX12CommandBuffer& operator=(DirectX12CommandBuffer&&) noexcept = delete;
 
        DirectX12CommandBuffer& operator=(const DirectX12CommandBuffer&) = delete;
 
    public:
        ~DirectX12CommandBuffer() noexcept override;
 
    public:
        static inline SharedPtr<DirectX12CommandBuffer> create(const DirectX12Queue& queue, bool begin = false, bool primary = true) {
            return SharedObject::create<DirectX12CommandBuffer>(queue, begin, primary);
        }
 
        // CommandBuffer interface.
    public:
        SharedPtr<const DirectX12Queue> queue() const noexcept;
 
        void begin() const override;
 
        void end() const override;
 
        void track(SharedPtr<const IBuffer> buffer) const override;
 
        void track(SharedPtr<const IImage> image) const override;
 
        void track(SharedPtr<const ISampler> sampler) const override;
 
        bool isSecondary() const noexcept override;
 
        void setViewports(Span<const IViewport*> viewports) const override;
 
        void setViewports(const IViewport* viewport) const override;
 
        void setScissors(Span<const IScissor*> scissors) const override;
 
        void setScissors(const IScissor* scissor) const override;
 
        void setBlendFactors(const Vector4f& blendFactors) const noexcept override;
 
        void setStencilRef(UInt32 stencilRef) const noexcept override;
 
        UInt64 submit() const override;
 
        [[nodiscard]] UniquePtr<DirectX12Barrier> makeBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const override;
 
        void barrier(const DirectX12Barrier& barrier) const noexcept override;
 
        void transfer(const IDirectX12Buffer& source, const IDirectX12Buffer& target, UInt32 sourceElement = 0, UInt32 targetElement = 0, UInt32 elements = 1) const override;
 
        void transfer(const void* const data, size_t size, const IDirectX12Buffer& target, UInt32 targetElement = 0, UInt32 elements = 1) const override;
 
        void transfer(Span<const void* const> data, size_t elementSize, const IDirectX12Buffer& target, UInt32 firstElement = 0) const override;
 
        void transfer(const IDirectX12Buffer& source, const IDirectX12Image& target, UInt32 sourceElement = 0, UInt32 firstSubresource = 0, UInt32 elements = 1) const override;
 
        void transfer(const void* const data, size_t size, const IDirectX12Image& target, UInt32 subresource = 0) const override;
 
        void transfer(Span<const void* const> data, size_t elementSize, const IDirectX12Image& target, UInt32 firstSubresource = 0, UInt32 subresources = 1) const override;
 
        void transfer(const IDirectX12Image& source, const IDirectX12Image& target, UInt32 sourceSubresource = 0, UInt32 targetSubresource = 0, UInt32 subresources = 1) const override;
 
        void transfer(const IDirectX12Image& source, const IDirectX12Buffer& target, UInt32 firstSubresource = 0, UInt32 targetElement = 0, UInt32 subresources = 1) const override;
 
        void transfer(const SharedPtr<const IDirectX12Buffer>& source, const IDirectX12Buffer& target, UInt32 sourceElement = 0, UInt32 targetElement = 0, UInt32 elements = 1) const override;
 
        void transfer(const SharedPtr<const IDirectX12Buffer>& source, const IDirectX12Image& target, UInt32 sourceElement = 0, UInt32 firstSubresource = 0, UInt32 elements = 1) const override;
 
        void transfer(const SharedPtr<const IDirectX12Image>& source, const IDirectX12Image& target, UInt32 sourceSubresource = 0, UInt32 targetSubresource = 0, UInt32 subresources = 1) const override;
 
        void transfer(const SharedPtr<const IDirectX12Image>& source, const IDirectX12Buffer& target, UInt32 firstSubresource = 0, UInt32 targetElement = 0, UInt32 subresources = 1) const override;
 
        void use(const DirectX12PipelineState& pipeline) const noexcept override;
 
        void bind(const DirectX12DescriptorSet& descriptorSet) const override;
 
        void bind(Span<const DirectX12DescriptorSet*> descriptorSets) const override;
 
        void bind(const DirectX12DescriptorSet& descriptorSet, const DirectX12PipelineState& pipeline) const override;
 
        void bind(Span<const DirectX12DescriptorSet*> descriptorSets, const DirectX12PipelineState& pipeline) const override;
 
        void bind(const IDirectX12VertexBuffer& buffer) const noexcept override;
 
        void bind(const IDirectX12IndexBuffer& buffer) const noexcept override;
 
        void dispatch(const Vector3u& threadCount) const noexcept override;
 
        void dispatchIndirect(const IDirectX12Buffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;
 
        void dispatchIndirect(const IDirectX12Buffer& batchBuffer, const IDirectX12Buffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept;
 
        void dispatchMesh(const Vector3u& threadCount) const noexcept override;
 
        void dispatchMeshIndirect(const IDirectX12Buffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;
 
        void dispatchMeshIndirect(const IDirectX12Buffer& batchBuffer, const IDirectX12Buffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept override;
 
        void draw(UInt32 vertices, UInt32 instances = 1, UInt32 firstVertex = 0, UInt32 firstInstance = 0) const noexcept override;
 
        void drawIndirect(const IDirectX12Buffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;
 
        void drawIndirect(const IDirectX12Buffer& batchBuffer, const IDirectX12Buffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept override;
 
        void drawIndexed(UInt32 indices, UInt32 instances = 1, UInt32 firstIndex = 0, Int32 vertexOffset = 0, UInt32 firstInstance = 0) const noexcept override;
 
        void drawIndexedIndirect(const IDirectX12Buffer& batchBuffer, UInt32 batchCount, UInt64 offset = 0) const noexcept override;
 
        void drawIndexedIndirect(const IDirectX12Buffer& batchBuffer, const IDirectX12Buffer& countBuffer, UInt64 offset = 0, UInt64 countOffset = 0, UInt32 maxBatches = std::numeric_limits<UInt32>::max()) const noexcept override;
        
        void pushConstants(const DirectX12PushConstantsLayout& layout, const void* const memory) const override;
 
        void writeTimingEvent(const SharedPtr<const TimingEvent>& timingEvent) const override;
 
        void execute(const SharedPtr<const DirectX12CommandBuffer>& commandBuffer) const override;
 
        void execute(Enumerable<SharedPtr<const DirectX12CommandBuffer>> commandBuffers) const override;
 
        void buildAccelerationStructure(DirectX12BottomLevelAccelerationStructure& blas, const SharedPtr<const IDirectX12Buffer>& scratchBuffer, const IDirectX12Buffer& buffer, UInt64 offset = 0) const override;
 
        void buildAccelerationStructure(DirectX12TopLevelAccelerationStructure& tlas, const SharedPtr<const IDirectX12Buffer>& scratchBuffer, const IDirectX12Buffer& buffer, UInt64 offset = 0) const override;
 
        void updateAccelerationStructure(DirectX12BottomLevelAccelerationStructure& blas, const SharedPtr<const IDirectX12Buffer>& scratchBuffer, const IDirectX12Buffer& buffer, UInt64 offset = 0) const override;
 
        void updateAccelerationStructure(DirectX12TopLevelAccelerationStructure& tlas, const SharedPtr<const IDirectX12Buffer>& scratchBuffer, const IDirectX12Buffer& buffer, UInt64 offset = 0) const override;
 
        void copyAccelerationStructure(const DirectX12BottomLevelAccelerationStructure& from, const DirectX12BottomLevelAccelerationStructure& to, bool compress = false) const noexcept override;
 
        void copyAccelerationStructure(const DirectX12TopLevelAccelerationStructure& from, const DirectX12TopLevelAccelerationStructure& to, bool compress = false) const noexcept override;
 
        void traceRays(UInt32 width, UInt32 height, UInt32 depth, const ShaderBindingTableOffsets& offsets, const IDirectX12Buffer& rayGenerationShaderBindingTable, const IDirectX12Buffer* missShaderBindingTable, const IDirectX12Buffer* hitShaderBindingTable, const IDirectX12Buffer* callableShaderBindingTable) const noexcept override;
 
    private:
        inline SharedPtr<const ICommandQueue> getQueue() const noexcept override {
            return std::static_pointer_cast<const ICommandQueue>(this->queue());
        }
 
        void releaseSharedState() const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Queue final : public CommandQueue<DirectX12CommandBuffer>, public ComResource<ID3D12CommandQueue> {
        LITEFX_IMPLEMENTATION(DirectX12QueueImpl);
        friend struct SharedObject::Allocator<DirectX12Queue>;
 
    public:
        using base_type = CommandQueue<DirectX12CommandBuffer>;
        using base_type::submit;
 
    private:
        explicit DirectX12Queue(const DirectX12Device& device, QueueType type, QueuePriority priority);
 
    private:
        DirectX12Queue(DirectX12Queue&&) noexcept = delete;
 
        DirectX12Queue(const DirectX12Queue&) = delete;
 
        DirectX12Queue& operator=(DirectX12Queue&&) noexcept = delete;
 
        DirectX12Queue& operator=(const DirectX12Queue&) = delete;
 
    public:
        ~DirectX12Queue() noexcept override;
 
    public:
        static inline SharedPtr<DirectX12Queue> create(const DirectX12Device& device, QueueType type, QueuePriority priority) {
            return SharedObject::create<DirectX12Queue>(device, type, priority);
        }
 
        // DirectX12Queue interface.
    public:
        virtual SharedPtr<const DirectX12Device> device() const noexcept;
 
        // CommandQueue interface.
    public:
        QueuePriority priority() const noexcept override;
 
        QueueType type() const noexcept override;
 
#if defined(LITEFX_BUILD_SUPPORT_DEBUG_MARKERS) && defined(LITEFX_BUILD_WITH_PIX_RUNTIME)
    public:
        void beginDebugRegion(const String& label, const Vectors::ByteVector3& color = DEFAULT_DEBUG_COLOR) const noexcept override;
 
        void endDebugRegion() const noexcept override;
 
        void setDebugMarker(const String& label, const Vectors::ByteVector3& color = DEFAULT_DEBUG_COLOR) const noexcept override;
#endif // defined(LITEFX_BUILD_SUPPORT_DEBUG_MARKERS) && defined(LITEFX_BUILD_WITH_PIX_RUNTIME)
 
    public:
        SharedPtr<DirectX12CommandBuffer> createCommandBuffer(bool beginRecording = false, bool secondary = false) const override;
 
        UInt64 submit(const SharedPtr<const DirectX12CommandBuffer>& commandBuffer) const override;
 
        UInt64 submit(Enumerable<SharedPtr<const DirectX12CommandBuffer>> commandBuffers) const override;
 
        void waitFor(UInt64 fence) const override;
 
        void waitFor(const DirectX12Queue& queue, UInt64 fence) const noexcept;
 
        UInt64 currentFence() const noexcept override;
 
    private:
        inline void waitForQueue(const ICommandQueue& queue, UInt64 fence) const override {
            auto d3dQueue = dynamic_cast<const DirectX12Queue*>(&queue);
 
            if (d3dQueue == nullptr) [[unlikely]]
                throw InvalidArgumentException("queue", "Cannot wait for queues from other backends.");
 
            this->waitFor(*d3dQueue, fence);
        }
    };
 
    class LITEFX_DIRECTX12_API DirectX12RenderPipeline final : public virtual DirectX12PipelineState, public RenderPipeline<DirectX12PipelineLayout, DirectX12ShaderProgram, DirectX12InputAssembler, DirectX12Rasterizer> {
        LITEFX_IMPLEMENTATION(DirectX12RenderPipelineImpl);
        LITEFX_BUILDER(DirectX12RenderPipelineBuilder);
 
    public:
        explicit DirectX12RenderPipeline(const DirectX12RenderPass& renderPass, const SharedPtr<DirectX12PipelineLayout>& layout, const SharedPtr<DirectX12ShaderProgram>& shaderProgram, const SharedPtr<DirectX12InputAssembler>& inputAssembler, const SharedPtr<DirectX12Rasterizer>& rasterizer, MultiSamplingLevel samples = MultiSamplingLevel::x1, bool enableAlphaToCoverage = false, const String& name = "");
 
        DirectX12RenderPipeline(DirectX12RenderPipeline&&) noexcept = delete;
        
        DirectX12RenderPipeline(const DirectX12RenderPipeline&) = delete;
 
        DirectX12RenderPipeline& operator=(DirectX12RenderPipeline&&) noexcept = delete;
 
        DirectX12RenderPipeline& operator=(const DirectX12RenderPipeline&) = delete;
 
        ~DirectX12RenderPipeline() noexcept override;
 
    private:
        DirectX12RenderPipeline(const DirectX12RenderPass& renderPass, const String& name = "");
 
        // Pipeline interface.
    public:
        SharedPtr<const DirectX12ShaderProgram> program() const noexcept override;
 
        SharedPtr<const DirectX12PipelineLayout> layout() const noexcept override;
 
        // RenderPipeline interface.
    public:
        SharedPtr<DirectX12InputAssembler> inputAssembler() const noexcept override;
 
        SharedPtr<DirectX12Rasterizer> rasterizer() const noexcept override;
 
        bool alphaToCoverage() const noexcept override;
 
        MultiSamplingLevel samples() const noexcept override;
 
        void updateSamples(MultiSamplingLevel samples) override;
 
        // DirectX12PipelineState interface.
    public:
        void use(const DirectX12CommandBuffer& commandBuffer) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ComputePipeline final : public virtual DirectX12PipelineState, public ComputePipeline<DirectX12PipelineLayout, DirectX12ShaderProgram> {
        LITEFX_IMPLEMENTATION(DirectX12ComputePipelineImpl);
        LITEFX_BUILDER(DirectX12ComputePipelineBuilder);
 
    public:
        explicit DirectX12ComputePipeline(const DirectX12Device& device, const SharedPtr<DirectX12PipelineLayout>& layout, const SharedPtr<DirectX12ShaderProgram>& shaderProgram, const String& name = "");
 
        DirectX12ComputePipeline(DirectX12ComputePipeline&&) noexcept;
 
        DirectX12ComputePipeline(const DirectX12ComputePipeline&) = delete;
 
        DirectX12ComputePipeline& operator=(DirectX12ComputePipeline&&) noexcept;
 
        DirectX12ComputePipeline& operator=(const DirectX12ComputePipeline&) = delete;
 
        ~DirectX12ComputePipeline() noexcept override;
 
    private:
        DirectX12ComputePipeline(const DirectX12Device& device) noexcept;
 
        // Pipeline interface.
    public:
        SharedPtr<const DirectX12ShaderProgram> program() const noexcept override;
 
        SharedPtr<const DirectX12PipelineLayout> layout() const noexcept override;
 
        // DirectX12PipelineState interface.
    public:
        void use(const DirectX12CommandBuffer& commandBuffer) const noexcept override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RayTracingPipeline final : public virtual DirectX12PipelineState, public RayTracingPipeline<DirectX12PipelineLayout, DirectX12ShaderProgram> {
        LITEFX_IMPLEMENTATION(DirectX12RayTracingPipelineImpl);
        LITEFX_BUILDER(DirectX12RayTracingPipelineBuilder);
 
    public:
        explicit DirectX12RayTracingPipeline(const DirectX12Device& device, const SharedPtr<DirectX12PipelineLayout>& layout, const SharedPtr<DirectX12ShaderProgram>& shaderProgram, ShaderRecordCollection&& shaderRecords, UInt32 maxRecursionDepth = 10, UInt32 maxPayloadSize = 0, UInt32 maxAttributeSize = 32, const String& name = ""); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
        DirectX12RayTracingPipeline(DirectX12RayTracingPipeline&&) noexcept;
 
        DirectX12RayTracingPipeline(const DirectX12RayTracingPipeline&) = delete;
 
        DirectX12RayTracingPipeline& operator=(DirectX12RayTracingPipeline&&) noexcept;
 
        DirectX12RayTracingPipeline& operator=(const DirectX12RayTracingPipeline&) = delete;
 
        ~DirectX12RayTracingPipeline() noexcept override;
 
    private:
        DirectX12RayTracingPipeline(const DirectX12Device& device, ShaderRecordCollection&& shaderRecords) noexcept;
 
        // Pipeline interface.
    public:
        SharedPtr<const DirectX12ShaderProgram> program() const noexcept override;
 
        SharedPtr<const DirectX12PipelineLayout> layout() const noexcept override;
 
        // RayTracingPipeline interface.
    public:
        const ShaderRecordCollection& shaderRecords() const noexcept override;
 
        UInt32 maxRecursionDepth() const noexcept override;
 
        UInt32 maxPayloadSize() const noexcept override;
 
        UInt32 maxAttributeSize() const noexcept override;
 
        SharedPtr<IDirectX12Buffer> allocateShaderBindingTable(ShaderBindingTableOffsets& offsets, ShaderBindingGroup groups = ShaderBindingGroup::All) const override;
 
        // DirectX12PipelineState interface.
    public:
        void use(const DirectX12CommandBuffer& commandBuffer) const noexcept override;
 
        ComPtr<ID3D12StateObject> stateObject() const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12FrameBuffer final : public FrameBuffer<IDirectX12Image> {
        LITEFX_IMPLEMENTATION(DirectX12FrameBufferImpl);
        friend struct SharedObject::Allocator<DirectX12FrameBuffer>;
 
    public:
        using FrameBuffer::addImage;
        using FrameBuffer::mapRenderTarget;
        using FrameBuffer::mapRenderTargets;
 
    private:
        DirectX12FrameBuffer(const DirectX12Device& device, const Size2d& renderArea, StringView name = "");
 
    private:
        DirectX12FrameBuffer(DirectX12FrameBuffer&&) noexcept = delete;
 
        DirectX12FrameBuffer(const DirectX12FrameBuffer&) = delete;
 
        DirectX12FrameBuffer& operator=(DirectX12FrameBuffer&&) noexcept = delete;
 
        DirectX12FrameBuffer& operator=(const DirectX12FrameBuffer&) = delete;
 
    public:
        ~DirectX12FrameBuffer() noexcept override;
 
    public:
        static inline SharedPtr<DirectX12FrameBuffer> create(const DirectX12Device& device, const Size2d& renderArea, StringView name = "") {
            return SharedObject::create<DirectX12FrameBuffer>(device, renderArea, name);
        }
 
        // DirectX 12 FrameBuffer
    public:
        D3D12_CPU_DESCRIPTOR_HANDLE descriptorHandle(UInt32 imageIndex) const;
 
        D3D12_CPU_DESCRIPTOR_HANDLE descriptorHandle(StringView imageName) const;
        
        D3D12_CPU_DESCRIPTOR_HANDLE descriptorHandle(const RenderTarget& renderTarget) const;
 
        // FrameBuffer interface.
    public:
        const Size2d& size() const noexcept override;
 
        size_t getWidth() const noexcept override;
 
        size_t getHeight() const noexcept override;
 
        void mapRenderTarget(const RenderTarget& renderTarget, UInt32 index) override;
 
        void mapRenderTarget(const RenderTarget& renderTarget, StringView name) override;
 
        void unmapRenderTarget(const RenderTarget& renderTarget) noexcept override;
 
        const Array<SharedPtr<const IDirectX12Image>>& images() const override;
 
        inline const IDirectX12Image& operator[](UInt32 index) const override {
            return this->image(index);
        }
 
        const IDirectX12Image& image(UInt32 index) const override;
 
        inline const IDirectX12Image& operator[](const RenderTarget& renderTarget) const override {
            return this->image(renderTarget);
        }
 
        const IDirectX12Image& image(const RenderTarget& renderTarget) const override;
 
        inline const IDirectX12Image& operator[](StringView renderTargetName) const override {
            return this->resolveImage(hash(renderTargetName));
        }
        
        inline const IDirectX12Image& image(StringView renderTargetName) const override {
            return this->resolveImage(hash(renderTargetName));
        }
        
        const IDirectX12Image& resolveImage(UInt64 hash) const override;
 
        void addImage(const String& name, Format format, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) override;
 
        void addImage(const String& name, const RenderTarget& renderTarget, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::FrameBufferImage) override;
 
        void resize(const Size2d& renderArea) override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RenderPass final : public RenderPass<DirectX12Queue, DirectX12FrameBuffer> {
        LITEFX_IMPLEMENTATION(DirectX12RenderPassImpl);
        LITEFX_BUILDER(DirectX12RenderPassBuilder);
        friend struct SharedObject::Allocator<DirectX12RenderPass>;
 
    public:
        using base_type = RenderPass<DirectX12Queue, DirectX12FrameBuffer>;
 
    private:
        explicit DirectX12RenderPass(const DirectX12Device& device, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u);
 
        explicit DirectX12RenderPass(const DirectX12Device& device, const String& name, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u);
        
        explicit DirectX12RenderPass(const DirectX12Device& device, const DirectX12Queue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u);
 
        explicit DirectX12RenderPass(const DirectX12Device& device, const String& name, const DirectX12Queue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u);
 
    private:
        DirectX12RenderPass(DirectX12RenderPass&&) noexcept = delete;
 
        DirectX12RenderPass(const DirectX12RenderPass&) = delete;
 
        DirectX12RenderPass& operator=(DirectX12RenderPass&&) noexcept = delete;
 
        DirectX12RenderPass& operator=(const DirectX12RenderPass&) = delete;
 
    public:
        ~DirectX12RenderPass() noexcept override;
 
    public:
        static inline SharedPtr<DirectX12RenderPass> create(const DirectX12Device& device, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u) {
            return SharedObject::create<DirectX12RenderPass>(device, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers);
        }
 
        static inline SharedPtr<DirectX12RenderPass> create(const DirectX12Device& device, const String& name, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u) {
            return SharedObject::create<DirectX12RenderPass>(device, name, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers);
        }
 
        static inline SharedPtr<DirectX12RenderPass> create(const DirectX12Device& device, const DirectX12Queue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u) {
            return SharedObject::create<DirectX12RenderPass>(device, queue, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers);
        }
 
        static inline SharedPtr<DirectX12RenderPass> create(const DirectX12Device& device, const String& name, const DirectX12Queue& queue, Span<RenderTarget> renderTargets, Span<RenderPassDependency> inputAttachments = { }, Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding = std::nullopt, UInt32 secondaryCommandBuffers = 1u) {
            return SharedObject::create<DirectX12RenderPass>(device, name, queue, renderTargets, inputAttachments, inputAttachmentSamplerBinding, secondaryCommandBuffers);
        }
 
    private:
        explicit DirectX12RenderPass(const DirectX12Device& device, const String& name = "");
 
        static inline SharedPtr<DirectX12RenderPass> create(const DirectX12Device& device, const String& name = "") {
            return SharedObject::create<DirectX12RenderPass>(device, name);
        }
 
        // RenderPass interface.
    public:
        const DirectX12Device& device() const noexcept /*override*/;
 
        SharedPtr<const DirectX12FrameBuffer> activeFrameBuffer() const noexcept override;
 
        const DirectX12Queue& commandQueue() const noexcept override;
 
        Enumerable<SharedPtr<const DirectX12CommandBuffer>> commandBuffers() const override;
 
        SharedPtr<const DirectX12CommandBuffer> commandBuffer(UInt32 index) const override;
 
        UInt32 secondaryCommandBuffers() const noexcept override;
 
        const Array<RenderTarget>& renderTargets() const noexcept override;
 
        const RenderTarget& renderTarget(UInt32 location) const override;
 
        bool hasPresentTarget() const noexcept override;
 
        const Array<RenderPassDependency>& inputAttachments() const noexcept override;
 
        const RenderPassDependency& inputAttachment(UInt32 location) const override;
 
        const Optional<DescriptorBindingPoint>& inputAttachmentSamplerBinding() const noexcept override;
 
        void begin(const DirectX12FrameBuffer& frameBuffer) const override;
 
        UInt64 end() const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12SwapChain final : public SwapChain<IDirectX12Image>, public ComResource<IDXGISwapChain4> {
        LITEFX_IMPLEMENTATION(DirectX12SwapChainImpl);
        friend class DirectX12RenderPass;
        friend class DirectX12Image;
        friend class DirectX12Device;
 
    public:
        using base_type = SwapChain<IDirectX12Image>;
 
    private:
        explicit DirectX12SwapChain(const DirectX12Device& device, const DirectX12Backend& backend, Format surfaceFormat = Format::B8G8R8A8_SRGB, const Size2d& renderArea = { 800, 600 }, UInt32 buffers = 3, bool enableVsync = false); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
    public:
        DirectX12SwapChain(DirectX12SwapChain&&) noexcept = delete;
 
        DirectX12SwapChain(const DirectX12SwapChain&) = delete;
 
        DirectX12SwapChain& operator=(DirectX12SwapChain&&) noexcept = delete;
 
        DirectX12SwapChain& operator=(const DirectX12SwapChain&) = delete;
 
        ~DirectX12SwapChain() noexcept override;
 
        // DirectX 12 swap chain.
    public:
        virtual bool supportsVariableRefreshRate() const noexcept;
 
        virtual ID3D12QueryHeap* timestampQueryHeap() const noexcept;
 
        // SwapChain interface.
    public:
        const Array<SharedPtr<const TimingEvent>>& timingEvents() const override;
 
        SharedPtr<const TimingEvent> timingEvent(UInt32 queryId) const override;
 
        UInt64 readTimingEvent(SharedPtr<const TimingEvent> timingEvent) const override;
 
        UInt32 resolveQueryId(SharedPtr<const TimingEvent> timingEvent) const override;
 
        const IGraphicsDevice& device() const override;
 
        Format surfaceFormat() const noexcept override;
 
        UInt32 buffers() const noexcept override;
 
        const Size2d& renderArea() const noexcept override;
 
        bool verticalSynchronization() const noexcept override;
 
        IDirectX12Image* image(UInt32 backBuffer) const override;
 
        const IDirectX12Image& image() const noexcept override;
 
        const Array<SharedPtr<IDirectX12Image>>& images() const noexcept override;
 
        void present(UInt64 fence) const override;
 
    public:
        Enumerable<Format> getSurfaceFormats() const override;
 
        void addTimingEvent(SharedPtr<const TimingEvent> timingEvent) override;
 
        void reset(Format surfaceFormat, const Size2d& renderArea, UInt32 buffers, bool enableVsync = false) override;
 
        [[nodiscard]] UInt32 swapBackBuffer() const override;
 
    private:
        void resolveQueryHeaps(const DirectX12CommandBuffer& commandBuffer) const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12GraphicsFactory final : public GraphicsFactory<DirectX12DescriptorLayout, IDirectX12Buffer, IDirectX12VertexBuffer, IDirectX12IndexBuffer, IDirectX12Image, IDirectX12Sampler, DirectX12BottomLevelAccelerationStructure, DirectX12TopLevelAccelerationStructure> {
        LITEFX_IMPLEMENTATION(DirectX12GraphicsFactoryImpl);
        friend class DirectX12Device;
        friend struct SharedObject::Allocator<DirectX12GraphicsFactory>;
 
    public:
        using base_type = GraphicsFactory<DirectX12DescriptorLayout, IDirectX12Buffer, IDirectX12VertexBuffer, IDirectX12IndexBuffer, IDirectX12Image, IDirectX12Sampler, DirectX12BottomLevelAccelerationStructure, DirectX12TopLevelAccelerationStructure>;
        using base_type::createBuffer;
        using base_type::createVertexBuffer;
        using base_type::createIndexBuffer;
        using base_type::createTexture;
        using base_type::createTextures;
        using base_type::createSampler;
        using base_type::createSamplers;
 
    private:
        explicit DirectX12GraphicsFactory(const DirectX12Device& device);
 
    private:
        DirectX12GraphicsFactory(DirectX12GraphicsFactory&&) noexcept = delete;
        
        DirectX12GraphicsFactory(const DirectX12GraphicsFactory&) = delete;
 
        DirectX12GraphicsFactory& operator=(DirectX12GraphicsFactory&&) noexcept = delete;
 
        DirectX12GraphicsFactory& operator=(const DirectX12GraphicsFactory&) = delete;
 
    public:
        ~DirectX12GraphicsFactory() noexcept override;
 
    private:
        static inline SharedPtr<DirectX12GraphicsFactory> create(const DirectX12Device& device) {
            return SharedObject::create<DirectX12GraphicsFactory>(device);
        }
 
    public:
        SharedPtr<IDirectX12Buffer> createBuffer(BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12Buffer> createBuffer(const String& name, BufferType type, ResourceHeap heap, size_t elementSize, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12VertexBuffer> createVertexBuffer(const DirectX12VertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12VertexBuffer> createVertexBuffer(const String& name, const DirectX12VertexBufferLayout& layout, ResourceHeap heap, UInt32 elements = 1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12IndexBuffer> createIndexBuffer(const DirectX12IndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12IndexBuffer> createIndexBuffer(const String& name, const DirectX12IndexBufferLayout& layout, ResourceHeap heap, UInt32 elements, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12Image> createTexture(Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12Image> createTexture(const String& name, Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        Generator<SharedPtr<IDirectX12Image>> createTextures(Format format, const Size3d& size, ImageDimensions dimension = ImageDimensions::DIM_2, UInt32 levels = 1, UInt32 layers = 1, MultiSamplingLevel samples = MultiSamplingLevel::x1, ResourceUsage usage = ResourceUsage::Default) const override;
 
        SharedPtr<IDirectX12Sampler> createSampler(FilterMode magFilter = FilterMode::Nearest, FilterMode minFilter = FilterMode::Nearest, BorderMode borderU = BorderMode::Repeat, BorderMode borderV = BorderMode::Repeat, BorderMode borderW = BorderMode::Repeat, MipMapMode mipMapMode = MipMapMode::Nearest, Float mipMapBias = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float minLod = 0.f, Float anisotropy = 0.f) const override;
 
        SharedPtr<IDirectX12Sampler> createSampler(const String& name, FilterMode magFilter = FilterMode::Nearest, FilterMode minFilter = FilterMode::Nearest, BorderMode borderU = BorderMode::Repeat, BorderMode borderV = BorderMode::Repeat, BorderMode borderW = BorderMode::Repeat, MipMapMode mipMapMode = MipMapMode::Nearest, Float mipMapBias = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float minLod = 0.f, Float anisotropy = 0.f) const override;
 
        Generator<SharedPtr<IDirectX12Sampler>> createSamplers(FilterMode magFilter = FilterMode::Nearest, FilterMode minFilter = FilterMode::Nearest, BorderMode borderU = BorderMode::Repeat, BorderMode borderV = BorderMode::Repeat, BorderMode borderW = BorderMode::Repeat, MipMapMode mipMapMode = MipMapMode::Nearest, Float mipMapBias = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float minLod = 0.f, Float anisotropy = 0.f) const override;
 
        UniquePtr<DirectX12BottomLevelAccelerationStructure> createBottomLevelAccelerationStructure(StringView name, AccelerationStructureFlags flags = AccelerationStructureFlags::None) const override;
 
        UniquePtr<DirectX12TopLevelAccelerationStructure> createTopLevelAccelerationStructure(StringView name, AccelerationStructureFlags flags = AccelerationStructureFlags::None) const override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12Device final : public GraphicsDevice<DirectX12GraphicsFactory, DirectX12Surface, DirectX12GraphicsAdapter, DirectX12SwapChain, DirectX12Queue, DirectX12RenderPass, DirectX12RenderPipeline, DirectX12ComputePipeline, DirectX12RayTracingPipeline, DirectX12Barrier>, public ComResource<ID3D12Device10> {
        LITEFX_IMPLEMENTATION(DirectX12DeviceImpl);
        friend struct SharedObject::Allocator<DirectX12Device>;
        friend class DirectX12Backend;
 
    private:
        explicit DirectX12Device(const DirectX12GraphicsAdapter& adapter, UniquePtr<DirectX12Surface>&& surface, UInt32 globalBufferHeapSize = D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1, UInt32 globalSamplerHeapSize = D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE);
 
    private:
        DirectX12Device(DirectX12Device&&) noexcept = delete;
 
        DirectX12Device(const DirectX12Device&) = delete;
 
        DirectX12Device& operator=(DirectX12Device&&) noexcept = delete;
 
        DirectX12Device& operator=(const DirectX12Device&) = delete;
        
    public:
        ~DirectX12Device() noexcept override;
 
        // Factory methods.
    public:
        static inline SharedPtr<DirectX12Device> create(const DirectX12Backend& backend, const DirectX12GraphicsAdapter& adapter, UniquePtr<DirectX12Surface>&& surface, GraphicsDeviceFeatures features = {}) {
            return SharedObject::create<DirectX12Device>(adapter, std::move(surface))->initialize(backend, Format::B8G8R8A8_SRGB, { 800, 600 }, 3, false, features); // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        }
 
        static inline SharedPtr<DirectX12Device> create(const DirectX12Backend& backend, const DirectX12GraphicsAdapter& adapter, UniquePtr<DirectX12Surface>&& surface, Format format, const Size2d& renderArea, UInt32 backBuffers, bool enableVsync = false, GraphicsDeviceFeatures features = {}, UInt32 globalBufferHeapSize = D3D12_MAX_SHADER_VISIBLE_DESCRIPTOR_HEAP_SIZE_TIER_1, UInt32 globalSamplerHeapSize = D3D12_MAX_SHADER_VISIBLE_SAMPLER_HEAP_SIZE) {
            return SharedObject::create<DirectX12Device>(adapter, std::move(surface), globalBufferHeapSize, globalSamplerHeapSize)->initialize(backend, format, renderArea, backBuffers, enableVsync, features);
        }
 
    private:
        SharedPtr<DirectX12Device> initialize(const DirectX12Backend& backend, Format format, const Size2d& renderArea, UInt32 backBuffers, bool enableVsync, GraphicsDeviceFeatures features);
 
        void release() noexcept;
 
        // DirectX 12 Device interface.
    public:
        const ID3D12DescriptorHeap* globalBufferHeap() const noexcept;
 
        const ID3D12DescriptorHeap* globalSamplerHeap() const noexcept;
 
        void allocateGlobalDescriptors(const DirectX12DescriptorSet& descriptorSet, UInt32& bufferOffset, UInt32& samplerOffset) const;
 
        void releaseGlobalDescriptors(const DirectX12DescriptorSet& descriptorSet) const;
 
        void updateBufferDescriptors(const DirectX12DescriptorSet& descriptorSet, UInt32 firstDescriptor, UInt32 descriptors) const noexcept;
 
        void updateSamplerDescriptors(const DirectX12DescriptorSet& descriptorSet, UInt32 firstDescriptor, UInt32 descriptors) const noexcept;
 
        void bindDescriptorSet(const DirectX12CommandBuffer& commandBuffer, const DirectX12DescriptorSet& descriptorSet, const DirectX12PipelineState& pipeline) const noexcept;
 
        void bindGlobalDescriptorHeaps(const DirectX12CommandBuffer& commandBuffer) const noexcept;
 
        void indirectDrawSignatures(ComPtr<ID3D12CommandSignature>& dispatchSignature, ComPtr<ID3D12CommandSignature>& dispatchMeshSignature, ComPtr<ID3D12CommandSignature>& drawSignature, ComPtr<ID3D12CommandSignature>& drawIndexedSignature) const noexcept;
 
        // GraphicsDevice interface.
    public:
        DeviceState& state() const noexcept override;
 
        const DirectX12SwapChain& swapChain() const noexcept override;
 
        DirectX12SwapChain& swapChain() noexcept override;
 
        const DirectX12Surface& surface() const noexcept override;
 
        const DirectX12GraphicsAdapter& adapter() const noexcept override;
 
        const DirectX12GraphicsFactory& factory() const noexcept override;
 
        const DirectX12Queue& defaultQueue(QueueType type) const override;
 
        SharedPtr<const DirectX12Queue> createQueue(QueueType type, QueuePriority priority) override;
 
        [[nodiscard]] UniquePtr<DirectX12Barrier> makeBarrier(PipelineStage syncBefore, PipelineStage syncAfter) const override;
 
        [[nodiscard]] SharedPtr<DirectX12FrameBuffer> makeFrameBuffer(StringView name, const Size2d& renderArea) const override;
 
        MultiSamplingLevel maximumMultiSamplingLevel(Format format) const noexcept override;
 
        double ticksPerMillisecond() const noexcept override;
 
        void wait() const override;
 
        void computeAccelerationStructureSizes(const DirectX12BottomLevelAccelerationStructure& blas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate = false) const override;
 
        void computeAccelerationStructureSizes(const DirectX12TopLevelAccelerationStructure& tlas, UInt64& bufferSize, UInt64& scratchSize, bool forUpdate = false) const override;
 
#if defined(LITEFX_BUILD_DEFINE_BUILDERS)
    public:
        [[nodiscard]] DirectX12RenderPassBuilder buildRenderPass(UInt32 commandBuffers = 1) const override;
 
        [[nodiscard]] DirectX12RenderPassBuilder buildRenderPass(const String& name, UInt32 commandBuffers = 1) const override;
 
        //[[nodiscard]] DirectX12RenderPipelineBuilder buildRenderPipeline(const String& name) const override;
 
        [[nodiscard]] DirectX12RenderPipelineBuilder buildRenderPipeline(const DirectX12RenderPass& renderPass, const String& name) const override;
 
        [[nodiscard]] DirectX12ComputePipelineBuilder buildComputePipeline(const String& name) const override;
 
        [[nodiscard]] DirectX12RayTracingPipelineBuilder buildRayTracingPipeline(ShaderRecordCollection&& shaderRecords) const override;
 
        [[nodiscard]] DirectX12RayTracingPipelineBuilder buildRayTracingPipeline(const String& name, ShaderRecordCollection&& shaderRecords) const override;
        
        [[nodiscard]] DirectX12PipelineLayoutBuilder buildPipelineLayout() const override;
 
        [[nodiscard]] DirectX12InputAssemblerBuilder buildInputAssembler() const override;
 
        [[nodiscard]] DirectX12RasterizerBuilder buildRasterizer() const override;
 
        [[nodiscard]] DirectX12ShaderProgramBuilder buildShaderProgram() const override;
 
        [[nodiscard]] DirectX12BarrierBuilder buildBarrier() const override;
#endif // defined(LITEFX_BUILD_DEFINE_BUILDERS)
    };
    
    class LITEFX_DIRECTX12_API DirectX12Backend final : public RenderBackend<DirectX12Device>, public ComResource<IDXGIFactory7> {
        LITEFX_IMPLEMENTATION(DirectX12BackendImpl);
 
    public:
        explicit DirectX12Backend(const App& app, bool advancedSoftwareRasterizer = false);
 
        DirectX12Backend(DirectX12Backend&&) noexcept;
 
        DirectX12Backend(const DirectX12Backend&) = delete;
 
        DirectX12Backend& operator=(DirectX12Backend&&) noexcept;
 
        DirectX12Backend& operator=(const DirectX12Backend&) = delete;
 
        ~DirectX12Backend() noexcept override;
 
        // IBackend interface.
    public:
        BackendType type() const noexcept override;
 
        StringView name() const noexcept override;
 
    protected:
        void activate() override;
 
        void deactivate() override;
 
        // RenderBackend interface.
    public:
        const Array<SharedPtr<const DirectX12GraphicsAdapter>>& adapters() const override;
 
        const DirectX12GraphicsAdapter* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const noexcept override;
 
        void registerDevice(const String& name, SharedPtr<DirectX12Device>&& device) override;
 
        void releaseDevice(const String& name) override;
 
        DirectX12Device* device(const String& name) noexcept override;
 
        const DirectX12Device* device(const String& name) const noexcept override;
 
    public:
        UniquePtr<DirectX12Surface> createSurface(const HWND& hwnd) const;
 
        virtual void enableAdvancedSoftwareRasterizer(bool enable = false);
    };
 
}
 
#pragma warning(pop)