dx12_builders.hpp

#pragma once
 
#include <litefx/rendering_builders.hpp>
#include "dx12_api.hpp"
#include "dx12.hpp"
 
#if defined(BUILD_DEFINE_BUILDERS)
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    class LITEFX_DIRECTX12_API DirectX12ShaderProgramBuilder : public ShaderProgramBuilder<DirectX12ShaderProgramBuilder, DirectX12ShaderProgram> {
        LITEFX_IMPLEMENTATION(DirectX12ShaderProgramBuilderImpl);
 
    public:
        explicit DirectX12ShaderProgramBuilder(const DirectX12Device& device);
        DirectX12ShaderProgramBuilder(const DirectX12ShaderProgramBuilder&) = delete;
        DirectX12ShaderProgramBuilder(DirectX12ShaderProgramBuilder&&) = delete;
        virtual ~DirectX12ShaderProgramBuilder() noexcept;
 
        // Builder interface.
    protected:
        virtual void build() override;
 
        // ShaderProgramBuilder interface.
    public:
        virtual DirectX12ShaderProgramBuilder& withShaderModule(const ShaderStage& type, const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withShaderModule(const ShaderStage& type, std::istream& stream, const String& name, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withVertexShaderModule(const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withVertexShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withTessellationControlShaderModule(const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withTessellationControlShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withTessellationEvaluationShaderModule(const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withTessellationEvaluationShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withGeometryShaderModule(const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withGeometryShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withFragmentShaderModule(const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withFragmentShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withComputeShaderModule(const String& fileName, const String& entryPoint = "main") override;
 
        virtual DirectX12ShaderProgramBuilder& withComputeShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RasterizerBuilder : public RasterizerBuilder<DirectX12RasterizerBuilder, DirectX12Rasterizer> {
        LITEFX_IMPLEMENTATION(DirectX12RasterizerBuilderImpl);
 
    public:
        explicit DirectX12RasterizerBuilder() noexcept;
        DirectX12RasterizerBuilder(const DirectX12RasterizerBuilder&) noexcept = delete;
        DirectX12RasterizerBuilder(DirectX12RasterizerBuilder&&) noexcept = delete;
        virtual ~DirectX12RasterizerBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // RasterizerBuilder interface.
    public:
        virtual DirectX12RasterizerBuilder& polygonMode(const PolygonMode& mode = PolygonMode::Solid) noexcept override;
 
        virtual DirectX12RasterizerBuilder& cullMode(const CullMode& cullMode = CullMode::BackFaces) noexcept override;
 
        virtual DirectX12RasterizerBuilder& cullOrder(const CullOrder& cullOrder = CullOrder::CounterClockWise) noexcept override;
 
        virtual DirectX12RasterizerBuilder& lineWidth(const Float& lineWidth = 1.f) noexcept override;
 
        virtual DirectX12RasterizerBuilder& depthBias(const DepthStencilState::DepthBias& depthBias) noexcept override;
 
        virtual DirectX12RasterizerBuilder& depthState(const DepthStencilState::DepthState& depthState) noexcept override;
 
        virtual DirectX12RasterizerBuilder& stencilState(const DepthStencilState::StencilState& stencilState) noexcept override;
    };
    
    class LITEFX_DIRECTX12_API DirectX12VertexBufferLayoutBuilder : public VertexBufferLayoutBuilder<DirectX12VertexBufferLayoutBuilder, DirectX12VertexBufferLayout, DirectX12InputAssemblerBuilder> {
    public:
        using VertexBufferLayoutBuilder<DirectX12VertexBufferLayoutBuilder, DirectX12VertexBufferLayout, DirectX12InputAssemblerBuilder>::VertexBufferLayoutBuilder;
 
    public:
        virtual DirectX12VertexBufferLayoutBuilder& withAttribute(UniquePtr<BufferAttribute>&& attribute) override;
 
    public:
        virtual DirectX12VertexBufferLayoutBuilder& withAttribute(const BufferFormat& format, const UInt32& offset, const AttributeSemantic& semantic = AttributeSemantic::Unknown, const UInt32& semanticIndex = 0);
 
        virtual DirectX12VertexBufferLayoutBuilder& withAttribute(const UInt32& location, const BufferFormat& format, const UInt32& offset, const AttributeSemantic& semantic = AttributeSemantic::Unknown, const UInt32& semanticIndex = 0);
    };
 
    class LITEFX_DIRECTX12_API DirectX12InputAssemblerBuilder : public InputAssemblerBuilder<DirectX12InputAssemblerBuilder, DirectX12InputAssembler> {
        LITEFX_IMPLEMENTATION(DirectX12InputAssemblerBuilderImpl);
 
    public:
        explicit DirectX12InputAssemblerBuilder() noexcept;
        DirectX12InputAssemblerBuilder(const DirectX12InputAssemblerBuilder&) noexcept = delete;
        DirectX12InputAssemblerBuilder(DirectX12InputAssemblerBuilder&&) noexcept = delete;
        virtual ~DirectX12InputAssemblerBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // InputAssemblerBuilder interface.
    public:
        virtual DirectX12InputAssemblerBuilder& topology(const PrimitiveTopology& topology) override;
 
        virtual void use(UniquePtr<DirectX12VertexBufferLayout>&& layout) override;
 
        virtual void use(UniquePtr<DirectX12IndexBufferLayout>&& layout) override;
 
    public:
        virtual DirectX12VertexBufferLayoutBuilder vertexBuffer(const size_t& elementSize, const UInt32& binding = 0);
 
        virtual DirectX12InputAssemblerBuilder& indexType(const IndexType& type);
    };
 
    class LITEFX_DIRECTX12_API DirectX12DescriptorSetLayoutBuilder : public DescriptorSetLayoutBuilder<DirectX12DescriptorSetLayoutBuilder, DirectX12DescriptorSetLayout, DirectX12PipelineLayoutBuilder> {
        LITEFX_IMPLEMENTATION(DirectX12DescriptorSetLayoutBuilderImpl);
 
    public:
        explicit DirectX12DescriptorSetLayoutBuilder(DirectX12PipelineLayoutBuilder& parent, const UInt32& space = 0, const ShaderStage& stages = ShaderStage::Fragment | ShaderStage::Geometry | ShaderStage::TessellationControl | ShaderStage::TessellationEvaluation | ShaderStage::Vertex, const UInt32& poolSize = 0, const UInt32& maxUnboundedArraySize = 0);
        DirectX12DescriptorSetLayoutBuilder(const DirectX12DescriptorSetLayoutBuilder&) = delete;
        DirectX12DescriptorSetLayoutBuilder(DirectX12DescriptorSetLayoutBuilder&&) = delete;
        virtual ~DirectX12DescriptorSetLayoutBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // DescriptorSetLayoutBuilder interface.
    public:
        virtual DirectX12DescriptorSetLayoutBuilder& withDescriptor(UniquePtr<DirectX12DescriptorLayout>&& layout) override;
 
        virtual DirectX12DescriptorSetLayoutBuilder& withDescriptor(const DescriptorType& type, const UInt32& binding, const UInt32& descriptorSize, const UInt32& descriptors = 1) override;
 
        virtual DirectX12DescriptorSetLayoutBuilder& withStaticSampler(const UInt32& binding, 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& minLod = 0.f, const Float& maxLod = std::numeric_limits<Float>::max(), const Float& anisotropy = 0.f) override;
 
        // DirectX12DescriptorSetLayoutBuilder.
    public:
        virtual DirectX12DescriptorSetLayoutBuilder& space(const UInt32& space) noexcept;
 
        virtual DirectX12DescriptorSetLayoutBuilder& shaderStages(const ShaderStage& stages) noexcept;
 
        virtual DirectX12DescriptorSetLayoutBuilder& poolSize(const UInt32& poolSize) noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PushConstantsLayoutBuilder : public PushConstantsLayoutBuilder<DirectX12PushConstantsLayoutBuilder, DirectX12PushConstantsLayout, DirectX12PipelineLayoutBuilder> {
        LITEFX_IMPLEMENTATION(DirectX12PushConstantsLayoutBuilderImpl);
 
    public:
        explicit DirectX12PushConstantsLayoutBuilder(DirectX12PipelineLayoutBuilder& parent, const UInt32& size);
        DirectX12PushConstantsLayoutBuilder(const DirectX12PushConstantsLayoutBuilder&) = delete;
        DirectX12PushConstantsLayoutBuilder(DirectX12PushConstantsLayoutBuilder&&) = delete;
        virtual ~DirectX12PushConstantsLayoutBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // PushConstantsLayoutBuilder interface.
    public:
        virtual DirectX12PushConstantsLayoutBuilder& withRange(const ShaderStage& shaderStages, const UInt32& offset, const UInt32& size, const UInt32& space, const UInt32& binding) override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12PipelineLayoutBuilder : public PipelineLayoutBuilder<DirectX12PipelineLayoutBuilder, DirectX12PipelineLayout> {
        LITEFX_IMPLEMENTATION(DirectX12PipelineLayoutBuilderImpl);
        friend class DirectX12DescriptorSetLayoutBuilder;
 
    public:
        DirectX12PipelineLayoutBuilder(const DirectX12Device& device);
        DirectX12PipelineLayoutBuilder(DirectX12PipelineLayoutBuilder&&) = delete;
        DirectX12PipelineLayoutBuilder(const DirectX12PipelineLayoutBuilder&) = delete;
        virtual ~DirectX12PipelineLayoutBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // PipelineBuilder interface.
    public:
        virtual void use(UniquePtr<DirectX12DescriptorSetLayout>&& layout) override;
 
        virtual void use(UniquePtr<DirectX12PushConstantsLayout>&& layout) override;
 
        // DirectX12PipelineLayoutBuilder.
    public:
        virtual DirectX12DescriptorSetLayoutBuilder descriptorSet(const UInt32& space = 0, const ShaderStage& stages = ShaderStage::Compute | ShaderStage::Fragment | ShaderStage::Geometry | ShaderStage::TessellationControl | ShaderStage::TessellationEvaluation | ShaderStage::Vertex, const UInt32& poolSize = 0);
 
        virtual DirectX12PushConstantsLayoutBuilder pushConstants(const UInt32& size);
 
    private:
        virtual const DirectX12Device& device() const noexcept;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RenderPipelineBuilder : public RenderPipelineBuilder<DirectX12RenderPipelineBuilder, DirectX12RenderPipeline> {
        LITEFX_IMPLEMENTATION(DirectX12RenderPipelineBuilderImpl);
 
    public:
        explicit DirectX12RenderPipelineBuilder(const DirectX12RenderPass& renderPass, const String& name = "");
        DirectX12RenderPipelineBuilder(DirectX12RenderPipelineBuilder&&) = delete;
        DirectX12RenderPipelineBuilder(const DirectX12RenderPipelineBuilder&) = delete;
        virtual ~DirectX12RenderPipelineBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // RenderPipelineBuilder interface.
    public:
        virtual DirectX12RenderPipelineBuilder& shaderProgram(SharedPtr<DirectX12ShaderProgram> shaderProgram) override;
 
        virtual DirectX12RenderPipelineBuilder& layout(SharedPtr<DirectX12PipelineLayout> layout) override;
 
        virtual DirectX12RenderPipelineBuilder& rasterizer(SharedPtr<DirectX12Rasterizer> rasterizer) override;
 
        virtual DirectX12RenderPipelineBuilder& inputAssembler(SharedPtr<DirectX12InputAssembler> inputAssembler) override;
 
        virtual DirectX12RenderPipelineBuilder& viewport(SharedPtr<IViewport> viewport) override;
 
        virtual DirectX12RenderPipelineBuilder& scissor(SharedPtr<IScissor> scissor) override;
 
        virtual DirectX12RenderPipelineBuilder& enableAlphaToCoverage(const bool& enable = true) override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12ComputePipelineBuilder : public ComputePipelineBuilder<DirectX12ComputePipelineBuilder, DirectX12ComputePipeline> {
        LITEFX_IMPLEMENTATION(DirectX12ComputePipelineBuilderImpl);
 
    public:
        explicit DirectX12ComputePipelineBuilder(const DirectX12Device& device, const String& name = "");
        DirectX12ComputePipelineBuilder(DirectX12ComputePipelineBuilder&&) = delete;
        DirectX12ComputePipelineBuilder(const DirectX12ComputePipelineBuilder&) = delete;
        virtual ~DirectX12ComputePipelineBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // ComputePipelineBuilder interface.
    public:
        virtual DirectX12ComputePipelineBuilder& shaderProgram(SharedPtr<DirectX12ShaderProgram> program) override;
 
        virtual DirectX12ComputePipelineBuilder& layout(SharedPtr<DirectX12PipelineLayout> layout) override;
    };
 
    class LITEFX_DIRECTX12_API DirectX12RenderPassBuilder : public RenderPassBuilder<DirectX12RenderPassBuilder, DirectX12RenderPass> {
        LITEFX_IMPLEMENTATION(DirectX12RenderPassBuilderImpl)
 
    public:
        explicit DirectX12RenderPassBuilder(const DirectX12Device& device, const String& name = "") noexcept;
 
        explicit DirectX12RenderPassBuilder(const DirectX12Device& device, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const String& name = "") noexcept;
 
        explicit DirectX12RenderPassBuilder(const DirectX12Device& device, const UInt32& commandBuffers, const String& name = "") noexcept;
 
        explicit DirectX12RenderPassBuilder(const DirectX12Device& device, const UInt32& commandBuffers, const MultiSamplingLevel& multiSamplingLevel, const String& name = "") noexcept;
        DirectX12RenderPassBuilder(const DirectX12RenderPassBuilder&) noexcept = delete;
        DirectX12RenderPassBuilder(DirectX12RenderPassBuilder&&) noexcept = delete;
        virtual ~DirectX12RenderPassBuilder() noexcept;
 
        // Builder interface.
    public:
        virtual void build() override;
 
        // RenderPassBuilder interface.
    public:
        virtual DirectX12RenderPassBuilder& commandBuffers(const UInt32& count) override;
 
        virtual DirectX12RenderPassBuilder& multiSamplingLevel(const MultiSamplingLevel& samples) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(const String& name, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(const UInt32& location, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(const String& name, const UInt32& location, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(DirectX12InputAttachmentMapping& output, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(const String& name, DirectX12InputAttachmentMapping& output, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(DirectX12InputAttachmentMapping& output, const UInt32& location, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& renderTarget(const String& name, DirectX12InputAttachmentMapping& output, const UInt32& location, const RenderTargetType& type, const Format& format, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }, bool clearColor = true, bool clearStencil = true, bool isVolatile = false) override;
 
        virtual DirectX12RenderPassBuilder& inputAttachment(const DirectX12InputAttachmentMapping& inputAttachment) override;
 
        virtual DirectX12RenderPassBuilder& inputAttachment(const UInt32& inputLocation, const DirectX12RenderPass& renderPass, const UInt32& outputLocation) override;
 
        virtual DirectX12RenderPassBuilder& inputAttachment(const UInt32& inputLocation, const DirectX12RenderPass& renderPass, const RenderTarget& renderTarget) override;
    };
}
#endif // defined(BUILD_DEFINE_BUILDERS)