rendering_builders.hpp

#pragma once
 
#include "rendering_api.hpp"
#include "rendering.hpp"
 
#if defined(LITEFX_BUILD_DEFINE_BUILDERS)
namespace LiteFX::Rendering {
 
    template <typename TBarrier> requires
        meta::implements<TBarrier, Barrier<typename TBarrier::buffer_type, typename TBarrier::image_type>>
    class BarrierBuilder : public Builder<TBarrier> {
    public:
        template <typename TParent> requires
            meta::implements<TParent, BarrierBuilder<TBarrier>>
        struct [[nodiscard]] ImageBarrierBuilder;
 
        template <typename TParent> requires
            meta::implements<TParent, BarrierBuilder<TBarrier>>
        struct [[nodiscard]] SecondStageBuilder {
        private:
            TParent m_parent;
            PipelineStage m_from;
 
            constexpr SecondStageBuilder(TParent&& parent, PipelineStage waitFor) noexcept :
                m_parent(std::move(parent)), m_from(waitFor) { }
 
        public:
            friend class BarrierBuilder;
 
            constexpr auto toContinueWith(PipelineStage stage) -> TParent {
                this->m_parent.stagesCallback(this->m_from, stage);
                return std::move(this->m_parent);
            }
        };
 
        template <typename TParent> requires
            meta::implements<TParent, BarrierBuilder<TBarrier>>
        struct [[nodiscard]] GlobalBarrierBuilder {
        private:
            ResourceAccess m_access;
            TParent m_parent;
 
            constexpr GlobalBarrierBuilder(TParent&& parent, ResourceAccess access) noexcept :
                m_parent(std::move(parent)), m_access(access) { }
 
        public:
            friend class BarrierBuilder;
 
            constexpr auto untilFinishedWith(ResourceAccess access) -> TParent {
                this->m_parent.globalBarrierCallback(access, m_access);
                return std::move(this->m_parent);
            }
        };
 
        template <typename TParent> requires
            meta::implements<TParent, BarrierBuilder<TBarrier>>
        struct [[nodiscard]] BufferBarrierBuilder {
        private:
            ResourceAccess m_access;
            SharedPtr<IBuffer> m_buffer;
            TParent m_parent;
 
            constexpr BufferBarrierBuilder(TParent&& parent, IBuffer& buffer, ResourceAccess access) noexcept :
                m_parent(std::move(parent)), m_buffer(buffer.shared_from_this()), m_access(access) { }
 
        public:
            friend class BarrierBuilder;
 
            constexpr auto untilFinishedWith(ResourceAccess access) -> TParent {
                this->m_parent.bufferBarrierCallback(*m_buffer, access, m_access);
                return std::move(this->m_parent);
            }
        };
 
        template <typename TParent> requires
            meta::implements<TParent, BarrierBuilder<TBarrier>>
        struct [[nodiscard]] ImageLayoutBarrierBuilder {
        private:
            TParent m_parent;
            ResourceAccess m_access;
            SharedPtr<IImage> m_image;
            ImageLayout m_layout;
            UInt32 m_level{ 0 }, m_levels{ 1 }, m_layer{ 0 }, m_layers{ 1 }, m_plane{ 0 };
 
            constexpr ImageLayoutBarrierBuilder(TParent&& parent, IImage& image, ResourceAccess access, ImageLayout layout, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane) noexcept :
                m_parent(std::move(parent)), m_access(access), m_image(image.shared_from_this()), m_layout(layout), m_level(level), m_levels(levels), m_layer(layer), m_layers(layers), m_plane(plane) { }
 
        public:
            friend class BarrierBuilder;
            friend struct ImageBarrierBuilder<TParent>;
 
            constexpr auto whenFinishedWith(ResourceAccess access) -> TParent {
                this->m_parent.imageBarrierCallback(*m_image, access, m_access, m_layout, m_level, m_levels, m_layer, m_layers, m_plane);
                return std::move(this->m_parent);
            }
        };
 
        template <typename TParent> requires
            meta::implements<TParent, BarrierBuilder<TBarrier>>
        struct [[nodiscard]] ImageBarrierBuilder {
        private:
            TParent m_parent;
            ResourceAccess m_access;
            SharedPtr<IImage> m_image;
            UInt32 m_level{ 0 }, m_levels{ 0 }, m_layer{ 0 }, m_layers{ 0 }, m_plane{ 0 };
 
            constexpr ImageBarrierBuilder(TParent&& parent, IImage& image, ResourceAccess access) noexcept :
                m_parent(std::move(parent)), m_access(access), m_image(image.shared_from_this()) { }
 
        public:
            friend class BarrierBuilder;
 
            constexpr auto transitionLayout(ImageLayout layout) -> ImageLayoutBarrierBuilder<TParent> {
                return ImageLayoutBarrierBuilder<TParent>{ std::move(m_parent), *m_image, m_access, layout, m_level, m_levels, m_layer, m_layers, m_plane };
            }
 
            constexpr auto subresource(UInt32 level, UInt32 levels, UInt32 layer = 0, UInt32 layers = 1, UInt32 plane = 0) -> ImageBarrierBuilder<TParent>& {
                m_level = level;
                m_levels = levels;
                m_layer = layer;
                m_layers = layers;
                m_plane = plane;
 
                return *this;
            };
        };
 
    private:
        constexpr void stagesCallback(PipelineStage waitFor, PipelineStage continueWith) {
            this->setupStages(waitFor, continueWith);
        }
 
        constexpr void globalBarrierCallback(ResourceAccess before, ResourceAccess after) {
            this->setupGlobalBarrier(before, after);
        }
 
        constexpr void bufferBarrierCallback(IBuffer& buffer, ResourceAccess before, ResourceAccess after) {
            this->setupBufferBarrier(buffer, before, after);
        }
 
        constexpr void imageBarrierCallback(IImage& image, ResourceAccess before, ResourceAccess after, ImageLayout layout, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane) {
            this->setupImageBarrier(image, before, after, layout, level, levels, layer, layers, plane);
        }
 
    protected:
        constexpr virtual void setupStages(PipelineStage waitFor, PipelineStage continueWith) = 0;
 
        constexpr virtual void setupGlobalBarrier(ResourceAccess before, ResourceAccess after) = 0;
 
        constexpr virtual void setupBufferBarrier(IBuffer& buffer, ResourceAccess before, ResourceAccess after) = 0;
 
        constexpr virtual void setupImageBarrier(IImage& image, ResourceAccess before, ResourceAccess after, ImageLayout layout, UInt32 level, UInt32 levels, UInt32 layer, UInt32 layers, UInt32 plane) = 0;
 
    public:
        using Builder<TBarrier>::Builder;
        using barrier_type = TBarrier;
 
    public:
        template <typename TSelf>
        [[nodiscard]] constexpr auto waitFor(this TSelf&& self, PipelineStage stage) -> SecondStageBuilder<TSelf> {
            return SecondStageBuilder<TSelf>{ std::forward<TSelf>(self), stage };
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto blockAccessTo(this TSelf&& self, ResourceAccess access) -> GlobalBarrierBuilder<TSelf> {
            return GlobalBarrierBuilder<TSelf>{ std::forward<TSelf>(self), access };
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto blockAccessTo(this TSelf&& self, IBuffer& buffer, ResourceAccess access) -> BufferBarrierBuilder<TSelf> {
            return BufferBarrierBuilder<TSelf>{ std::forward<TSelf>(self), buffer, access };
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto blockAccessTo(this TSelf&& self, IBuffer& buffer, UInt32 subresource, ResourceAccess access) -> BufferBarrierBuilder<TSelf> {
            return BufferBarrierBuilder<TSelf>{ std::forward<TSelf>(self), buffer, subresource, access };
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto blockAccessTo(this TSelf&& self, IImage& image, ResourceAccess access) -> ImageBarrierBuilder<TSelf> {
            return ImageBarrierBuilder<TSelf>{ std::forward<TSelf>(self), image, access };
        }
    };
 
    template <typename TShaderProgram> requires
        meta::implements<TShaderProgram, ShaderProgram<typename TShaderProgram::shader_module_type>>
    class ShaderProgramBuilder : public Builder<TShaderProgram, std::nullptr_t, SharedPtr<TShaderProgram>> {
    public:
        using Builder<TShaderProgram, std::nullptr_t, SharedPtr<TShaderProgram>>::Builder;
        using shader_program_type = TShaderProgram;
        using shader_module_type = shader_program_type::shader_module_type;
 
    private:
        struct ShaderProgramState {
            Array<UniquePtr<shader_module_type>> modules{ };
        } m_state;
 
    protected:
        inline ShaderProgramState& state() noexcept {
            return m_state;
        }
 
        constexpr virtual UniquePtr<shader_module_type> makeShaderModule(ShaderStage type, const String& fileName, const String& entryPoint, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor) = 0;
 
        constexpr virtual UniquePtr<shader_module_type> makeShaderModule(ShaderStage type, std::istream& stream, const String& name, const String& entryPoint, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor) = 0;
 
    public:
        template<typename TSelf>
        [[nodiscard]] constexpr auto withShaderModule(this TSelf&& self, ShaderStage type, const String& fileName, const String& entryPoint = "main", const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt) -> TSelf&& {
            self.m_state.modules.push_back(std::move(static_cast<ShaderProgramBuilder&>(self).makeShaderModule(type, fileName, entryPoint, shaderLocalDescriptor)));
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withShaderModule(this TSelf&& self, ShaderStage type, std::istream& stream, const String& name, const String& entryPoint = "main", const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt) -> TSelf&& {
            self.m_state.modules.push_back(std::move(static_cast<ShaderProgramBuilder&>(self).makeShaderModule(type, stream, name, entryPoint, shaderLocalDescriptor)));
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withVertexShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Vertex, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withVertexShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Vertex, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withTaskShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Task, fileName, entryPoint);
        }
        template<typename TSelf>
        [[nodiscard]] constexpr auto withTaskShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Task, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withMeshShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Mesh, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withMeshShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Mesh, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withTessellationControlShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::TessellationControl, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withTessellationControlShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::TessellationControl, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withTessellationEvaluationShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::TessellationEvaluation, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withTessellationEvaluationShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::TessellationEvaluation, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withGeometryShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Geometry, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withGeometryShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Geometry, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withFragmentShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Fragment, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withFragmentShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Fragment, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withComputeShaderModule(this TSelf&& self, const String& fileName, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Compute, fileName, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withComputeShaderModule(this TSelf&& self, std::istream& stream, const String& name, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Compute, stream, name, entryPoint);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withRayGenerationShaderModule(this TSelf&& self, const String& fileName, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::RayGeneration, fileName, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withRayGenerationShaderModule(this TSelf&& self, std::istream& stream, const String& name, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::RayGeneration, stream, name, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withMissShaderModule(this TSelf&& self, const String& fileName, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Miss, fileName, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withMissShaderModule(this TSelf&& self, std::istream& stream, const String& name, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Miss, stream, name, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withCallableShaderModule(this TSelf&& self, const String& fileName, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Callable, fileName, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withCallableShaderModule(this TSelf&& self, std::istream& stream, const String& name, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Callable, stream, name, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withIntersectionShaderModule(this TSelf&& self, const String& fileName, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Intersection, fileName, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withIntersectionShaderModule(this TSelf&& self, std::istream& stream, const String& name, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::Intersection, stream, name, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withAnyHitShaderModule(this TSelf&& self, const String& fileName, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::AnyHit, fileName, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withAnyHitShaderModule(this TSelf&& self, std::istream& stream, const String& name, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::AnyHit, stream, name, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withClosestHitShaderModule(this TSelf&& self, const String& fileName, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::ClosestHit, fileName, entryPoint, shaderLocalDescriptor);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto withClosestHitShaderModule(this TSelf&& self, std::istream& stream, const String& name, const Optional<DescriptorBindingPoint>& shaderLocalDescriptor = std::nullopt, const String& entryPoint = "main") -> TSelf&& {
            return std::forward<TSelf>(self).withShaderModule(ShaderStage::ClosestHit, stream, name, entryPoint, shaderLocalDescriptor);
        }
    };
 
    template <typename TRasterizer> requires
        meta::implements<TRasterizer, IRasterizer>
    class RasterizerBuilder : public Builder<TRasterizer, std::nullptr_t, SharedPtr<TRasterizer>> {
    public:
        using Builder<TRasterizer, std::nullptr_t, SharedPtr<TRasterizer>>::Builder;
        using rasterizer_type = TRasterizer;
 
    private:
        struct RasterizerState {
            PolygonMode polygonMode{ PolygonMode::Solid };
 
            CullMode cullMode{ CullMode::BackFaces };
 
            CullOrder cullOrder{ CullOrder::ClockWise };
 
            Float lineWidth{ 1.0f };
 
            DepthStencilState::DepthBias depthBias{ };
 
            DepthStencilState::DepthState depthState{ };
 
            DepthStencilState::StencilState stencilState{ };
        } m_state;
 
    protected:
        inline RasterizerState& state() noexcept {
            return m_state;
        }
 
    public:
        template<typename TSelf>
        [[nodiscard]] constexpr auto polygonMode(this TSelf&& self, PolygonMode mode) noexcept -> TSelf&& {
            self.m_state.polygonMode = mode;
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto cullMode(this TSelf&& self, CullMode mode) noexcept -> TSelf&& {
            self.m_state.cullMode = mode;
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto cullOrder(this TSelf&& self, CullOrder order) noexcept -> TSelf&& {
            self.m_state.cullOrder = order;
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto lineWidth(this TSelf&& self, Float width) noexcept -> TSelf&& {
            self.m_state.lineWidth = width;
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto depthBias(this TSelf&& self, const DepthStencilState::DepthBias& depthBias) noexcept -> TSelf&& {
            self.m_state.depthBias = depthBias;
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto depthState(this TSelf&& self, const DepthStencilState::DepthState& depthState) noexcept -> TSelf&& {
            self.m_state.depthState = depthState;
            return std::forward<TSelf>(self);
        }
 
        template<typename TSelf>
        [[nodiscard]] constexpr auto stencilState(this TSelf&& self, const DepthStencilState::StencilState& stencilState) noexcept -> TSelf&& {
            self.m_state.stencilState = stencilState;
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TVertexBufferLayout, typename TParent> requires
        meta::implements<TVertexBufferLayout, IVertexBufferLayout>
    class VertexBufferLayoutBuilder : public Builder<TVertexBufferLayout, TParent, SharedPtr<TVertexBufferLayout>> {
    public:
        using Builder<TVertexBufferLayout, TParent, SharedPtr<TVertexBufferLayout>>::Builder;
        using vertex_buffer_layout_type = TVertexBufferLayout;
 
    private:
        struct VertexBufferLayoutState {
            Array<BufferAttribute> attributes{ };
        } m_state;
 
    protected:
        inline VertexBufferLayoutState& state() noexcept {
            return m_state;
        }
 
    public:
        template <typename TSelf>
        [[nodiscard]] constexpr auto withAttribute(this TSelf&& self, BufferAttribute&& attribute) -> TSelf&& {
            self.m_state.attributes.push_back(std::move(attribute));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withAttribute(this TSelf&& self, BufferFormat format, UInt32 offset, AttributeSemantic semantic = AttributeSemantic::Unknown, UInt32 semanticIndex = 0) -> TSelf&& {
            return std::forward<TSelf>(self).withAttribute({ static_cast<UInt32>(self.m_state.attributes.size()), offset, format, semantic, semanticIndex });
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withAttribute(this TSelf&& self, UInt32 location, BufferFormat format, UInt32 offset, AttributeSemantic semantic = AttributeSemantic::Unknown, UInt32 semanticIndex = 0) -> TSelf&& {
            return std::forward<TSelf>(self).withAttribute({ location, offset, format, semantic, semanticIndex });
        }
    };
 
    template <typename TDescriptorSetLayout, typename TParent> requires
        meta::implements<TDescriptorSetLayout, DescriptorSetLayout<typename TDescriptorSetLayout::descriptor_layout_type, typename TDescriptorSetLayout::descriptor_set_type>>
    class DescriptorSetLayoutBuilder : public Builder<TDescriptorSetLayout, TParent, SharedPtr<TDescriptorSetLayout>> {
    public:
        using Builder<TDescriptorSetLayout, TParent, SharedPtr<TDescriptorSetLayout>>::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;
 
    private:
        struct DescriptorSetLayoutState {
            UInt32 space{};
            
            ShaderStage stages{};
 
            Array<descriptor_layout_type> descriptorLayouts{};
        } m_state;
 
    protected:
        inline DescriptorSetLayoutState& state() noexcept {
            return m_state;
        }
 
        constexpr virtual descriptor_layout_type makeDescriptor(DescriptorType type, UInt32 binding, UInt32 descriptorSize, UInt32 descriptors) = 0;
 
        constexpr virtual descriptor_layout_type makeDescriptor(UInt32 binding, FilterMode magFilter, FilterMode minFilter, BorderMode borderU, BorderMode borderV, BorderMode borderW, MipMapMode mipMapMode, Float mipMapBias, Float minLod, Float maxLod, Float anisotropy) = 0;
 
    public:
        template <typename TSelf>
        [[nodiscard]] constexpr auto withDescriptor(this TSelf&& self, descriptor_layout_type&& layout) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(layout));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withDescriptor(this TSelf&& self, DescriptorType type, UInt32 binding, UInt32 descriptorSize, UInt32 descriptors = 1) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(type, binding, descriptorSize, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withStaticSampler(this TSelf&& self, UInt32 binding, 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 minLod = 0.f, Float maxLod = std::numeric_limits<Float>::max(), Float anisotropy = 0.f) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(binding, magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, minLod, maxLod, anisotropy)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withConstantBuffer(this TSelf&& self, UInt32 binding, UInt32 descriptorSize, UInt32 descriptors = 1) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(DescriptorType::ConstantBuffer, binding, descriptorSize, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withBuffer(this TSelf&& self, UInt32 binding, UInt32 descriptors = 1, bool writable = false) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(writable ? DescriptorType::RWBuffer : DescriptorType::Buffer, binding, 0, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withStructuredBuffer(this TSelf&& self, UInt32 binding, UInt32 descriptors = 1, bool writable = false) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(writable ? DescriptorType::RWStructuredBuffer : DescriptorType::StructuredBuffer, binding, 0, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withByteAddressBuffer(this TSelf&& self, UInt32 binding, UInt32 descriptors = 1, bool writable = false) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(writable ? DescriptorType::RWByteAddressBuffer : DescriptorType::ByteAddressBuffer, binding, 0, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withTexture(this TSelf&& self, UInt32 binding, UInt32 descriptors = 1, bool writable = false) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(writable ? DescriptorType::RWTexture : DescriptorType::Texture, binding, 0, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withInputAttachment(this TSelf&& self, UInt32 binding) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(DescriptorType::InputAttachment, binding, 0)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withAccelerationStructure(this TSelf&& self, UInt32 binding) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(DescriptorType::AccelerationStructure, binding, 0)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        [[nodiscard]] constexpr auto withSampler(this TSelf&& self, UInt32 binding, UInt32 descriptors = 1) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(static_cast<DescriptorSetLayoutBuilder&>(self).makeDescriptor(DescriptorType::Sampler, binding, 0, descriptors)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto space(this TSelf&& self, UInt32 space) noexcept -> TSelf&& {
            self.m_state.space = space;
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto shaderStages(this TSelf&& self, ShaderStage stages) noexcept -> TSelf&& {
            self.m_state.stages = stages;
            return std::forward<TSelf>(self);
        }
 
    public:
        template <typename TSelf>
        [[nodiscard]] constexpr auto use(this TSelf&& self, UniquePtr<descriptor_layout_type>&& layout) -> TSelf&& {
            self.m_state.descriptorLayouts.push_back(std::move(layout));
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TPushConstantsLayout, typename TParent> requires
        meta::implements<TPushConstantsLayout, PushConstantsLayout<typename TPushConstantsLayout::push_constants_range_type>>
    class PushConstantsLayoutBuilder : public Builder<TPushConstantsLayout, TParent> {
    public:
        using Builder<TPushConstantsLayout, TParent>::Builder;
        using push_constants_layout_type = TPushConstantsLayout;
        using push_constants_range_type = push_constants_layout_type::push_constants_range_type;
 
    private:
        struct PushConstantsLayoutState {
            Array<UniquePtr<push_constants_range_type>> ranges{ };
        } m_state;
 
    protected:
        inline PushConstantsLayoutState& state() noexcept {
            return m_state;
        }
 
        virtual UniquePtr<push_constants_range_type> makeRange(ShaderStage shaderStages, UInt32 offset, UInt32 size, UInt32 space, UInt32 binding) = 0;
 
    public:
        template <typename TSelf>
        constexpr auto withRange(this TSelf&& self, ShaderStage shaderStages, UInt32 offset, UInt32 size, UInt32 space, UInt32 binding) -> TSelf&& {
            self.m_state.ranges.push_back(std::move(static_cast<PushConstantsLayoutBuilder&>(self).makeRange(shaderStages, offset, size, space, binding)));
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TPipelineLayout> requires
        meta::implements<TPipelineLayout, PipelineLayout<typename TPipelineLayout::descriptor_set_layout_type, typename TPipelineLayout::push_constants_layout_type>>
    class PipelineLayoutBuilder : public Builder<TPipelineLayout, std::nullptr_t, SharedPtr<TPipelineLayout>> {
    public:
        using Builder<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;
 
    private:
        struct PipelineLayoutState {
            Array<SharedPtr<descriptor_set_layout_type>> descriptorSetLayouts{ };
 
            UniquePtr<push_constants_layout_type> pushConstantsLayout{ };
        } m_state;
 
    protected:
        inline PipelineLayoutState& state() noexcept {
            return m_state;
        }
 
    public:
        template <typename TSelf>
        constexpr auto use(this TSelf&& self, SharedPtr<descriptor_set_layout_type>&& layout) -> TSelf&& {
            self.m_state.descriptorSetLayouts.push_back(std::move(layout));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto use(this TSelf&& self, UniquePtr<push_constants_layout_type>&& layout) -> TSelf&& {
            self.m_state.pushConstantsLayout = std::move(layout);
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TInputAssembler> requires
        meta::implements<TInputAssembler, InputAssembler<typename TInputAssembler::vertex_buffer_layout_type, typename TInputAssembler::index_buffer_layout_type>>
    class InputAssemblerBuilder : public Builder<TInputAssembler, std::nullptr_t, SharedPtr<TInputAssembler>> {
    public:
        using Builder<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;
 
    private:
        struct InputAssemblerState {
            PrimitiveTopology topology{};
 
            Array<SharedPtr<vertex_buffer_layout_type>> vertexBufferLayouts{};
            
            SharedPtr<index_buffer_layout_type> indexBufferLayout{};
        } m_state;
 
    protected:
        inline InputAssemblerState& state() noexcept {
            return m_state;
        }
 
    public:
        template <typename TSelf>
        constexpr auto topology(this TSelf&& self, PrimitiveTopology topology) -> TSelf&& {
            self.m_state.topology = topology;
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto use(this TSelf&& self, SharedPtr<vertex_buffer_layout_type>&& layout) -> TSelf&& {
            self.m_state.vertexBufferLayouts.push_back(std::move(layout));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto use(this TSelf&& self, SharedPtr<index_buffer_layout_type>&& layout) -> TSelf&& {
            self.m_state.indexBufferLayout = std::move(layout);
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TRenderPipeline> requires
        meta::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<TRenderPipeline> {
    public:
        using Builder<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;
 
    private:
        struct RenderPipelineState {
            SharedPtr<shader_program_type> shaderProgram{ };
 
            SharedPtr<pipeline_layout_type> pipelineLayout{ };
 
            SharedPtr<rasterizer_type> rasterizer{ };
 
            SharedPtr<input_assembler_type> inputAssembler{ };
 
            bool enableAlphaToCoverage{ false };
 
            MultiSamplingLevel samples { MultiSamplingLevel::x1 };
        } m_state;
 
    protected:
        inline RenderPipelineState& state() noexcept {
            return m_state;
        }
 
    public:
        template <typename TSelf>
        constexpr auto shaderProgram(this TSelf&& self, SharedPtr<shader_program_type> program) -> TSelf&& {
            self.m_state.shaderProgram = std::move(program);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto layout(this TSelf&& self, SharedPtr<pipeline_layout_type> layout) -> TSelf&& {
            self.m_state.pipelineLayout = std::move(layout);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto rasterizer(this TSelf&& self, SharedPtr<rasterizer_type> rasterizer) -> TSelf&& {
            self.m_state.rasterizer = std::move(rasterizer);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto inputAssembler(this TSelf&& self, SharedPtr<input_assembler_type> inputAssembler) -> TSelf&& {
            self.m_state.inputAssembler = std::move(inputAssembler);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto enableAlphaToCoverage(this TSelf&& self, bool enable = true) -> TSelf&& {
            self.m_state.enableAlphaToCoverage = enable;
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto samples(this TSelf&& self, MultiSamplingLevel samples) -> TSelf&& {
            self.m_state.samples = samples;
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TComputePipeline> requires
        meta::implements<TComputePipeline, ComputePipeline<typename TComputePipeline::pipeline_layout_type, typename TComputePipeline::shader_program_type>>
    class ComputePipelineBuilder : public Builder<TComputePipeline> {
    public:
        using Builder<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;
 
    private:
        struct ComputePipelineState {
            SharedPtr<shader_program_type> shaderProgram{ };
 
            SharedPtr<pipeline_layout_type> pipelineLayout{ };
        } m_state;
 
    protected:
        inline ComputePipelineState& state() noexcept {
            return m_state;
        }
 
    public:
        template <typename TSelf>
        constexpr auto shaderProgram(this TSelf&& self, SharedPtr<shader_program_type> program) -> TSelf&& {
            self.m_state.shaderProgram = std::move(program);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto layout(this TSelf&& self, SharedPtr<pipeline_layout_type> layout) -> TSelf&& {
            self.m_state.pipelineLayout = std::move(layout);
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TRayTracingPipeline> requires
        meta::implements<TRayTracingPipeline, RayTracingPipeline<typename TRayTracingPipeline::pipeline_layout_type, typename TRayTracingPipeline::shader_program_type>>
    class RayTracingPipelineBuilder : public Builder<TRayTracingPipeline> {
    public:
        using Builder<TRayTracingPipeline>::Builder;
        using raytracing_pipeline_type = TRayTracingPipeline;
        using pipeline_layout_type = raytracing_pipeline_type::pipeline_layout_type;
        using shader_program_type = raytracing_pipeline_type::shader_program_type;
 
    private:
        struct RayTracingPipelineState {
            SharedPtr<pipeline_layout_type> pipelineLayout { };
 
            UInt32 maxRecursionDepth { 10 }; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
            UInt32 maxPayloadSize { 0 }; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
 
            UInt32 maxAttributeSize { 32 }; // NOLINT(cppcoreguidelines-avoid-magic-numbers)
        } m_state;
 
    protected:
        inline RayTracingPipelineState& state() noexcept {
            return m_state;
        }
 
    public:
        template <typename TSelf>
        constexpr auto layout(this TSelf&& self, SharedPtr<pipeline_layout_type> layout) -> TSelf&& {
            self.m_state.pipelineLayout = std::move(layout);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto maxBounces(this TSelf&& self, UInt32 maxRecursionDepth) -> TSelf&& {
            self.m_state.maxRecursionDepth = maxRecursionDepth;
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto maxPayloadSize(this TSelf&& self, UInt32 maxPayloadSize) -> TSelf&& {
            self.m_state.maxPayloadSize = maxPayloadSize;
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto maxAttributeSize(this TSelf&& self, UInt32 maxAttributeSize) -> TSelf&& {
            self.m_state.maxAttributeSize = maxAttributeSize;
            return std::forward<TSelf>(self);
        }
    };
 
    template <typename TRenderPass> requires
        meta::implements<TRenderPass, RenderPass<typename TRenderPass::command_queue_type, typename TRenderPass::frame_buffer_type>>
    class RenderPassBuilder : public Builder<TRenderPass, std::nullptr_t, SharedPtr<TRenderPass>> {
    public:
        using Builder<TRenderPass, std::nullptr_t, SharedPtr<TRenderPass>>::Builder;
        using render_pass_type = TRenderPass;
        using command_queue_type = render_pass_type::command_queue_type;
 
    private:
        struct RenderPassState {
            UInt32 commandBufferCount{ 0 };
 
            Array<RenderTarget> renderTargets{ };
 
            Array<RenderPassDependency> inputAttachments{ };
 
            SharedPtr<const command_queue_type> commandQueue{ nullptr };
 
            Optional<DescriptorBindingPoint> inputAttachmentSamplerBinding{ std::nullopt };
        } m_state;
 
    protected:
        inline RenderPassState& state() noexcept {
            return m_state;
        }
 
        virtual RenderPassDependency makeInputAttachment(DescriptorBindingPoint binding, const RenderTarget& renderTarget) = 0;
 
    public:
        template <typename TSelf>
        constexpr auto executeOn(this TSelf&& self, const command_queue_type& queue) -> TSelf&& {
            self.m_state.commandQueue = queue.shared_from_this();
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto commandBuffers(this TSelf&& self, UInt32 count) -> TSelf&& {
            self.m_state.commandBufferCount = count;
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto renderTarget(this TSelf&& self, RenderTargetType type, Format format, RenderTargetFlags flags = RenderTargetFlags::None, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }) -> TSelf&& {
            self.renderTarget("", static_cast<UInt32>(self.m_state.renderTargets.size()), type, format, flags, clearValues);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto renderTarget(this TSelf&& self, const String& name, RenderTargetType type, Format format, RenderTargetFlags flags = RenderTargetFlags::None, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }) -> TSelf&& {
            self.renderTarget(name, static_cast<UInt32>(self.m_state.renderTargets.size()), type, format, flags, clearValues);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto renderTarget(this TSelf&& self, UInt32 location, RenderTargetType type, Format format, RenderTargetFlags flags = RenderTargetFlags::None, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }) -> TSelf&& {
            self.renderTarget("", location, type, format, flags, clearValues);
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto renderTarget(this TSelf&& self, const String& name, UInt32 location, RenderTargetType type, Format format, RenderTargetFlags flags = RenderTargetFlags::None, const Vector4f& clearValues = { 0.0f, 0.0f, 0.0f, 0.0f }) -> TSelf&& {
            self.m_state.renderTargets.push_back(RenderTarget(name, location, type, format, flags, clearValues));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto inputAttachment(this TSelf&& self, DescriptorBindingPoint binding, const render_pass_type& renderPass, UInt32 outputLocation) -> TSelf&& {
            self.m_state.inputAttachments.push_back(static_cast<RenderPassBuilder&>(self).makeInputAttachment(binding, renderPass.renderTarget(outputLocation)));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        auto inputAttachment(this TSelf&& self, DescriptorBindingPoint binding, RenderTarget renderTarget) -> TSelf&& {
            self.m_state.inputAttachments.push_back(static_cast<RenderPassBuilder&>(self).makeInputAttachment(binding, renderTarget));
            return std::forward<TSelf>(self);
        }
 
        template <typename TSelf>
        constexpr auto inputAttachmentSamplerBinding(this TSelf&& self, const DescriptorBindingPoint& bindingPoint) -> TSelf&& {
            self.m_state.inputAttachmentSamplerBinding = bindingPoint;
            return std::forward<TSelf>(self);
        }
    };
 
}
#endif // defined(LITEFX_BUILD_DEFINE_BUILDERS)