dx12_builders.hpp

#pragma once
 
#include <litefx/rendering_builders.hpp>
#include "dx12_api.hpp"
#include "dx12.hpp"
 
#if defined(LITEFX_BUILD_DEFINE_BUILDERS)
namespace LiteFX::Rendering::Backends {
    using namespace LiteFX::Math;
    using namespace LiteFX::Rendering;
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12BarrierBuilder final : public BarrierBuilder<DirectX12Barrier> {
    public:
        explicit DirectX12BarrierBuilder();
        ~DirectX12BarrierBuilder() noexcept override;
 
        DirectX12BarrierBuilder(const DirectX12BarrierBuilder&) = delete;
        DirectX12BarrierBuilder(DirectX12BarrierBuilder&&) noexcept = default;
        DirectX12BarrierBuilder& operator=(const DirectX12BarrierBuilder&) = delete;
        DirectX12BarrierBuilder& operator=(DirectX12BarrierBuilder&&) noexcept = delete;
 
        // BarrierBuilder interface.
    public:
        void setupStages(PipelineStage waitFor, PipelineStage continueWith) override;
 
        void setupGlobalBarrier(ResourceAccess before, ResourceAccess after) override;
 
        void setupBufferBarrier(IBuffer& buffer, ResourceAccess before, ResourceAccess after) override;
 
        void setupImageBarrier(IImage& image, ResourceAccess before, ResourceAccess after, ImageLayout layout, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane) override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12ShaderProgramBuilder final : public ShaderProgramBuilder<DirectX12ShaderProgram> {
    public:
        explicit DirectX12ShaderProgramBuilder(const DirectX12Device& device);
        ~DirectX12ShaderProgramBuilder() noexcept override;
 
        DirectX12ShaderProgramBuilder(const DirectX12ShaderProgramBuilder&) = delete;
        DirectX12ShaderProgramBuilder(DirectX12ShaderProgramBuilder&&) noexcept = delete;
        auto operator=(const DirectX12ShaderProgramBuilder&) = delete;
        auto operator=(DirectX12ShaderProgramBuilder&&) noexcept = delete;
 
        // Builder interface.
    protected:
        void build() override;
 
        // ShaderProgramBuilder interface.
    protected:
        UniquePtr<DirectX12ShaderModule> makeShaderModule(ShaderStage type, const String& fileName, const String& entryPoint, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor) override;
 
        UniquePtr<DirectX12ShaderModule> makeShaderModule(ShaderStage type, std::istream& stream, const String& name, const String& entryPoint, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor) override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12RasterizerBuilder final : public RasterizerBuilder<DirectX12Rasterizer> {
    public:
        explicit DirectX12RasterizerBuilder();
        ~DirectX12RasterizerBuilder() noexcept override;
 
        DirectX12RasterizerBuilder(const DirectX12RasterizerBuilder&) = delete;
        DirectX12RasterizerBuilder(DirectX12RasterizerBuilder&&) noexcept = delete;
        auto operator=(const DirectX12RasterizerBuilder&) = delete;
        auto operator=(DirectX12RasterizerBuilder&&) noexcept = delete;
 
        // Builder interface.
    protected:
        void build() override;
    };
    
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12InputAssemblerBuilder final : public InputAssemblerBuilder<DirectX12InputAssembler> {
        LITEFX_IMPLEMENTATION(DirectX12InputAssemblerBuilderImpl);
 
    public:
        explicit DirectX12InputAssemblerBuilder();
        ~DirectX12InputAssemblerBuilder() noexcept override;
 
        DirectX12InputAssemblerBuilder(const DirectX12InputAssemblerBuilder&) = delete;
        DirectX12InputAssemblerBuilder(DirectX12InputAssemblerBuilder&&) noexcept = delete;
        auto operator=(const DirectX12InputAssemblerBuilder&) = delete;
        auto operator=(DirectX12InputAssemblerBuilder&&) noexcept = delete;
 
        // Builder interface.
    protected:
        void build() override;
 
    public:
        DirectX12VertexBufferLayoutBuilder vertexBuffer(size_t elementSize, UInt32 binding = 0);
 
        template <typename TSelf>
        inline auto indexType(this TSelf&& self, IndexType type) -> TSelf&& {
            self.use(DirectX12IndexBufferLayout::create(type));
            return std::forward<TSelf>(self);
        }
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12VertexBufferLayoutBuilder final : public VertexBufferLayoutBuilder<DirectX12VertexBufferLayout, DirectX12InputAssemblerBuilder> {
    public:
        using VertexBufferLayoutBuilder<DirectX12VertexBufferLayout, DirectX12InputAssemblerBuilder>::VertexBufferLayoutBuilder;
 
        // Builder interface.
    protected:
        void build() override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12PipelineLayoutBuilder final : public PipelineLayoutBuilder<DirectX12PipelineLayout> {
        LITEFX_IMPLEMENTATION(DirectX12PipelineLayoutBuilderImpl);
        friend class DirectX12DescriptorSetLayoutBuilder;
 
    public:
        DirectX12PipelineLayoutBuilder(const DirectX12Device& device);
        ~DirectX12PipelineLayoutBuilder() noexcept override;
 
        DirectX12PipelineLayoutBuilder(DirectX12PipelineLayoutBuilder&&) noexcept = delete;
        DirectX12PipelineLayoutBuilder(const DirectX12PipelineLayoutBuilder&) = delete;
        auto operator=(DirectX12PipelineLayoutBuilder&&) noexcept = delete;
        auto operator=(const DirectX12PipelineLayoutBuilder&) = delete;
 
        // Builder interface.
    protected:
        void build() override;
 
        // DirectX12PipelineLayoutBuilder.
    public:
        DirectX12DescriptorSetLayoutBuilder descriptorSet(UInt32 space = 0, ShaderStage stages = ShaderStage::Any);
 
        DirectX12PushConstantsLayoutBuilder pushConstants(UInt32 size);
 
    private:
        SharedPtr<const DirectX12Device> device() const noexcept;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12DescriptorSetLayoutBuilder final : public DescriptorSetLayoutBuilder<DirectX12DescriptorSetLayout, DirectX12PipelineLayoutBuilder> {
    public:
        explicit DirectX12DescriptorSetLayoutBuilder(DirectX12PipelineLayoutBuilder& parent, UInt32 space = 0, ShaderStage stages = ShaderStage::Any);
        ~DirectX12DescriptorSetLayoutBuilder() noexcept override;
 
        DirectX12DescriptorSetLayoutBuilder(const DirectX12DescriptorSetLayoutBuilder&) = delete;
        DirectX12DescriptorSetLayoutBuilder(DirectX12DescriptorSetLayoutBuilder&&) noexcept = delete;
        auto operator=(const DirectX12DescriptorSetLayoutBuilder&) = delete;
        auto operator=(DirectX12DescriptorSetLayoutBuilder&&) noexcept = delete;
 
        // Builder interface.
    protected:
        void build() override;
 
        // DescriptorSetLayoutBuilder interface.
    protected:
        DirectX12DescriptorLayout makeDescriptor(DescriptorType type, UInt32 binding, UInt32 descriptorSize, UInt32 descriptors) override;
 
        DirectX12DescriptorLayout makeDescriptor(UInt32 binding, FilterMode magFilter, FilterMode minFilter, BorderMode borderU, BorderMode borderV, BorderMode borderW, MipMapMode mipMapMode, Float mipMapBias, Float minLod, Float maxLod, Float anisotropy) override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12PushConstantsLayoutBuilder final : public PushConstantsLayoutBuilder<DirectX12PushConstantsLayout, DirectX12PipelineLayoutBuilder> {
    public:
        explicit DirectX12PushConstantsLayoutBuilder(DirectX12PipelineLayoutBuilder& parent, UInt32 size);
        ~DirectX12PushConstantsLayoutBuilder() noexcept override;
 
        DirectX12PushConstantsLayoutBuilder(const DirectX12PushConstantsLayoutBuilder&) = delete;
        DirectX12PushConstantsLayoutBuilder(DirectX12PushConstantsLayoutBuilder&&) noexcept = delete;
        auto operator=(const DirectX12PushConstantsLayoutBuilder&) = delete;
        auto operator=(DirectX12PushConstantsLayoutBuilder&&) noexcept = delete;
 
        // Builder interface.
    protected:
        void build() override;
 
        // PushConstantsLayoutBuilder interface.
    protected:
        UniquePtr<DirectX12PushConstantsRange> makeRange(ShaderStage shaderStages, UInt32 offset, UInt32 size, UInt32 space, UInt32 binding) override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12RenderPipelineBuilder final : public RenderPipelineBuilder<DirectX12RenderPipeline> {
    public:
        explicit DirectX12RenderPipelineBuilder(const DirectX12RenderPass& renderPass, const String& name = "");
        ~DirectX12RenderPipelineBuilder() noexcept override;
 
        DirectX12RenderPipelineBuilder(DirectX12RenderPipelineBuilder&&) noexcept = delete;
        DirectX12RenderPipelineBuilder(const DirectX12RenderPipelineBuilder&) = delete;
        auto operator=(DirectX12RenderPipelineBuilder&&) noexcept = delete;
        auto operator=(const DirectX12RenderPipelineBuilder&) = delete;
 
        // Builder interface.
    public:
        void build() override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12ComputePipelineBuilder final : public ComputePipelineBuilder<DirectX12ComputePipeline> {
    public:
        explicit DirectX12ComputePipelineBuilder(const DirectX12Device& device, const String& name = "");
        ~DirectX12ComputePipelineBuilder() noexcept override;
 
        DirectX12ComputePipelineBuilder(DirectX12ComputePipelineBuilder&&) noexcept = delete;
        DirectX12ComputePipelineBuilder(const DirectX12ComputePipelineBuilder&) = delete;
        auto operator=(DirectX12ComputePipelineBuilder&&) noexcept = delete;
        auto operator=(const DirectX12ComputePipelineBuilder&) = delete;
 
        // Builder interface.
    public:
        void build() override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12RayTracingPipelineBuilder final : public RayTracingPipelineBuilder<DirectX12RayTracingPipeline> {
    public:
        explicit DirectX12RayTracingPipelineBuilder(const DirectX12Device& device, ShaderRecordCollection&& shaderRecords, const String& name = "");
        ~DirectX12RayTracingPipelineBuilder() noexcept override;
 
        DirectX12RayTracingPipelineBuilder(DirectX12RayTracingPipelineBuilder&&) noexcept = delete;
        DirectX12RayTracingPipelineBuilder(const DirectX12RayTracingPipelineBuilder&) = delete;
        auto operator=(DirectX12RayTracingPipelineBuilder&&) noexcept = delete;
        auto operator=(const DirectX12RayTracingPipelineBuilder&) = delete;
 
        // Builder interface.
    public:
        void build() override;
    };
 
    class LITEFX_DIRECTX12_API [[nodiscard]] DirectX12RenderPassBuilder final : public RenderPassBuilder<DirectX12RenderPass> {
    public:
        explicit DirectX12RenderPassBuilder(const DirectX12Device& device, const String& name = "");
 
        explicit DirectX12RenderPassBuilder(const DirectX12Device& device, UInt32 commandBuffers, const String& name = "");
 
        ~DirectX12RenderPassBuilder() noexcept override;
 
        DirectX12RenderPassBuilder(const DirectX12RenderPassBuilder&) = delete;
        DirectX12RenderPassBuilder(DirectX12RenderPassBuilder&&) noexcept = delete;
        auto operator=(const DirectX12RenderPassBuilder&) = delete;
        auto operator=(DirectX12RenderPassBuilder&&) noexcept = delete;
 
        // Builder interface.
    protected:
        void build() override;
 
        // RenderPassBuilder interface.
    protected:
        RenderPassDependency makeInputAttachment(DescriptorBindingPoint binding, const RenderTarget& renderTarget) override;
    };
 
}
#endif // defined(LITEFX_BUILD_DEFINE_BUILDERS)