FrameBuffer.h

#pragma once
 
#include "spark/render/CommandBuffer.h"
#include "spark/render/Export.h"
#include "spark/render/Image.h"
 
#include "spark/math/Vector2.h"
 
#include <memory>
 
namespace spark::render
{
    class SPARK_RENDER_EXPORT IFrameBuffer
    {
    public:
        virtual ~IFrameBuffer() noexcept = default;
 
        [[nodiscard]] virtual unsigned int bufferIndex() const noexcept = 0;
 
        [[nodiscard]] virtual spark::math::Vector2<unsigned> size() const noexcept = 0;
 
        [[nodiscard]] std::vector<std::shared_ptr<const ICommandBuffer>> commandBuffers() const noexcept { return genericCommandBuffers(); }
 
        [[nodiscard]] std::shared_ptr<const ICommandBuffer> commandBuffer(unsigned int index) const { return genericCommandBuffer(index); }
 
        [[nodiscard]] std::vector<const IImage*> images() const noexcept { return genericImages(); }
 
        [[nodiscard]] const IImage& image(unsigned int location) const { return genericImage(location); }
 
        virtual void resize(const spark::math::Vector2<unsigned>& render_area) = 0;
 
    private:
        [[nodiscard]] virtual std::vector<std::shared_ptr<const ICommandBuffer>> genericCommandBuffers() const noexcept = 0;
        [[nodiscard]] virtual std::shared_ptr<const ICommandBuffer> genericCommandBuffer(unsigned int index) const = 0;
        [[nodiscard]] virtual std::vector<const IImage*> genericImages() const noexcept = 0;
        [[nodiscard]] virtual const IImage& genericImage(unsigned int location) const = 0;
    };
 
    template <typename CommandBufferType>
    class FrameBuffer : public IFrameBuffer
    {
    public:
        using command_buffer_type = CommandBufferType;
        using image_type = typename command_buffer_type::image_type;
 
    public:
        [[nodiscard]] virtual std::vector<std::shared_ptr<const command_buffer_type>> commandBuffers() const noexcept = 0;
 
        [[nodiscard]] virtual std::shared_ptr<const command_buffer_type> commandBuffer(unsigned index) const = 0;
 
        [[nodiscard]] virtual std::vector<const image_type*> images() const noexcept = 0;
 
        [[nodiscard]] virtual const image_type& image(unsigned location) const = 0;
 
    private:
        [[nodiscard]] std::vector<std::shared_ptr<const ICommandBuffer>> genericCommandBuffers() const noexcept final
        {
            auto tmp = commandBuffers();
            std::vector<std::shared_ptr<const ICommandBuffer>> command_buffers_vector;
            command_buffers_vector.reserve(tmp.size());
            std::ranges::transform(tmp,
                                   std::back_inserter(command_buffers_vector),
                                   [](const auto& command_buffer) { return static_cast<std::shared_ptr<const ICommandBuffer>>(command_buffer); });
            return command_buffers_vector;
        }
 
        [[nodiscard]] std::shared_ptr<const ICommandBuffer> genericCommandBuffer(unsigned index) const final { return commandBuffer(index); }
 
        [[nodiscard]] std::vector<const IImage*> genericImages() const noexcept final
        {
            auto tmp = images();
            std::vector<const IImage*> images_vector;
            images_vector.reserve(tmp.size());
            std::ranges::transform(tmp, std::back_inserter(images_vector), [](const auto& image) { return static_cast<const IImage*>(image); });
            return images_vector;
        }
 
        [[nodiscard]] const IImage& genericImage(unsigned location) const final { return image(location); }
    };
}