Renderer2D.h

#pragma once
 
#include "spark/math/Vector2.h"
#include "spark/render/CommandBuffer.h"
#include "spark/render/Scissor.h"
#include "spark/render/Viewport.h"
 
#include "glm/matrix.hpp"
 
#include <memory>
#include <span>
#include <string>
 
namespace spark::core
{
    template <typename Backend>
    class Renderer2D
    {
        friend class Window;
 
    public:
        using backend_type = Backend;
        using device_type = typename backend_type::device_type;
        using buffer_type = typename device_type::buffer_type;
        using command_buffer_type = typename device_type::command_buffer_type;
        using descriptor_set_type = typename command_buffer_type::descriptor_set_type;
        using adapter_type = typename device_type::adapter_type;
        using surface_type = typename backend_type::surface_type;
        using render_pass_type = typename backend_type::render_pass_type;
        using render_pipeline_type = typename backend_type::render_pipeline_type;
        using pipeline_layout_type = typename backend_type::pipeline_layout_type;
        using shader_program_type = typename backend_type::shader_program_type;
        using shader_module_type = typename shader_program_type::shader_module_type;
        using input_assembler_type = typename backend_type::input_assembler_type;
        using rasterizer_type = typename backend_type::rasterizer_type;
        using factory_type = typename device_type::factory_type;
        using vertex_buffer_layout_type = typename factory_type::vertex_buffer_layout_type;
        using vertex_buffer_type = typename factory_type::vertex_buffer_type;
        using index_buffer_layout_type = typename factory_type::index_buffer_layout_type;
        using index_buffer_type = typename factory_type::index_buffer_type;
 
    public:
        explicit Renderer2D(const math::Vector2<unsigned>& render_area,
                            std::function<typename surface_type::handle_type(const typename backend_type::handle_type&)> surface_factory,
                            std::span<std::string> required_extensions);
 
        ~Renderer2D();
 
        Renderer2D(const Renderer2D& other) = delete;
        Renderer2D(Renderer2D&& other) noexcept = delete;
        Renderer2D& operator=(const Renderer2D& other) = delete;
        Renderer2D& operator=(Renderer2D&& other) noexcept = delete;
 
        void recreateSwapChain(const math::Vector2<unsigned>& new_size);
 
        void render();
 
        void drawQuad(const glm::mat4& transform_matrix, const spark::math::Vector4<float>& color = {1.f, 1.f, 1.f, 1.f});
 
        void drawCircle(const glm::mat4& transform_matrix, float radius, const spark::math::Vector4<float>& color = {1.f, 1.f, 1.f, 1.f});
 
    private:
        void initRenderGraph();
 
        void updateCamera(const render::ICommandBuffer& command_buffer);
 
        void upload();
 
    private:
        inline static constexpr std::array s_rectangleVertices = {
            glm::vec3(-0.5f, -0.5f, 0.f),
            glm::vec3(-0.5f, 0.5f, 0.f),
            glm::vec3(0.5f, 0.5f, 0.f),
            glm::vec3(0.5f, -0.5f, 0.f)
        };
 
        inline static constexpr std::array<uint16_t, 6> s_rectangleIndices = {0, 1, 2, 0, 2, 3};
 
        device_type* m_device;
        std::unique_ptr<backend_type> m_renderBackend;
        std::shared_ptr<input_assembler_type> m_inputAssembler;
        std::unique_ptr<render::IViewport> m_viewport;
        std::unique_ptr<render::IScissor> m_scissor;
        std::vector<std::size_t> m_transferFences;
 
        SPARK_WARNING_PUSH
        SPARK_DISABLE_MSVC_WARNING(4324) // 'InstanceBuffer': structure was padded due to alignment specifier. This is intended to align the CPU buffer to GPU one.
 
        struct alignas(sizeof(glm::vec4)) InstanceBuffer
        {
            glm::mat4 transform;
            glm::vec4 color;
            float radius;
        };
 
        SPARK_WARNING_POP
 
        inline static constexpr std::size_t s_maxInstances = 1024 * 8;
        std::vector<InstanceBuffer> m_instanceData;
    };
}
 
#include "spark/core/impl/Renderer2D.h"