spk_texture_painter.hpp

#pragma once
 
#include "structure/graphics/painter/spk_mesh_painter.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/opengl/spk_sampler_object.hpp"
#include "structure/opengl/spk_texture_object.hpp"
#include "structure/opengl/spk_vertex_buffer_object.hpp"
 
namespace spk
{
    struct TextureVertex
    {
        Vector2Int pos;
        Vector2 uv;
    };

    class TextureMesh : public IMesh<TextureVertex>
    {
    public:
        using Base = IMesh<TextureVertex>;
        using Polygon = Base::Polygon;

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

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

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

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

            Builder &insertRectangle(const Vector2Int &p_anchor, const Vector2UInt &p_size, const Vector2 &p_uvAnchor, const Vector2 &p_uvSize, PolygonOrder p_order = PolygonOrder::TriangleFanFromFirst)
            {
                const Vector2Int posA{p_anchor.x, p_anchor.y};
                const Vector2Int posB{p_anchor.x, p_anchor.y + static_cast<int>(p_size.y)};
                const Vector2Int posC{p_anchor.x + static_cast<int>(p_size.x), p_anchor.y + static_cast<int>(p_size.y)};
                const Vector2Int posD{p_anchor.x + static_cast<int>(p_size.x), p_anchor.y};
 
                const Vector2 uvA = p_uvAnchor;
                const Vector2 uvB{p_uvAnchor.x, p_uvAnchor.y + p_uvSize.y};
                const Vector2 uvC{p_uvAnchor.x + p_uvSize.x, p_uvAnchor.y + p_uvSize.y};
                const Vector2 uvD{p_uvAnchor.x + p_uvSize.x, p_uvAnchor.y};
 
                TextureVertex a{posA, uvA};
                TextureVertex b{posB, uvB};
                TextureVertex c{posC, uvC};
                TextureVertex d{posD, uvD};
 
                return insertQuad(a, b, c, d, p_order);
            }

            Builder &insertRectangleFullUV(const Vector2Int &p_anchor, const Vector2UInt &p_size, PolygonOrder p_order = PolygonOrder::TriangleFanFromFirst)
            {
                return insertRectangle(p_anchor, p_size, {0.0f, 0.0f}, {1.0f, 1.0f}, p_order);
            }

            Builder &insertRectangleFullUV(const spk::Extend2D &p_extend, PolygonOrder p_order = PolygonOrder::TriangleFanFromFirst)
            {
                return insertRectangle(p_extend.anchor, p_extend.size, {0.0f, 0.0f}, {1.0f, 1.0f}, p_order);
            }

            TextureMesh construct()
            {
                TextureMesh 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::Vector2});
        }
    };

    class TexturePainter : public MeshPainter<TextureMesh>
    {
    private:
        static Lumina::Pipeline &_texturePipeline();
        OpenGL::SamplerObject &_textureSampler;
        OpenGL::UBO &_modelData;
        float &_layerRef;
 
    public:
        TexturePainter();

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

        void setTexture(const OpenGL::TextureObject *p_texture);
        const OpenGL::TextureObject *texture() const;
    };
}