RenderPass.h

#pragma once
 
#include "spark/render/Export.h"
#include "spark/render/FrameBuffer.h"
#include "spark/render/InputAttachementMapping.h"
#include "spark/render/RenderPipeilne.h"
#include "spark/render/RenderTarget.h"
#include "spark/render/StateResource.h"
 
#include <span>
 
namespace spark::render
{
    class SPARK_RENDER_EXPORT IRenderPass : public virtual IStateResource
    {
    public:
        ~IRenderPass() noexcept override = default;
 
        virtual void begin(unsigned int buffer) = 0;
 
        virtual void end() const = 0;
 
        [[nodiscard]] const IFrameBuffer& activeFrameBuffer() const { return genericActiveFrameBuffer(); }
 
        [[nodiscard]] std::vector<const IFrameBuffer*> frameBuffers() const noexcept { return genericFrameBuffers(); }
 
        virtual void resizeFrameBuffers(const math::Vector2<unsigned int>& new_render_area) = 0;
 
        [[nodiscard]] std::vector<const IRenderPipeline*> pipelines() const noexcept { return genericPipelines(); }
 
        [[nodiscard]] virtual const RenderTarget& renderTarget(unsigned int location) const = 0;
 
        [[nodiscard]] virtual std::span<const RenderTarget> renderTargets() const noexcept = 0;
 
        [[nodiscard]] virtual bool hasPresentRenderTarget() const noexcept = 0;
 
        [[nodiscard]] virtual MultiSamplingLevel multiSamplingLevel() const noexcept = 0;
 
        void updateAttachments(const IDescriptorSet& descriptor_set) const { genericUpdateAttachments(descriptor_set); }
 
    private:
        [[nodiscard]] virtual const IFrameBuffer& genericActiveFrameBuffer() const = 0;
        [[nodiscard]] virtual std::vector<const IFrameBuffer*> genericFrameBuffers() const noexcept = 0;
        [[nodiscard]] virtual std::vector<const IRenderPipeline*> genericPipelines() const noexcept = 0;
        virtual void genericUpdateAttachments(const IDescriptorSet& descriptor_set) const = 0;
    };
 
    template <typename RenderPipelineType, typename FrameBufferType, typename InputAttachmentMappingType>
    class RenderPass : public StateResource, public IRenderPass, public InputAttachmentMappingSource<FrameBufferType>
    {
    public:
        using frame_buffer_type = FrameBufferType;
        using render_pipeline_type = RenderPipelineType;
        using input_attachment_mapping_type = InputAttachmentMappingType;
        using pipeline_layout_type = typename render_pipeline_type::pipeline_layout_type;
        using descriptor_set_layout_type = typename pipeline_layout_type::descriptor_set_layout_type;
        using descriptor_set_type = typename descriptor_set_layout_type::descriptor_set_type;
 
    public:
        [[nodiscard]] virtual const frame_buffer_type& activeFrameBuffer() const = 0;
 
        [[nodiscard]] virtual std::vector<const frame_buffer_type*> frameBuffers() const noexcept = 0;
 
        [[nodiscard]] virtual std::vector<const render_pipeline_type*> pipelines() const noexcept = 0;
 
        [[nodiscard]] virtual std::span<const input_attachment_mapping_type> inputAttachments() const noexcept = 0;
 
        virtual void updateAttachments(const descriptor_set_type& descriptor_set) const = 0;
 
    private:
        [[nodiscard]] const IFrameBuffer& genericActiveFrameBuffer() const final { return activeFrameBuffer(); }
 
        [[nodiscard]] std::vector<const IFrameBuffer*> genericFrameBuffers() const noexcept final
        {
            auto tmp = frameBuffers();
            std::vector<const IFrameBuffer*> frame_buffers_vector;
            frame_buffers_vector.reserve(tmp.size());
            std::ranges::transform(tmp, std::back_inserter(frame_buffers_vector), [](const auto& frame_buffer) { return static_cast<const IFrameBuffer*>(frame_buffer); });
            return frame_buffers_vector;
        }
 
        [[nodiscard]] std::vector<const IRenderPipeline*> genericPipelines() const noexcept final
        {
            auto tmp = pipelines();
            std::vector<const IRenderPipeline*> pipelines_vector;
            pipelines_vector.reserve(tmp.size());
            std::ranges::transform(tmp, std::back_inserter(pipelines_vector), [](const auto& pipeline) { return static_cast<const IRenderPipeline*>(pipeline); });
            return pipelines_vector;
        }
 
        void genericUpdateAttachments(const IDescriptorSet& descriptor_set) const final { updateAttachments(static_cast<const descriptor_set_type&>(descriptor_set)); }
    };
}