rendering.hpp

#pragma once
 
#include <litefx/rendering_api.hpp>
#include <litefx/rendering_formatters.hpp>
 
namespace LiteFX::Rendering {
    using namespace LiteFX;
    using namespace LiteFX::Math;
 
    template <typename TBuffer, typename TImage> requires
        std::derived_from<TBuffer, IBuffer> &&
        std::derived_from<TImage, IImage>
    class Barrier : public IBarrier {
    public:
        using buffer_type = TBuffer;
        using image_type = TImage;
 
    public:
        virtual ~Barrier() noexcept = default;
 
    public:
        virtual void transition(buffer_type& buffer, const ResourceState& targetState) = 0;
 
        virtual void transition(buffer_type& buffer, const UInt32& element, const ResourceState& targetState) = 0;
 
        virtual void transition(buffer_type& buffer, const ResourceState& sourceState, const ResourceState& targetState) = 0;
 
        virtual void transition(buffer_type& buffer, const ResourceState& sourceState, const UInt32& element, const ResourceState& targetState) = 0;
 
        virtual void transition(image_type& image, const ResourceState& targetState) = 0;
 
        virtual void transition(image_type& image, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) = 0;
 
        virtual void transition(image_type& image, const ResourceState& sourceState, const ResourceState& targetState) = 0;
 
        virtual void transition(image_type& image, const ResourceState& sourceState, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) = 0;
 
        virtual void waitFor(const buffer_type& buffer) = 0;
 
        virtual void waitFor(const image_type& image) = 0;
 
    private:
        virtual void doTransition(IBuffer& buffer, const ResourceState& targetState) override { 
            this->transition(dynamic_cast<buffer_type&>(buffer), targetState);
        }
 
        virtual void doTransition(IBuffer& buffer, const UInt32& element, const ResourceState& targetState) override {
            this->transition(dynamic_cast<buffer_type&>(buffer), element, targetState);
        }
 
        virtual void doTransition(IBuffer& buffer, const ResourceState& sourceState, const ResourceState& targetState) override {
            this->transition(dynamic_cast<buffer_type&>(buffer), sourceState, targetState);
        }
 
        virtual void doTransition(IBuffer& buffer, const ResourceState& sourceState, const UInt32& element, const ResourceState& targetState) override {
            this->transition(dynamic_cast<buffer_type&>(buffer), sourceState, element, targetState);
        }
 
        virtual void doTransition(IImage& image, const ResourceState& targetState) override {
            this->transition(dynamic_cast<image_type&>(image), targetState);
        }
 
        virtual void doTransition(IImage& image, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) override {
            this->transition(dynamic_cast<image_type&>(image), level, layer, plane, targetState);
        }
 
        virtual void doTransition(IImage& image, const ResourceState& sourceState, const ResourceState& targetState) override {
            this->transition(dynamic_cast<image_type&>(image), sourceState, targetState);
        }
 
        virtual void doTransition(IImage& image, const ResourceState& sourceState, const UInt32& level, const UInt32& layer, const UInt32& plane, const ResourceState& targetState) override {
            this->transition(dynamic_cast<image_type&>(image), sourceState, level, layer, plane, targetState);
        }
 
        virtual void doWaitFor(const IBuffer& buffer) override {
            this->waitFor(dynamic_cast<const buffer_type&>(buffer));
        }
 
        virtual void doWaitFor(const IImage& image) override {
            this->waitFor(dynamic_cast<const image_type&>(image));
        }
    };
 
    template <typename TBuffer, typename TImage, typename TSampler> requires
        std::derived_from<TBuffer, IBuffer> &&
        std::derived_from<TSampler, ISampler> &&
        std::derived_from<TImage, IImage>
    class DescriptorSet : public IDescriptorSet {
    public:
        using buffer_type = TBuffer;
        using sampler_type = TSampler;
        using image_type = TImage;
 
    public:
        virtual ~DescriptorSet() noexcept = default;
 
    public:
        virtual void update(const UInt32& binding, const buffer_type& buffer, const UInt32& bufferElement = 0, const UInt32& elements = 1, const UInt32& firstDescriptor = 0) const = 0;
 
        virtual void update(const UInt32& binding, const image_type& texture, const UInt32& descriptor = 0, const UInt32& firstLevel = 0, const UInt32& levels = 0, const UInt32& firstLayer = 0, const UInt32& layers = 0) const = 0;
 
        virtual void update(const UInt32& binding, const sampler_type& sampler, const UInt32& descriptor = 0) const = 0;
 
        virtual void attach(const UInt32& binding, const image_type& image) const = 0;
 
    private:
        virtual void doUpdate(const UInt32& binding, const IBuffer& buffer, const UInt32& bufferElement, const UInt32& elements, const UInt32& firstDescriptor) const override {
            this->update(binding, dynamic_cast<const buffer_type&>(buffer), bufferElement, elements, firstDescriptor);
        }
 
        virtual void doUpdate(const UInt32& binding, const IImage& texture, const UInt32& descriptor, const UInt32& firstLevel, const UInt32& levels, const UInt32& firstLayer, const UInt32& layers) const  override {
            this->update(binding, dynamic_cast<const image_type&>(texture), descriptor, firstLevel, levels, firstLayer, layers);
        }
 
        virtual void doUpdate(const UInt32& binding, const ISampler& sampler, const UInt32& descriptor) const  override {
            this->update(binding, dynamic_cast<const sampler_type&>(sampler), descriptor);
        }
 
        virtual void doAttach(const UInt32& binding, const IImage& image) const  override {
            this->attach(binding, dynamic_cast<const image_type&>(image));
        }
    };
 
    template <typename TDescriptorLayout, typename TDescriptorSet> requires
        rtti::implements<TDescriptorLayout, IDescriptorLayout> &&
        rtti::implements<TDescriptorSet, DescriptorSet<typename TDescriptorSet::buffer_type, typename TDescriptorSet::image_type, typename TDescriptorSet::sampler_type>>
    class DescriptorSetLayout : public IDescriptorSetLayout {
    public:
        using descriptor_layout_type = TDescriptorLayout;
        using descriptor_set_type = TDescriptorSet;
 
    public:
        virtual ~DescriptorSetLayout() noexcept = default;
 
    public:
        virtual Array<const descriptor_layout_type*> descriptors() const noexcept = 0;
 
        virtual const descriptor_layout_type& descriptor(const UInt32& binding) const = 0;
 
        virtual UniquePtr<descriptor_set_type> allocate(const UInt32& descriptors = 0) const = 0;
 
        virtual Array<UniquePtr<descriptor_set_type>> allocateMultiple(const UInt32& descriptorSets, const UInt32& descriptors = 0) const = 0;
 
        virtual void free(const descriptor_set_type& descriptorSet) const noexcept = 0;
 
    private:
        virtual Array<const IDescriptorLayout*> getDescriptors() const noexcept override {
            auto descriptors = this->descriptors();
            return Array<const IDescriptorLayout*>(descriptors.begin(), descriptors.end());
        }
 
        virtual UniquePtr<IDescriptorSet> getDescriptorSet(const UInt32& descriptors) const override {
            return this->allocate(descriptors);
        }
 
        virtual Array<UniquePtr<IDescriptorSet>> getDescriptorSets(const UInt32& descriptorSets, const UInt32& descriptors) const override {
            auto sets = this->allocateMultiple(descriptorSets, descriptors);
            Array<UniquePtr<IDescriptorSet>> results;
            results.reserve(sets.size());
            std::move(sets.begin(), sets.end(), std::inserter(results, results.end()));
            return results;
        }
 
        virtual void releaseDescriptorSet(const IDescriptorSet& descriptorSet) const noexcept override {
            this->releaseDescriptorSet(dynamic_cast<const descriptor_set_type&>(descriptorSet));
        }
    };
 
    template <typename TPushConstantsRange> requires
        rtti::implements<TPushConstantsRange, IPushConstantsRange>
    class PushConstantsLayout : public IPushConstantsLayout {
    public:
        using push_constants_range_type = TPushConstantsRange;
 
    public:
        virtual ~PushConstantsLayout() noexcept = default;
 
    public:
        virtual Array<const push_constants_range_type*> ranges() const noexcept = 0;
 
    private:
        virtual Array<const IPushConstantsRange*> getRanges() const noexcept override {
            auto ranges = this->ranges();
            return Array<const IPushConstantsRange*>(ranges.begin(), ranges.end());
        }
    };
 
    template <typename TShaderModule> requires
        rtti::implements<TShaderModule, IShaderModule>
    class ShaderProgram : public IShaderProgram {
    public:
        using shader_module_type = TShaderModule;
 
    public:
        virtual ~ShaderProgram() noexcept = default;
 
    public:
        virtual Array<const shader_module_type*> modules() const noexcept = 0;
 
    private:
        virtual Array<const IShaderModule*> getModules() const noexcept {
            auto modules = this->modules();
            return Array<const IShaderModule*>(modules.begin(), modules.end());
        }
    };
    
    template <typename TDescriptorSetLayout, typename TPushConstantsLayout> requires
        rtti::implements<TDescriptorSetLayout, DescriptorSetLayout<typename TDescriptorSetLayout::descriptor_layout_type, typename TDescriptorSetLayout::descriptor_set_type>> &&
        rtti::implements<TPushConstantsLayout, PushConstantsLayout<typename TPushConstantsLayout::push_constants_range_type>>
    class PipelineLayout : public IPipelineLayout {
    public:
        using descriptor_set_layout_type = TDescriptorSetLayout;
        using push_constants_layout_type = TPushConstantsLayout;
 
    public:
        virtual ~PipelineLayout() noexcept = default;
 
    public:
        virtual const descriptor_set_layout_type& descriptorSet(const UInt32& space) const = 0;
 
        virtual Array<const descriptor_set_layout_type*> descriptorSets() const noexcept = 0;
 
        virtual const push_constants_layout_type* pushConstants() const noexcept = 0;
 
    private:
        virtual Array<const IDescriptorSetLayout*> getDescriptorSets() const noexcept override {
            auto layouts = this->descriptorSets();
            return Array<const IDescriptorSetLayout*>(layouts.begin(), layouts.end());
        }
    };
 
    template <typename TVertexBufferLayout> requires
        rtti::implements<TVertexBufferLayout, IVertexBufferLayout>
    class VertexBuffer : public virtual IVertexBuffer {
    public:
        using vertex_buffer_layout_type = TVertexBufferLayout;
 
    public:
        virtual ~VertexBuffer() noexcept = default;
 
    public:
        virtual const vertex_buffer_layout_type& layout() const noexcept = 0;
    };
 
    template <typename TIndexBufferLayout> requires
        rtti::implements<TIndexBufferLayout, IIndexBufferLayout>
    class IndexBuffer : public virtual IIndexBuffer {
    public:
        using index_buffer_layout_type = TIndexBufferLayout;
 
    public:
        virtual ~IndexBuffer() noexcept = default;
 
    public:
        virtual const index_buffer_layout_type& layout() const noexcept = 0;
    };
 
    template <typename TVertexBufferLayout, typename TIndexBufferLayout> requires
        rtti::implements<TVertexBufferLayout, IVertexBufferLayout> &&
        rtti::implements<TIndexBufferLayout, IIndexBufferLayout>
    class InputAssembler : public IInputAssembler {
    public:
        using vertex_buffer_layout_type = TVertexBufferLayout;
        using index_buffer_layout_type = TIndexBufferLayout;
 
    public:
        virtual ~InputAssembler() noexcept = default;
 
    public:
        virtual Array<const vertex_buffer_layout_type*> vertexBufferLayouts() const noexcept = 0;
 
        virtual const vertex_buffer_layout_type& vertexBufferLayout(const UInt32& binding) const = 0;
 
        virtual const index_buffer_layout_type& indexBufferLayout() const = 0;
 
    private:
        virtual Array<const IVertexBufferLayout*> getVertexBufferLayouts() const noexcept override {
            auto layouts = this->vertexBufferLayouts();
            return Array<const IVertexBufferLayout*>(layouts.begin(), layouts.end());
        }
    };
 
    template <typename TPipelineLayout, typename TShaderProgram> requires
        rtti::implements<TPipelineLayout, PipelineLayout<typename TPipelineLayout::descriptor_set_layout_type, typename TPipelineLayout::push_constants_layout_type>> &&
        rtti::implements<TShaderProgram, ShaderProgram<typename TShaderProgram::shader_module_type>>
    class Pipeline : public virtual IPipeline, public virtual StateResource {
    public:
        using shader_program_type = TShaderProgram;
        using pipeline_layout_type = TPipelineLayout;
 
    public:
        virtual ~Pipeline() noexcept = default;
 
    public:
        virtual SharedPtr<const shader_program_type> program() const noexcept = 0;
 
        virtual SharedPtr<const pipeline_layout_type> layout() const noexcept = 0;
 
    private:
        virtual SharedPtr<const IShaderProgram> getProgram() const noexcept override {
            return std::static_pointer_cast<const IShaderProgram>(this->program());
        }
 
        virtual SharedPtr<const IPipelineLayout> getLayout() const noexcept override {
            return std::static_pointer_cast<const IPipelineLayout>(this->layout());
        }
    };
 
    template <typename TBuffer, typename TVertexBuffer, typename TIndexBuffer, typename TImage, typename TBarrier, typename TPipeline> requires
        rtti::implements<TBarrier, Barrier<TBuffer, TImage>> &&
        std::derived_from<TPipeline, Pipeline<typename TPipeline::pipeline_layout_type, typename TPipeline::shader_program_type>>
    class CommandBuffer : public ICommandBuffer {
        using ICommandBuffer::begin;
        using ICommandBuffer::end;
        using ICommandBuffer::dispatch;
        using ICommandBuffer::draw;
        using ICommandBuffer::drawIndexed;
 
    public:
        using buffer_type = TBuffer;
        using vertex_buffer_type = TVertexBuffer;
        using index_buffer_type = TIndexBuffer;
        using image_type = TImage;
        using barrier_type = TBarrier;
        using pipeline_type = TPipeline;
        using pipeline_layout_type = pipeline_type::pipeline_layout_type;
        using descriptor_set_layout_type = pipeline_layout_type::descriptor_set_layout_type;
        using push_constants_layout_type = pipeline_layout_type::push_constants_layout_type;
        using descriptor_set_type = descriptor_set_layout_type::descriptor_set_type;
 
    public:
        virtual ~CommandBuffer() noexcept = default;
 
    public:
        virtual void barrier(const barrier_type& barrier, const bool& invert = false) const noexcept = 0;
 
        virtual void generateMipMaps(image_type& image) noexcept = 0;
 
        virtual void transfer(const buffer_type& source, const buffer_type& target, const UInt32& sourceElement = 0, const UInt32& targetElement = 0, const UInt32& elements = 1) const = 0;
 
        virtual void transfer(const buffer_type& source, const image_type& target, const UInt32& sourceElement = 0, const UInt32& firstSubresource = 0, const UInt32& elements = 1) const = 0;
 
        virtual void transfer(const image_type& source, const image_type& target, const UInt32& sourceSubresource = 0, const UInt32& targetSubresource = 0, const UInt32& subresources = 1) const = 0;
 
        virtual void transfer(const image_type& source, const buffer_type& target, const UInt32& firstSubresource = 0, const UInt32& targetElement = 0, const UInt32& subresources = 1) const = 0;
 
        virtual void use(const pipeline_type& pipeline) const noexcept = 0;
 
        virtual void bind(const descriptor_set_type& descriptorSet, const pipeline_type& pipeline) const noexcept = 0;
 
        virtual void bind(const vertex_buffer_type& buffer) const noexcept = 0;
 
        virtual void bind(const index_buffer_type& buffer) const noexcept = 0;
 
        virtual void pushConstants(const push_constants_layout_type& layout, const void* const memory) const noexcept = 0;
 
        virtual void draw(const vertex_buffer_type& vertexBuffer, const UInt32& instances = 1, const UInt32& firstVertex = 0, const UInt32& firstInstance = 0) const {
            this->bind(vertexBuffer);
            this->draw(vertexBuffer.elements(), instances, firstVertex, firstInstance);
        }
 
        virtual void drawIndexed(const index_buffer_type& indexBuffer, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const {
            this->bind(indexBuffer);
            this->drawIndexed(indexBuffer.elements(), instances, firstIndex, vertexOffset, firstInstance);
        }
 
        virtual void drawIndexed(const vertex_buffer_type& vertexBuffer, const index_buffer_type& indexBuffer, const UInt32& instances = 1, const UInt32& firstIndex = 0, const Int32& vertexOffset = 0, const UInt32& firstInstance = 0) const {
            this->bind(vertexBuffer);
            this->bind(indexBuffer);
            this->drawIndexed(indexBuffer.elements(), instances, firstIndex, vertexOffset, firstInstance);
        }
 
    private:
        virtual void cmdBarrier(const IBarrier& barrier, const bool& invert) const noexcept override { 
            this->barrier(dynamic_cast<const barrier_type&>(barrier), invert);
        }
 
        virtual void cmdGenerateMipMaps(IImage& image) noexcept override { 
            this->generateMipMaps(dynamic_cast<image_type&>(image));
        }
 
        virtual void cmdTransfer(const IBuffer& source, const IBuffer& target, const UInt32& sourceElement, const UInt32& targetElement, const UInt32& elements) const override { 
            this->transfer(dynamic_cast<const buffer_type&>(source), dynamic_cast<const buffer_type&>(target), sourceElement, targetElement, elements);
        }
        
        virtual void cmdTransfer(const IBuffer& source, const IImage& target, const UInt32& sourceElement, const UInt32& firstSubresource, const UInt32& elements) const override { 
            this->transfer(dynamic_cast<const buffer_type&>(source), dynamic_cast<const image_type&>(target), sourceElement, firstSubresource, elements);
        }
        
        virtual void cmdTransfer(const IImage& source, const IImage& target, const UInt32& sourceSubresource, const UInt32& targetSubresource, const UInt32& subresources) const override {
            this->transfer(dynamic_cast<const image_type&>(source), dynamic_cast<const image_type&>(target), sourceSubresource, targetSubresource, subresources);
        }
 
        virtual void cmdTransfer(const IImage& source, const IBuffer& target, const UInt32& firstSubresource, const UInt32& targetElement, const UInt32& subresources) const override {
            this->transfer(dynamic_cast<const image_type&>(source), dynamic_cast<const buffer_type&>(target), firstSubresource, targetElement, subresources);
        }
 
        virtual void cmdUse(const IPipeline& pipeline) const noexcept override { 
            this->use(dynamic_cast<const pipeline_type&>(pipeline));
        }
 
        virtual void cmdBind(const IDescriptorSet& descriptorSet, const IPipeline& pipeline) const noexcept override { 
            this->bind(dynamic_cast<const descriptor_set_type&>(descriptorSet), dynamic_cast<const pipeline_type&>(pipeline));
        }
        
        virtual void cmdBind(const IVertexBuffer& buffer) const noexcept override { 
            this->bind(dynamic_cast<const vertex_buffer_type&>(buffer));
        }
 
        virtual void cmdBind(const IIndexBuffer& buffer) const noexcept override { 
            this->bind(dynamic_cast<const index_buffer_type&>(buffer));
        }
        
        virtual void cmdPushConstants(const IPushConstantsLayout& layout, const void* const memory) const noexcept override { 
            this->pushConstants(dynamic_cast<const push_constants_layout_type&>(layout), memory);
        }
        
        virtual void cmdDraw(const IVertexBuffer& vertexBuffer, const UInt32& instances, const UInt32& firstVertex, const UInt32& firstInstance) const override { 
            this->draw(dynamic_cast<const vertex_buffer_type&>(vertexBuffer), instances, firstVertex, firstInstance);
        }
        
        virtual void cmdDrawIndexed(const IIndexBuffer& indexBuffer, const UInt32& instances, const UInt32& firstIndex, const Int32& vertexOffset, const UInt32& firstInstance) const override { 
            this->drawIndexed(dynamic_cast<const index_buffer_type&>(indexBuffer), instances, firstIndex, vertexOffset, firstInstance);
        }
        
        virtual void cmdDrawIndexed(const IVertexBuffer& vertexBuffer, const IIndexBuffer& indexBuffer, const UInt32& instances, const UInt32& firstIndex, const Int32& vertexOffset, const UInt32& firstInstance) const override { 
            this->drawIndexed(dynamic_cast<const vertex_buffer_type&>(vertexBuffer), dynamic_cast<const index_buffer_type&>(indexBuffer), instances, firstIndex, vertexOffset, firstInstance);
        }
    };
 
    template <typename TPipelineLayout, typename TShaderProgram, typename TInputAssembler, typename TRasterizer> requires
        rtti::implements<TInputAssembler, InputAssembler<typename TInputAssembler::vertex_buffer_layout_type, typename TInputAssembler::index_buffer_layout_type>> &&
        rtti::implements<TRasterizer, Rasterizer>
    class RenderPipeline : public IRenderPipeline, public Pipeline<TPipelineLayout, TShaderProgram> {
    public:
        using input_assembler_type = TInputAssembler;
        using rasterizer_type = TRasterizer;
 
    public:
        virtual ~RenderPipeline() noexcept = default;
 
    public:
        virtual SharedPtr<input_assembler_type> inputAssembler() const noexcept = 0;
 
        virtual SharedPtr<rasterizer_type> rasterizer() const noexcept = 0;
 
    private:
        virtual SharedPtr<IInputAssembler> getInputAssembler() const noexcept override {
            return this->inputAssembler();
        }
 
        virtual SharedPtr<IRasterizer> getRasterizer() const noexcept override {
            return this->rasterizer();
        }
    };
 
    template <typename TPipelineLayout, typename TShaderProgram>
    class ComputePipeline : public IComputePipeline, public Pipeline<TPipelineLayout, TShaderProgram> {
    public:
        virtual ~ComputePipeline() noexcept = default;
    };
 
    template <typename TCommandBuffer> requires
        rtti::implements<TCommandBuffer, CommandBuffer<typename TCommandBuffer::buffer_type, typename TCommandBuffer::vertex_buffer_type, typename TCommandBuffer::index_buffer_type, typename TCommandBuffer::image_type, typename TCommandBuffer::barrier_type, typename TCommandBuffer::pipeline_type>>
    class FrameBuffer : public IFrameBuffer {
    public:
        using command_buffer_type = TCommandBuffer;
        using image_type = command_buffer_type::image_type;
 
    public:
        virtual ~FrameBuffer() noexcept = default;
 
    public:
        virtual Array<const command_buffer_type*> commandBuffers() const noexcept = 0;
 
        virtual const command_buffer_type& commandBuffer(const UInt32& index) const = 0;
 
        virtual Array<const image_type*> images() const noexcept = 0;
 
        virtual const image_type& image(const UInt32& location) const = 0;
 
    private:
        virtual Array<const ICommandBuffer*> getCommandBuffers() const noexcept override {
            auto commandBuffers = this->commandBuffers();
            return Array<const ICommandBuffer*>(commandBuffers.begin(), commandBuffers.end());
        }
 
        virtual Array<const IImage*> getImages() const noexcept override {
            auto images = this->images();
            return Array<const IImage*>(images.begin(), images.end());
        }
    };
 
    template <typename TFrameBuffer> requires
        rtti::implements<TFrameBuffer, FrameBuffer<typename TFrameBuffer::command_buffer_type>>
    class IInputAttachmentMappingSource {
    public:
        using frame_buffer_type = TFrameBuffer;
 
    public:
        virtual ~IInputAttachmentMappingSource() noexcept = default;
 
    public:
        virtual const frame_buffer_type& frameBuffer(const UInt32& buffer) const = 0;
    };
 
    template <typename TInputAttachmentMappingSource> requires
        rtti::implements<TInputAttachmentMappingSource, IInputAttachmentMappingSource<typename TInputAttachmentMappingSource::frame_buffer_type>>
    class IInputAttachmentMapping {
    public:
        using input_attachment_mapping_source_type = TInputAttachmentMappingSource;
 
    public:
        virtual ~IInputAttachmentMapping() noexcept = default;
 
    public:
        virtual const input_attachment_mapping_source_type* inputAttachmentSource() const noexcept = 0;
 
        virtual const RenderTarget& renderTarget() const noexcept = 0;
 
        virtual const UInt32& location() const noexcept = 0;
    };
 
    template <typename TRenderPipeline, typename TFrameBuffer, typename TInputAttachmentMapping> requires
        rtti::implements<TFrameBuffer, FrameBuffer<typename TFrameBuffer::command_buffer_type>> &&
        rtti::implements<TRenderPipeline, RenderPipeline<typename TRenderPipeline::pipeline_layout_type, typename TRenderPipeline::shader_program_type, typename TRenderPipeline::input_assembler_type, typename TRenderPipeline::rasterizer_type>> /*&&
        rtti::implements<TInputAttachmentMapping, IInputAttachmentMapping<TDerived>>*/
    class RenderPass : public virtual StateResource, public IRenderPass, public IInputAttachmentMappingSource<TFrameBuffer> {
    public:
        using frame_buffer_type = TFrameBuffer;
        using render_pipeline_type = TRenderPipeline;
        using input_attachment_mapping_type = TInputAttachmentMapping;
        using pipeline_layout_type = render_pipeline_type::pipeline_layout_type;
        using descriptor_set_layout_type = pipeline_layout_type::descriptor_set_layout_type;
        using descriptor_set_type = descriptor_set_layout_type::descriptor_set_type;
 
    public:
        virtual ~RenderPass() noexcept = default;
 
    public:
        virtual const frame_buffer_type& activeFrameBuffer() const = 0;
 
        virtual Array<const frame_buffer_type*> frameBuffers() const noexcept = 0;
 
        virtual Array<const render_pipeline_type*> pipelines() const noexcept = 0;
 
        virtual Span<const input_attachment_mapping_type> inputAttachments() const noexcept = 0;
 
        virtual void updateAttachments(const descriptor_set_type& descriptorSet) const = 0;
 
    private:
        virtual Array<const IFrameBuffer*> getFrameBuffers() const noexcept override {
            auto frameBuffers = this->frameBuffers();
            return Array<const IFrameBuffer*>(frameBuffers.begin(), frameBuffers.end());
        }
 
        virtual Array<const IRenderPipeline*> getPipelines() const noexcept override {
            auto pipelines = this->pipelines();
            return Array<const IRenderPipeline*>(pipelines.begin(), pipelines.end());
        }
 
        virtual void setAttachments(const IDescriptorSet& descriptorSet) const override {
            this->updateAttachments(dynamic_cast<const descriptor_set_type&>(descriptorSet));
        }
    };
 
    template <typename TImageInterface, typename TFrameBuffer> requires
        rtti::implements<TFrameBuffer, FrameBuffer<typename TFrameBuffer::command_buffer_type>> &&
        std::derived_from<TImageInterface, IImage>
    class SwapChain : public ISwapChain {
    public:
        using image_interface_type = TImageInterface;
        using frame_buffer_type = TFrameBuffer;
 
    public:
        virtual ~SwapChain() noexcept = default;
 
    public:
        virtual Array<const image_interface_type*> images() const noexcept = 0;
 
        virtual void present(const frame_buffer_type& frameBuffer) const = 0;
 
        virtual void present(const IFrameBuffer& frameBuffer) const override {
            this->present(dynamic_cast<const frame_buffer_type&>(frameBuffer));
        }
 
    private:
        virtual Array<const IImage*> getImages() const noexcept override {
            auto images = this->images();
            return Array<const IImage*>(images.begin(), images.end());
        }
    };
 
    template <typename TCommandBuffer> requires
        rtti::implements<TCommandBuffer, CommandBuffer<typename TCommandBuffer::buffer_type, typename TCommandBuffer::vertex_buffer_type, typename TCommandBuffer::index_buffer_type, typename TCommandBuffer::image_type, typename TCommandBuffer::barrier_type, typename TCommandBuffer::pipeline_type>>
    class CommandQueue : public ICommandQueue {
    public:
        using command_buffer_type = TCommandBuffer;
 
    public:
        virtual ~CommandQueue() noexcept = default;
 
    public:
        virtual UniquePtr<command_buffer_type> createCommandBuffer(const bool& beginRecording = false) const = 0;
 
        virtual UInt64 submit(const command_buffer_type& commandBuffer) const = 0;
 
        virtual UInt64 submit(const Array<const command_buffer_type*>& commandBuffers) const = 0;
 
    private:
        virtual UniquePtr<ICommandBuffer> getCommandBuffer(const bool& beginRecording) const override {
            return this->createCommandBuffer(beginRecording);
        }
 
        virtual UInt64 submitCommandBuffer(const ICommandBuffer& commandBuffer) const override {
            return this->submit(dynamic_cast<const command_buffer_type&>(commandBuffer));
        }
 
        virtual UInt64 submitCommandBuffers(const Array<const ICommandBuffer*>& commandBuffers) const override {
            Array<const command_buffer_type*> buffers;
            buffers.reserve(commandBuffers.size());
            std::transform(commandBuffers.begin(), commandBuffers.end(), buffers.begin(), [](auto buffer) { return dynamic_cast<const command_buffer_type*>(buffer); });
            return this->submit(buffers);
        }
    };
 
    template <typename TDescriptorLayout, typename TBuffer, typename TVertexBuffer, typename TIndexBuffer, typename TImage, typename TSampler> requires
        rtti::implements<TDescriptorLayout, IDescriptorLayout> &&
        std::derived_from<TVertexBuffer, VertexBuffer<typename TVertexBuffer::vertex_buffer_layout_type>> &&
        std::derived_from<TIndexBuffer, IndexBuffer<typename TIndexBuffer::index_buffer_layout_type>> &&
        std::derived_from<TImage, IImage> &&
        std::derived_from<TBuffer, IBuffer> &&
        std::derived_from<TSampler, ISampler>
    class GraphicsFactory : public IGraphicsFactory {
    public:
        using descriptor_layout_type = TDescriptorLayout;
        using vertex_buffer_type = TVertexBuffer;
        using vertex_buffer_layout_type = vertex_buffer_type::vertex_buffer_layout_type;
        using index_buffer_type = TIndexBuffer;
        using index_buffer_layout_type = index_buffer_type::index_buffer_layout_type;
        using buffer_type = TBuffer;
        using image_type = TImage;
        using sampler_type = TSampler;
 
    public:
        virtual ~GraphicsFactory() noexcept = default;
 
    public:
        virtual UniquePtr<TBuffer> createBuffer(const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const = 0;
        
        virtual UniquePtr<TBuffer> createBuffer(const String& name, const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements = 1, const bool& allowWrite = false) const = 0;
 
        virtual UniquePtr<TVertexBuffer> createVertexBuffer(const vertex_buffer_layout_type& layout, const BufferUsage& usage, const UInt32& elements = 1) const = 0;
 
        virtual UniquePtr<TVertexBuffer> createVertexBuffer(const String& name, const vertex_buffer_layout_type& layout, const BufferUsage& usage, const UInt32& elements = 1) const = 0;
 
        virtual UniquePtr<TIndexBuffer> createIndexBuffer(const index_buffer_layout_type& layout, const BufferUsage& usage, const UInt32& elements) const = 0;
 
        virtual UniquePtr<TIndexBuffer> createIndexBuffer(const String& name, const index_buffer_layout_type& layout, const BufferUsage& usage, const UInt32& elements) const = 0;
 
        virtual UniquePtr<TImage> createAttachment(const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const = 0;
 
        virtual UniquePtr<TImage> createAttachment(const String& name, const Format& format, const Size2d& size, const MultiSamplingLevel& samples = MultiSamplingLevel::x1) const = 0;
 
        virtual UniquePtr<TImage> createTexture(const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const = 0;
 
        virtual UniquePtr<TImage> createTexture(const String& name, const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32& levels = 1, const UInt32& layers = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const = 0;
 
        virtual Array<UniquePtr<TImage>> createTextures(const UInt32& elements, const Format& format, const Size3d& size, const ImageDimensions& dimension = ImageDimensions::DIM_2, const UInt32 & layers = 1, const UInt32& levels = 1, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const bool& allowWrite = false) const = 0;
 
        virtual UniquePtr<TSampler> createSampler(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& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const = 0;
 
        virtual UniquePtr<TSampler> createSampler(const String& name, 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& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const = 0;
 
        virtual Array<UniquePtr<TSampler>> createSamplers(const UInt32& elements, 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& maxLod = std::numeric_limits<Float>::max(), const Float& minLod = 0.f, const Float& anisotropy = 0.f) const = 0;
 
    private:
        virtual UniquePtr<IBuffer> getBuffer(const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements, const bool& allowWrite) const override { 
            return this->createBuffer(type, usage, elementSize, elements, allowWrite);
        }
 
        virtual UniquePtr<IBuffer> getBuffer(const String& name, const BufferType& type, const BufferUsage& usage, const size_t& elementSize, const UInt32& elements, const bool& allowWrite) const override {
            return this->createBuffer(name, type, usage, elementSize, elements, allowWrite);
        }
 
        virtual UniquePtr<IVertexBuffer> getVertexBuffer(const IVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override { 
            return this->createVertexBuffer(dynamic_cast<const vertex_buffer_layout_type&>(layout), usage, elements);
        }
 
        virtual UniquePtr<IVertexBuffer> getVertexBuffer(const String& name, const IVertexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override {
            return this->createVertexBuffer(name, dynamic_cast<const vertex_buffer_layout_type&>(layout), usage, elements);
        }
        
        virtual UniquePtr<IIndexBuffer> getIndexBuffer(const IIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override {
            return this->createIndexBuffer(dynamic_cast<const index_buffer_layout_type&>(layout), usage, elements);
        }
 
        virtual UniquePtr<IIndexBuffer> getIndexBuffer(const String& name, const IIndexBufferLayout& layout, const BufferUsage& usage, const UInt32& elements) const override {
            return this->createIndexBuffer(name, dynamic_cast<const index_buffer_layout_type&>(layout), usage, elements);
        }
 
        virtual UniquePtr<IImage> getAttachment(const Format& format, const Size2d& size, const MultiSamplingLevel& samples) const override { 
            return this->createAttachment(format, size, samples);
        }
 
        virtual UniquePtr<IImage> getAttachment(const String& name, const Format& format, const Size2d& size, const MultiSamplingLevel& samples) const override {
            return this->createAttachment(name, format, size, samples);
        }
        
        virtual UniquePtr<IImage> getTexture(const Format& format, const Size3d& size, const ImageDimensions& dimension, const UInt32& levels, const UInt32& layers, const MultiSamplingLevel& samples, const bool& allowWrite) const override { 
            return this->createTexture(format, size, dimension, levels, layers, samples, allowWrite);
        }
 
        virtual UniquePtr<IImage> getTexture(const String& name, const Format& format, const Size3d& size, const ImageDimensions& dimension, const UInt32& levels, const UInt32& layers, const MultiSamplingLevel& samples, const bool& allowWrite) const override {
            return this->createTexture(name, format, size, dimension, levels, layers, samples, allowWrite);
        }
 
        virtual Array<UniquePtr<IImage>> getTextures(const UInt32& elements, const Format& format, const Size3d& size, const ImageDimensions& dimension, const UInt32& layers, const UInt32& levels, const MultiSamplingLevel& samples, const bool& allowWrite) const override { 
            auto textures = this->getTextures(elements, format, size, dimension, layers, levels, samples, allowWrite);
            Array<UniquePtr<IImage>> results;
            results.reserve(textures.size());
            std::move(std::begin(textures), std::end(textures), std::inserter(results, std::end(results)));
            return results;
        }
        
        virtual UniquePtr<ISampler> getSampler(const FilterMode& magFilter, const FilterMode& minFilter, const BorderMode& borderU, const BorderMode& borderV, const BorderMode& borderW, const MipMapMode& mipMapMode, const Float& mipMapBias, const Float& maxLod, const Float& minLod, const Float& anisotropy) const override { 
            return this->createSampler(magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
 
        virtual UniquePtr<ISampler> getSampler(const String& name, const FilterMode& magFilter, const FilterMode& minFilter, const BorderMode& borderU, const BorderMode& borderV, const BorderMode& borderW, const MipMapMode& mipMapMode, const Float& mipMapBias, const Float& maxLod, const Float& minLod, const Float& anisotropy) const override {
            return this->createSampler(name, magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
        }
        
        virtual Array<UniquePtr<ISampler>> getSamplers(const UInt32& elements, const FilterMode& magFilter, const FilterMode& minFilter, const BorderMode& borderU, const BorderMode& borderV, const BorderMode& borderW, const MipMapMode& mipMapMode, const Float& mipMapBias, const Float& maxLod, const Float& minLod, const Float& anisotropy) const override {
            auto samplers = this->createSamplers(elements, magFilter, minFilter, borderU, borderV, borderW, mipMapMode, mipMapBias, maxLod, minLod, anisotropy);
            Array<UniquePtr<ISampler>> results;
            results.reserve(samplers.size());
            std::move(std::begin(samplers), std::end(samplers), std::inserter(results, std::end(results)));
            return results;
        }
    };
 
    template <typename TFactory, typename TSurface, typename TGraphicsAdapter, typename TSwapChain, typename TCommandQueue, typename TRenderPass, typename TComputePipeline, typename TBarrier> requires
        rtti::implements<TSurface, ISurface> &&
        rtti::implements<TGraphicsAdapter, IGraphicsAdapter> &&
        rtti::implements<TSwapChain, SwapChain<typename TFactory::image_type, typename TRenderPass::frame_buffer_type>> &&
        rtti::implements<TCommandQueue, CommandQueue<typename TCommandQueue::command_buffer_type>> &&
        rtti::implements<TFactory, GraphicsFactory<typename TFactory::descriptor_layout_type, typename TFactory::buffer_type, typename TFactory::vertex_buffer_type, typename TFactory::index_buffer_type, typename TFactory::image_type, typename TFactory::sampler_type>> &&
        rtti::implements<TRenderPass, RenderPass<typename TRenderPass::render_pipeline_type, typename TRenderPass::frame_buffer_type, typename TRenderPass::input_attachment_mapping_type>> &&
        rtti::implements<TComputePipeline, ComputePipeline<typename TComputePipeline::pipeline_layout_type, typename TComputePipeline::shader_program_type>> &&
        rtti::implements<TBarrier, Barrier<typename TFactory::buffer_type, typename TFactory::image_type>>
    class GraphicsDevice : public IGraphicsDevice {
    public:
        using surface_type = TSurface;
        using adapter_type = TGraphicsAdapter;
        using swap_chain_type = TSwapChain;
        using command_queue_type = TCommandQueue;
        using command_buffer_type = command_queue_type::command_buffer_type;
        using factory_type = TFactory;
        using barrier_type = TBarrier;
        using descriptor_layout_type = factory_type::descriptor_layout_type;
        using vertex_buffer_type = factory_type::vertex_buffer_type;
        using index_buffer_type = factory_type::index_buffer_type;
        using buffer_type = factory_type::buffer_type;
        using image_type = factory_type::image_type;
        using sampler_type = factory_type::sampler_type;
        using render_pass_type = TRenderPass;
        using frame_buffer_type = render_pass_type::frame_buffer_type;
        using render_pipeline_type = render_pass_type::render_pipeline_type;
        using compute_pipeline_type = TComputePipeline;
        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;
        using shader_program_type = render_pipeline_type::shader_program_type;
 
    public:
        virtual ~GraphicsDevice() noexcept = default;
 
    public:
        virtual const surface_type& surface() const noexcept = 0;
 
        virtual const adapter_type& adapter() const noexcept = 0;
 
        virtual const swap_chain_type& swapChain() const noexcept = 0;
 
        virtual swap_chain_type& swapChain() noexcept = 0;
 
        virtual const factory_type& factory() const noexcept = 0;
 
        virtual const command_queue_type& graphicsQueue() const noexcept = 0;
 
        virtual const command_queue_type& transferQueue() const noexcept = 0;
 
        virtual const command_queue_type& bufferQueue() const noexcept = 0;
 
        virtual const command_queue_type& computeQueue() const noexcept = 0;
 
        virtual UniquePtr<barrier_type> makeBarrier() const noexcept = 0;
 
    private:
        virtual UniquePtr<IBarrier> getNewBarrier() const noexcept override {
            return this->makeBarrier();
        }
 
#if defined(BUILD_DEFINE_BUILDERS)
    public:
        using render_pass_builder_type = render_pass_type::builder_type;
        using render_pipeline_builder_type = render_pipeline_type::builder_type;
        using compute_pipeline_builder_type = compute_pipeline_type::builder_type;
        using pipeline_layout_builder_type = pipeline_layout_type::builder_type;
        using input_assembler_builder_type = input_assembler_type::builder_type;
        using rasterizer_builder_type = rasterizer_type::builder_type;
        using shader_program_builder_type = shader_program_type::builder_type;
 
        [[nodiscard]] virtual render_pass_builder_type buildRenderPass(const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const UInt32& commandBuffers = 1) const = 0;
 
        [[nodiscard]] virtual render_pass_builder_type buildRenderPass(const String& name, const MultiSamplingLevel& samples = MultiSamplingLevel::x1, const UInt32& commandBuffers = 1) const = 0;
 
        [[nodiscard]] virtual compute_pipeline_builder_type buildComputePipeline(const String& name) const = 0;
 
        //[[nodiscard]] virtual render_pipeline_builder_type buildRenderPipeline(const String& name) const = 0;
 
        [[nodiscard]] virtual render_pipeline_builder_type buildRenderPipeline(const render_pass_type& renderPass, const String& name) const = 0;
 
        [[nodiscard]] virtual pipeline_layout_builder_type buildPipelineLayout() const = 0;
 
        [[nodiscard]] virtual input_assembler_builder_type buildInputAssembler() const = 0;
 
        [[nodiscard]] virtual rasterizer_builder_type buildRasterizer() const = 0;
 
        [[nodiscard]] virtual shader_program_builder_type buildShaderProgram() const = 0;
#endif // defined(BUILD_DEFINE_BUILDERS)
    };
 
    template <typename TBackend, typename TGraphicsDevice> requires
        rtti::implements<TGraphicsDevice, GraphicsDevice<typename TGraphicsDevice::factory_type, typename TGraphicsDevice::surface_type, typename TGraphicsDevice::adapter_type, typename TGraphicsDevice::swap_chain_type, typename TGraphicsDevice::command_queue_type, typename TGraphicsDevice::render_pass_type, typename TGraphicsDevice::compute_pipeline_type, typename TGraphicsDevice::barrier_type>>
    class RenderBackend : public IRenderBackend {
    public:
        using device_type = TGraphicsDevice;
        using surface_type = device_type::surface_type;
        using adapter_type = device_type::adapter_type;
        using swap_chain_type = device_type::swap_chain_type;
        using command_queue_type = device_type::command_queue_type;
        using command_buffer_type = device_type::command_buffer_type;
        using factory_type = device_type::factory_type;
        using barrier_type = device_type::barrier_type;
        using descriptor_layout_type = factory_type::descriptor_layout_type;
        using vertex_buffer_type = factory_type::vertex_buffer_type;
        using index_buffer_type = factory_type::index_buffer_type;
        using buffer_type = factory_type::buffer_type;
        using image_type = factory_type::image_type;
        using sampler_type = factory_type::sampler_type;
        using frame_buffer_type = device_type::frame_buffer_type;
        using render_pass_type = device_type::render_pass_type;
        using pipeline_layout_type = device_type::pipeline_layout_type;
        using render_pipeline_type = device_type::render_pipeline_type;
        using compute_pipeline_type = device_type::compute_pipeline_type;
        using shader_program_type = device_type::shader_program_type;
        using input_assembler_type = device_type::input_assembler_type;
        using rasterizer_type = device_type::rasterizer_type;
 
    public:
        virtual ~RenderBackend() noexcept = default;
 
    public:
        virtual Array<const adapter_type*> listAdapters() const = 0;
 
        virtual const adapter_type* findAdapter(const Optional<UInt64>& adapterId = std::nullopt) const = 0;
 
        virtual void registerDevice(String name, UniquePtr<device_type>&& device) = 0;
 
        template <typename ...TArgs>
        device_type* createDevice(String name, const adapter_type& adapter, UniquePtr<surface_type>&& surface, TArgs&&... _args) {
            auto device = makeUnique<device_type>(static_cast<const TBackend&>(*this), adapter, std::move(surface), std::forward<TArgs>(_args)...);
            auto devicePointer = device.get();
            this->registerDevice(name, std::move(device));
            return devicePointer;
        }
 
        virtual void releaseDevice(const String& name) = 0;
 
        virtual device_type* device(const String& name) noexcept = 0;
 
        virtual const device_type* device(const String& name) const noexcept = 0;
 
        virtual const device_type* operator[](const String& name) const noexcept {
            return this->device(name);
        };
 
        virtual device_type* operator[](const String& name) noexcept {
            return this->device(name);
        };
 
        // IRenderBackend interface
    private:
        virtual Array<const IGraphicsAdapter*> getAdapters() const override {
            auto adapters = this->listAdapters();
            return Array<const IGraphicsAdapter*>(adapters.begin(), adapters.end());
        }
    };
}