spk_color_painter.hpp

#pragma once
 
#include "structure/graphics/painter/spk_mesh_painter.hpp"
#include "structure/graphics/spk_color.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/opengl/spk_vertex_buffer_object.hpp"
 
namespace spk
{
    struct ColorVertex
    {
        Vector2Int pos;
        Color color;
    };

    class ColorMesh : public IMesh<ColorVertex>
    {
    public:
        using Base = IMesh<ColorVertex>;
        using Polygon = Base::Polygon;

        class Builder
        {
        private:
            std::vector<Polygon> _polygons;
 
        public:
            Builder() = default;

            Builder &clear()
            {
                _polygons.clear();
                return *this;
            }

            Builder &insertTriangle(const Vector2Int &p_a, const Vector2Int &p_b, const Vector2Int &p_c, const Color &p_color)
            {
                _polygons.push_back(Polygon::makeTriangle(ColorVertex{p_a, p_color}, ColorVertex{p_b, p_color}, ColorVertex{p_c, p_color}));
                return *this;
            }

            Builder &insertQuad(const Vector2Int &p_a, const Vector2Int &p_b, const Vector2Int &p_c, const Vector2Int &p_d, const Color &p_color, PolygonOrder p_order = PolygonOrder::TriangleFanFromFirst)
            {
                _polygons.push_back(Polygon::makeQuad(ColorVertex{p_a, p_color}, ColorVertex{p_b, p_color}, ColorVertex{p_c, p_color}, ColorVertex{p_d, p_color}, p_order));
                return *this;
            }

            Builder &insertRectangle(const Vector2Int &p_anchor, const Vector2UInt &p_size, const Color &p_color)
            {
                const Vector2Int a = p_anchor;
                const Vector2Int b = {p_anchor.x, p_anchor.y + static_cast<int>(p_size.y)};
                const Vector2Int c = {p_anchor.x + static_cast<int>(p_size.x), p_anchor.y + static_cast<int>(p_size.y)};
                const Vector2Int d = {p_anchor.x + static_cast<int>(p_size.x), p_anchor.y};
 
                return insertQuad(a, b, c, d, p_color, PolygonOrder::TriangleFanFromFirst);
            }

            ColorMesh construct()
            {
                ColorMesh result;
                for (const auto &poly : _polygons)
                {
                    result.append(poly);
                }
                return result;
            }
        };
 
    protected:
        void _configureBufferSet() const override
        {
            auto &layout = bufferSet()->vbo().layout();
            using Attribute = spk::OpenGL::VertexBufferObject::Layout::Attribute;
            layout.addAttribute({0, Attribute::Type::Vector2Int});
            layout.addAttribute({1, Attribute::Type::Color});
        }
    };

    class ColorPainter : public MeshPainter<ColorMesh>
    {
    private:
        static Lumina::Pipeline &_colorPipeline();
        OpenGL::UBO &_modelData;
        float &_layerRef;
 
    public:
        ColorPainter();

        void setLayer(const float &p_layer);
        const float &layer() const;
    };
}