rendering_builders.hpp

#pragma once
 
#include "rendering_api.hpp"
#include "rendering.hpp"
 
#if defined(BUILD_DEFINE_BUILDERS)
namespace LiteFX::Rendering {
 
    template <typename TDerived, typename TShaderProgram> requires
        rtti::implements<TShaderProgram, ShaderProgram<typename TShaderProgram::shader_module_type>>
    class ShaderProgramBuilder : public Builder<TDerived, TShaderProgram, std::nullptr_t, SharedPtr<TShaderProgram>> {
    public:
        using Builder<TDerived, TShaderProgram, std::nullptr_t, SharedPtr<TShaderProgram>>::Builder;
        using shader_program_type = TShaderProgram;
        using shader_module_type = shader_program_type::shader_module_type;
 
    public:
        virtual TDerived& withShaderModule(const ShaderStage& type, const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withShaderModule(const ShaderStage& type, std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withVertexShaderModule(const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withVertexShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withTessellationControlShaderModule(const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withTessellationControlShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withTessellationEvaluationShaderModule(const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withTessellationEvaluationShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withGeometryShaderModule(const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withGeometryShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withFragmentShaderModule(const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withFragmentShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withComputeShaderModule(const String& fileName, const String& entryPoint = "main") = 0;
 
        virtual TDerived& withComputeShaderModule(std::istream& stream, const String& name, const String& entryPoint = "main") = 0;
    };
 
    template <typename TDerived, typename TRasterizer> requires
        rtti::implements<TRasterizer, IRasterizer>
    class RasterizerBuilder : public Builder<TDerived, TRasterizer, std::nullptr_t, SharedPtr<TRasterizer>> {
    public:
        using Builder<TDerived, TRasterizer, std::nullptr_t, SharedPtr<TRasterizer>>::Builder;
        using rasterizer_type = TRasterizer;
 
    public:
        virtual TDerived& polygonMode(const PolygonMode& mode) noexcept = 0;
 
        virtual TDerived& cullMode(const CullMode& mode) noexcept = 0;
 
        virtual TDerived& cullOrder(const CullOrder& order) noexcept = 0;
 
        virtual TDerived& lineWidth(const Float& width) noexcept = 0;
 
        virtual TDerived& depthBias(const DepthStencilState::DepthBias& depthBias) noexcept = 0;
 
        virtual TDerived& depthState(const DepthStencilState::DepthState& depthState) noexcept = 0;
 
        virtual TDerived& stencilState(const DepthStencilState::StencilState& stencilState) noexcept = 0;
    };
 
    template <typename TDerived, typename TVertexBufferLayout, typename TParent> requires
        rtti::implements<TVertexBufferLayout, IVertexBufferLayout>
    class VertexBufferLayoutBuilder : public Builder<TDerived, TVertexBufferLayout, TParent> {
    public:
        using Builder<TDerived, TVertexBufferLayout, TParent>::Builder;
        using vertex_buffer_layout_type = TVertexBufferLayout;
 
    public:
        virtual TDerived& withAttribute(UniquePtr<BufferAttribute>&& attribute) = 0;
    };
 
    template <typename TDerived, typename TDescriptorSetLayout, typename TParent> requires
        rtti::implements<TDescriptorSetLayout, DescriptorSetLayout<typename TDescriptorSetLayout::descriptor_layout_type, typename TDescriptorSetLayout::descriptor_set_type>>
    class DescriptorSetLayoutBuilder : public Builder<TDerived, TDescriptorSetLayout, TParent> {
    public:
        using Builder<TDerived, TDescriptorSetLayout, TParent>::Builder;
        using descriptor_set_layout_type = TDescriptorSetLayout;
        using descriptor_layout_type = descriptor_set_layout_type::descriptor_layout_type;
        using descriptor_set_type = descriptor_set_layout_type::descriptor_set_type;
 
    public:
        virtual TDerived& withDescriptor(UniquePtr<descriptor_layout_type>&& layout) = 0;
 
        virtual TDerived& withDescriptor(const DescriptorType& type, const UInt32& binding, const UInt32& descriptorSize, const UInt32& descriptors = 1) = 0;
 
        virtual TDerived& 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) = 0;
 
    public:
        virtual TDerived& withConstantBuffer(const UInt32& binding, const UInt32& descriptorSize, const UInt32& descriptors = 1) {
            return this->withDescriptor(DescriptorType::ConstantBuffer, binding, descriptorSize, descriptors);
        }
 
        virtual TDerived& withBuffer(const UInt32& binding, const UInt32& descriptors = 1, const bool& writable = false) {
            return this->withDescriptor(writable ? DescriptorType::RWBuffer : DescriptorType::Buffer, binding, 0, descriptors);
        }
 
        virtual TDerived& withStructuredBuffer(const UInt32& binding, const UInt32& descriptors = 1, const bool& writable = false) {
            return this->withDescriptor(writable ? DescriptorType::RWStructuredBuffer : DescriptorType::StructuredBuffer, binding, 0, descriptors);
        }
 
        virtual TDerived& withByteAddressBuffer(const UInt32& binding, const UInt32& descriptors = 1, const bool& writable = false) {
            return this->withDescriptor(writable ? DescriptorType::RWByteAddressBuffer : DescriptorType::ByteAddressBuffer, binding, 0, descriptors);
        }
 
        virtual TDerived& withTexture(const UInt32& binding, const UInt32& descriptors = 1, const bool& writable = false) {
            return this->withDescriptor(writable ? DescriptorType::RWTexture : DescriptorType::Texture, binding, 0, descriptors);
        }
 
        virtual TDerived& withInputAttachment(const UInt32& binding) {
            return this->withDescriptor(DescriptorType::InputAttachment, binding, 0);
        }
 
        virtual TDerived& withSampler(const UInt32& binding, const UInt32& descriptors = 1) {
            return this->withDescriptor(DescriptorType::Sampler, binding, 0, descriptors);
        }
 
        virtual void use(UniquePtr<descriptor_layout_type>&& layout) {
            this->withDescriptor(std::move(layout));
        }
    };
 
    template <typename TDerived, typename TPushConstantsLayout, typename TParent> requires
        rtti::implements<TPushConstantsLayout, PushConstantsLayout<typename TPushConstantsLayout::push_constants_range_type>>
    class PushConstantsLayoutBuilder : public Builder<TDerived, TPushConstantsLayout, TParent> {
    public:
        using Builder<TDerived, TPushConstantsLayout, TParent>::Builder;
        using push_constants_layout_type = TPushConstantsLayout;
        using push_constants_range_type = push_constants_layout_type::push_constants_range_type;
 
    public:
        virtual TDerived& withRange(const ShaderStage& shaderStages, const UInt32& offset, const UInt32& size, const UInt32& space, const UInt32& binding) = 0;
    };
 
    template <typename TDerived, typename TPipelineLayout> requires
        rtti::implements<TPipelineLayout, PipelineLayout<typename TPipelineLayout::descriptor_set_layout_type, typename TPipelineLayout::push_constants_layout_type>>
    class PipelineLayoutBuilder : public Builder<TDerived, TPipelineLayout, std::nullptr_t, SharedPtr<TPipelineLayout>> {
    public:
        using Builder<TDerived, TPipelineLayout, std::nullptr_t, SharedPtr<TPipelineLayout>>::Builder;
        using pipeline_layout_type = TPipelineLayout;
        using descriptor_set_layout_type = pipeline_layout_type::descriptor_set_layout_type;
        using push_constants_layout_type = pipeline_layout_type::push_constants_layout_type;
 
    public:
        virtual void use(UniquePtr<descriptor_set_layout_type>&& layout) = 0;
 
        virtual void use(UniquePtr<push_constants_layout_type>&& layout) = 0;
    };
 
    template <typename TDerived, typename TInputAssembler> requires
        rtti::implements<TInputAssembler, InputAssembler<typename TInputAssembler::vertex_buffer_layout_type, typename TInputAssembler::index_buffer_layout_type>>
    class InputAssemblerBuilder : public Builder<TDerived, TInputAssembler, std::nullptr_t, SharedPtr<TInputAssembler>> {
    public:
        using Builder<TDerived, TInputAssembler, std::nullptr_t, SharedPtr<TInputAssembler>>::Builder;
        using input_assembler_type = TInputAssembler;
        using vertex_buffer_layout_type = input_assembler_type::vertex_buffer_layout_type;
        using index_buffer_layout_type = input_assembler_type::index_buffer_layout_type;
 
    public:
        virtual TDerived& topology(const PrimitiveTopology& topology) = 0;
 
        virtual void use(UniquePtr<vertex_buffer_layout_type>&& layout) = 0;
 
        virtual void use(UniquePtr<index_buffer_layout_type>&& layout) = 0;
    };
 
    template <typename TDerived, typename TRenderPipeline> requires
        rtti::implements<TRenderPipeline, RenderPipeline<typename TRenderPipeline::pipeline_layout_type, typename TRenderPipeline::shader_program_type, typename TRenderPipeline::input_assembler_type, typename TRenderPipeline::rasterizer_type>>
    class RenderPipelineBuilder : public Builder<TDerived, TRenderPipeline> {
    public:
        using Builder<TDerived, TRenderPipeline>::Builder;
        using render_pipeline_type = TRenderPipeline;
        using pipeline_layout_type = render_pipeline_type::pipeline_layout_type;
        using shader_program_type = render_pipeline_type::shader_program_type;
        using input_assembler_type = render_pipeline_type::input_assembler_type;
        using rasterizer_type = render_pipeline_type::rasterizer_type;
 
    public:
        virtual TDerived& shaderProgram(SharedPtr<shader_program_type> program) = 0;
 
        virtual TDerived& layout(SharedPtr<pipeline_layout_type> layout) = 0;
 
        virtual TDerived& rasterizer(SharedPtr<rasterizer_type> rasterizer) = 0;
 
        virtual TDerived& inputAssembler(SharedPtr<input_assembler_type> inputAssembler) = 0;
 
        virtual TDerived& viewport(SharedPtr<IViewport> viewport) = 0;
 
        virtual TDerived& scissor(SharedPtr<IScissor> scissor) = 0;
 
        virtual TDerived& enableAlphaToCoverage(const bool& enable = true) = 0;
    };
 
    template <typename TDerived, typename TComputePipeline> requires
        rtti::implements<TComputePipeline, ComputePipeline<typename TComputePipeline::pipeline_layout_type, typename TComputePipeline::shader_program_type>>
    class ComputePipelineBuilder : public Builder<TDerived, TComputePipeline> {
    public:
        using Builder<TDerived, TComputePipeline>::Builder;
        using compute_pipeline_type = TComputePipeline;
        using pipeline_layout_type = compute_pipeline_type::pipeline_layout_type;
        using shader_program_type = compute_pipeline_type::shader_program_type;
 
    public:
        virtual TDerived& shaderProgram(SharedPtr<shader_program_type> program) = 0;
 
        virtual TDerived& layout(SharedPtr<pipeline_layout_type> layout) = 0;
    };
 
    template <typename TDerived, typename TRenderPass> requires
        rtti::implements<TRenderPass, RenderPass<typename TRenderPass::render_pipeline_type, typename TRenderPass::frame_buffer_type, typename TRenderPass::input_attachment_mapping_type>>
    class RenderPassBuilder : public Builder<TDerived, TRenderPass> {
    public:
        using Builder<TDerived, TRenderPass>::Builder;
        using render_pass_type = TRenderPass;
        using input_attachment_mapping_type = render_pass_type::input_attachment_mapping_type;
 
    public:
        virtual TDerived& commandBuffers(const UInt32& count) = 0;
 
        virtual TDerived& multiSamplingLevel(const MultiSamplingLevel& samples) = 0;
 
        virtual TDerived& 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) = 0;
 
        virtual TDerived& 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) = 0;
 
        virtual TDerived& 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) = 0;
 
        virtual TDerived& 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) = 0;
 
        virtual TDerived& renderTarget(input_attachment_mapping_type& 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) = 0;
 
        virtual TDerived& renderTarget(const String& name, input_attachment_mapping_type& 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) = 0;
 
        virtual TDerived& renderTarget(input_attachment_mapping_type& 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) = 0;
 
        virtual TDerived& renderTarget(const String& name, input_attachment_mapping_type& 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) = 0;
        
        virtual TDerived& inputAttachment(const input_attachment_mapping_type& inputAttachment) = 0;
 
        virtual TDerived& inputAttachment(const UInt32& inputLocation, const render_pass_type& renderPass, const UInt32& outputLocation) = 0;
 
        virtual TDerived& inputAttachment(const UInt32& inputLocation, const render_pass_type& renderPass, const RenderTarget& renderTarget) = 0;
    };
}
#endif // defined(BUILD_DEFINE_BUILDERS)