GuiGeometry.h

/****************************************************************************
 * libgui
 * Daryl Borth 2026
 * GuiGeometry.h
 *
 * Platform-agnostic shape tessellation. Turns rounded rectangles, ellipses,
 * polygons, strokes, arcs and soft shadows into triangle meshes with
 * per-vertex colors. Edges are anti-aliased by a thin feathered fringe whose
 * vertices fade to alpha 0, so no multisampling is needed. Nothing here
 * touches a platform API; a mesh is drawn by whatever renders MeshVertex
 * triangle lists.
 *
 * Coordinates are design-canvas pixels, +Y down. Every triangle is emitted
 * with the same (clockwise on screen) winding.
 ***************************************************************************/
#pragma once
#include <cstddef>
#include <vector>
#include "../drivers/Mesh.h"

struct GuiPoint {
    float x;   
    float y;   
};

struct GuiRect {
    float x;   
    float y;   
    float w;   
    float h;   
};

struct GuiCorners {
    float tl; 
    float tr; 
    float br; 
    float bl; 
    GuiCorners(float r = 0) : tl(r), tr(r), br(r), bl(r) {}
    GuiCorners(float tl_, float tr_, float br_, float bl_) : tl(tl_), tr(tr_), br(br_), bl(bl_) {}
};

enum class STROKE {
    INSIDE,       
    CENTRE,     
    OUTSIDE      
};

struct GuiFill {
    PixelColor from;  
    PixelColor to;      
    float angle;       
    bool gradient;      

    static GuiFill solid(PixelColor c);
    static GuiFill linear(PixelColor a, PixelColor b, float angleDeg);
};

struct GuiPath {
    enum CMD : uint8_t { MOVE = 'M', LINE = 'L', CUBIC = 'C', CLOSE = 'Z' };
    std::vector<uint8_t> cmds;  
    std::vector<float> pts;      

    bool empty() const { return cmds.empty(); }
    GuiPath& moveTo(float x, float y) { cmds.push_back(MOVE); pts.push_back(x); pts.push_back(y); return *this; }
    GuiPath& lineTo(float x, float y) { cmds.push_back(LINE); pts.push_back(x); pts.push_back(y); return *this; }
    GuiPath& cubicTo(float x1, float y1, float x2, float y2, float x, float y)
    {
        cmds.push_back(CUBIC);
        pts.push_back(x1); pts.push_back(y1); pts.push_back(x2); pts.push_back(y2); pts.push_back(x); pts.push_back(y);
        return *this;
    }
    GuiPath& close() { cmds.push_back(CLOSE); return *this; }
};

std::vector<std::vector<GuiPoint> > GuiFlattenPath(const GuiPath& path, float scale, float tolerance = 0.15f);

GuiRect GuiPathBounds(const GuiPath& path, float scale = 1.0f);

std::vector<GuiPoint> GuiRoundRectPolygon(const GuiRect& r, float radius, float angleDeg, float tolerance = 0.15f);

class GuiMesh
{
    public:
        GuiMesh(float featherWidth = 1.0f, float curveTolerance = 0.3f);

        void clear();
        size_t size() const { return verts.size(); }
        bool empty() const { return verts.empty(); }
        const std::vector<MeshVertex>& vertices() const { return verts; }
        float getFeather() const { return feather; }
        float getTolerance() const { return tolerance; }

        void addRect(const GuiRect& r, const GuiFill& fill, bool edgeFringe = true);
        void addRoundRect(const GuiRect& r, const GuiCorners& corners, const GuiFill& fill, bool edgeFringe = true);
        void addEllipse(const GuiRect& r, const GuiFill& fill, bool edgeFringe = true);
        void addPolygon(const std::vector<GuiPoint>& pts, const GuiFill& fill, bool edgeFringe = true);
        void addLine(GuiPoint a, GuiPoint b, float width, const GuiFill& fill);

        void strokeRoundRect(const GuiRect& r, const GuiCorners& corners, float width, STROKE align, const GuiFill& fill);
        void strokeEllipse(const GuiRect& r, float width, STROKE align, const GuiFill& fill);
        void strokePolygon(const std::vector<GuiPoint>& pts, float width, STROKE align, const GuiFill& fill);
        void strokeArc(GuiPoint centre, float radius, float startDeg, float sweepDeg, float width, PixelColor color);

        void addShadow(const GuiRect& r, const GuiCorners& corners, float blur, float spread, float dx, float dy, PixelColor color);
 
    private:
        std::vector<MeshVertex> verts;
        float feather;
        float tolerance;
};