raylib-cs/Examples/Shapes/SplinesDrawing.cs

/*******************************************************************************************
*
*   raylib [shapes] example - splines drawing
*
*   Example complexity rating: [★★★☆] 3/4
*
*   Example originally created with raylib 5.0, last time updated with raylib 5.0
*
*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
*   BSD-like license that allows static linking with closed source software
*
*   Copyright (c) 2023-2025 Ramon Santamaria (@raysan5)
*
********************************************************************************************/

namespace Examples.Shapes;

public partial class SplinesDrawing : IExample
{
    private const int screenWidth = 800;
    private const int screenHeight = 450;

    private const int MAX_SPLINE_POINTS = 32;

    public string Name => "Shapes / Splines Drawing";

    public string Title => "raylib [shapes] example - splines drawing";

    public ConfigFlags ConfigFlags => ConfigFlags.Msaa4xHint;

    //----------------------------------------------------------------------------------
    // Types and Structures Definition
    //----------------------------------------------------------------------------------
    // Cubic Bezier spline control points
    // NOTE: Every segment has two control points
    private struct ControlPoint
    {
        public Vector2 start;
        public Vector2 end;
    }

    // Spline types
    private const int SPLINE_LINEAR = 0;      // Linear
    private const int SPLINE_BASIS = 1;       // B-Spline
    private const int SPLINE_CATMULLROM = 2;  // Catmull-Rom
    private const int SPLINE_BEZIER = 3;      // Cubic Bezier

    private Vector2[] points;
    private Vector2[] pointsInterleaved;

    private int pointCount;
    private int selectedPoint;
    private int focusedPoint;
    private int selectedControlIndex;   // -1 when none
    private bool selectedControlStart;
    private int focusedControlIndex;    // -1 when none
    private bool focusedControlStart;

    private ControlPoint[] control;

    // Spline config variables
    private float splineThickness;
    private int splineTypeActive; // 0-Linear, 1-BSpline, 2-CatmullRom, 3-Bezier
    private bool splineTypeEditMode;
    private bool splineHelpersActive;

    // Minimal raygui-like global lock
    private static bool guiLocked;

    public void Init()
    {
        points = new Vector2[MAX_SPLINE_POINTS];
        points[0] = new Vector2(50.0f, 400.0f);
        points[1] = new Vector2(160.0f, 220.0f);
        points[2] = new Vector2(340.0f, 380.0f);
        points[3] = new Vector2(520.0f, 60.0f);
        points[4] = new Vector2(710.0f, 260.0f);

        // Array required for spline bezier-cubic,
        // including control points interleaved with start-end segment points
        pointsInterleaved = new Vector2[3 * (MAX_SPLINE_POINTS - 1) + 1];

        pointCount = 5;
        selectedPoint = -1;
        focusedPoint = -1;
        selectedControlIndex = -1;
        focusedControlIndex = -1;

        // Cubic Bezier control points initialization
        control = new ControlPoint[MAX_SPLINE_POINTS - 1];
        for (int i = 0; i < pointCount - 1; i++)
        {
            control[i].start = new Vector2(points[i].X + 50, points[i].Y);
            control[i].end = new Vector2(points[i + 1].X - 50, points[i + 1].Y);
        }

        splineThickness = 8.0f;
        splineTypeActive = SPLINE_LINEAR;
        splineTypeEditMode = false;
        splineHelpersActive = true;

        guiLocked = false;
    }

    public void Update()
    {
        // Update
        //----------------------------------------------------------------------------------
        // Spline points creation logic (at the end of spline)
        if (IsMouseButtonPressed(MouseButton.Right) && (pointCount < MAX_SPLINE_POINTS))
        {
            points[pointCount] = GetMousePosition();
            int i = pointCount - 1;
            control[i].start = new Vector2(points[i].X + 50, points[i].Y);
            control[i].end = new Vector2(points[i + 1].X - 50, points[i + 1].Y);
            pointCount++;
        }

        // Spline point focus and selection logic
        if ((selectedPoint == -1) && ((splineTypeActive != SPLINE_BEZIER) || (selectedControlIndex == -1)))
        {
            focusedPoint = -1;
            for (int i = 0; i < pointCount; i++)
            {
                if (CheckCollisionPointCircle(GetMousePosition(), points[i], 8.0f))
                {
                    focusedPoint = i;
                    break;
                }
            }
            if (IsMouseButtonPressed(MouseButton.Left))
            {
                selectedPoint = focusedPoint;
            }
        }

        // Spline point movement logic
        if (selectedPoint >= 0)
        {
            points[selectedPoint] = GetMousePosition();
            if (IsMouseButtonReleased(MouseButton.Left))
            {
                selectedPoint = -1;
            }
        }

        // Cubic Bezier spline control points logic
        if ((splineTypeActive == SPLINE_BEZIER) && (focusedPoint == -1))
        {
            // Spline control point focus and selection logic
            if (selectedControlIndex == -1)
            {
                focusedControlIndex = -1;
                for (int i = 0; i < pointCount - 1; i++)
                {
                    if (CheckCollisionPointCircle(GetMousePosition(), control[i].start, 6.0f))
                    {
                        focusedControlIndex = i;
                        focusedControlStart = true;
                        break;
                    }
                    else if (CheckCollisionPointCircle(GetMousePosition(), control[i].end, 6.0f))
                    {
                        focusedControlIndex = i;
                        focusedControlStart = false;
                        break;
                    }
                }
                if (IsMouseButtonPressed(MouseButton.Left))
                {
                    selectedControlIndex = focusedControlIndex;
                    selectedControlStart = focusedControlStart;
                }
            }

            // Spline control point movement logic
            if (selectedControlIndex != -1)
            {
                if (selectedControlStart)
                {
                    control[selectedControlIndex].start = GetMousePosition();
                }
                else
                {
                    control[selectedControlIndex].end = GetMousePosition();
                }

                if (IsMouseButtonReleased(MouseButton.Left))
                {
                    selectedControlIndex = -1;
                }
            }
        }

        // Spline selection logic
        if (IsKeyPressed(KeyboardKey.One))
        {
            splineTypeActive = 0;
        }
        else if (IsKeyPressed(KeyboardKey.Two))
        {
            splineTypeActive = 1;
        }
        else if (IsKeyPressed(KeyboardKey.Three))
        {
            splineTypeActive = 2;
        }
        else if (IsKeyPressed(KeyboardKey.Four))
        {
            splineTypeActive = 3;
        }

        // Clear selection when changing to a spline without control points
        if (IsKeyPressed(KeyboardKey.One) || IsKeyPressed(KeyboardKey.Two) || IsKeyPressed(KeyboardKey.Three))
        {
            selectedControlIndex = -1;
        }
        //----------------------------------------------------------------------------------

        // Draw
        //----------------------------------------------------------------------------------
        BeginDrawing();

        ClearBackground(Color.RayWhite);

        if (splineTypeActive == SPLINE_LINEAR)
        {
            // Draw spline: linear
            DrawSplineLinear(points, pointCount, splineThickness, Color.Red);
        }
        else if (splineTypeActive == SPLINE_BASIS)
        {
            // Draw spline: basis
            DrawSplineBasis(points, pointCount, splineThickness, Color.Red);  // Provide connected points array
        }
        else if (splineTypeActive == SPLINE_CATMULLROM)
        {
            // Draw spline: catmull-rom
            DrawSplineCatmullRom(points, pointCount, splineThickness, Color.Red); // Provide connected points array
        }
        else if (splineTypeActive == SPLINE_BEZIER)
        {
            // NOTE: Cubic-bezier spline requires the 2 control points of each segment to be
            // provided interleaved with the start and end point of every segment
            for (int i = 0; i < (pointCount - 1); i++)
            {
                pointsInterleaved[3 * i] = points[i];
                pointsInterleaved[3 * i + 1] = control[i].start;
                pointsInterleaved[3 * i + 2] = control[i].end;
            }

            pointsInterleaved[3 * (pointCount - 1)] = points[pointCount - 1];

            // Draw spline: cubic-bezier (with control points)
            DrawSplineBezierCubic(pointsInterleaved, 3 * (pointCount - 1) + 1, splineThickness, Color.Red);

            // Draw spline control points
            for (int i = 0; i < pointCount - 1; i++)
            {
                // Every cubic bezier point have two control points
                DrawCircleV(control[i].start, 6, Color.Gold);
                DrawCircleV(control[i].end, 6, Color.Gold);
                if (focusedControlIndex == i && focusedControlStart)
                {
                    DrawCircleV(control[i].start, 8, Color.Green);
                }
                else if (focusedControlIndex == i && !focusedControlStart)
                {
                    DrawCircleV(control[i].end, 8, Color.Green);
                }

                DrawLineEx(points[i], control[i].start, 1.0f, Color.LightGray);
                DrawLineEx(points[i + 1], control[i].end, 1.0f, Color.LightGray);

                // Draw spline control lines
                DrawLineV(points[i], control[i].start, Color.Gray);
                DrawLineV(control[i].end, points[i + 1], Color.Gray);
            }
        }

        if (splineHelpersActive)
        {
            // Draw spline point helpers
            for (int i = 0; i < pointCount; i++)
            {
                DrawCircleLinesV(points[i], (focusedPoint == i) ? 12.0f : 8.0f, (focusedPoint == i) ? Color.Blue : Color.DarkBlue);
                if ((splineTypeActive != SPLINE_LINEAR) &&
                    (splineTypeActive != SPLINE_BEZIER) &&
                    (i < pointCount - 1))
                {
                    DrawLineV(points[i], points[i + 1], Color.Gray);
                }

                DrawText($"[{points[i].X:F0}, {points[i].Y:F0}]", (int)points[i].X, (int)points[i].Y + 10, 10, Color.Black);
            }
        }

        // Check all possible UI states that require controls lock
        if (splineTypeEditMode || (selectedPoint != -1) || (selectedControlIndex != -1))
        {
            GuiLock();
        }

        // Draw spline config
        GuiLabel(new Rectangle(12, 62, 140, 24), $"Spline thickness: {(int)splineThickness}");
        GuiSliderBar(new Rectangle(12, 60 + 24, 140, 16), null, null, ref splineThickness, 1.0f, 40.0f);

        GuiCheckBox(new Rectangle(12, 110, 20, 20), "Show point helpers", ref splineHelpersActive);

        if (splineTypeEditMode)
        {
            GuiUnlock();
        }

        GuiLabel(new Rectangle(12, 10, 140, 24), "Spline type:");
        if (GuiDropdownBox(new Rectangle(12, 8 + 24, 140, 28), "LINEAR;BSPLINE;CATMULLROM;BEZIER", ref splineTypeActive, splineTypeEditMode))
        {
            splineTypeEditMode = !splineTypeEditMode;
        }

        GuiUnlock();

        EndDrawing();
        //----------------------------------------------------------------------------------
    }

    public void Unload()
    {
    }

    //----------------------------------------------------------------------------------
    // Minimal raygui-like widgets (plain raylib re-implementation)
    //----------------------------------------------------------------------------------
    private static void GuiLock() => guiLocked = true;
    private static void GuiUnlock() => guiLocked = false;

    private static void GuiLabel(Rectangle bounds, string text)
    {
        DrawText(text, (int)bounds.X, (int)(bounds.Y + bounds.Height / 2 - 5), 10, Color.DarkGray);
    }

    private static void GuiSliderBar(Rectangle bounds, string textLeft, string textRight, ref float value, float minValue, float maxValue)
    {
        Vector2 mouse = GetMousePosition();
        bool hover = CheckCollisionPointRec(mouse, bounds);
        if (!guiLocked && hover && IsMouseButtonDown(MouseButton.Left))
        {
            value = minValue + ((mouse.X - bounds.X) / bounds.Width) * (maxValue - minValue);
            if (value < minValue)
            {
                value = minValue;
            }

            if (value > maxValue)
            {
                value = maxValue;
            }
        }

        DrawRectangleRec(bounds, Color.LightGray);
        float pct = (value - minValue) / (maxValue - minValue);
        DrawRectangleRec(new Rectangle(bounds.X, bounds.Y, bounds.Width * pct, bounds.Height), Color.SkyBlue);
        DrawRectangleLinesEx(bounds, 1, Color.Gray);
        if (!string.IsNullOrEmpty(textLeft))
        {
            DrawText(textLeft, (int)bounds.X - MeasureText(textLeft, 10) - 5, (int)(bounds.Y + bounds.Height / 2 - 5), 10, Color.DarkGray);
        }

        if (!string.IsNullOrEmpty(textRight))
        {
            DrawText(textRight, (int)(bounds.X + bounds.Width + 5), (int)(bounds.Y + bounds.Height / 2 - 5), 10, Color.DarkGray);
        }
    }

    private static void GuiCheckBox(Rectangle bounds, string text, ref bool active)
    {
        Vector2 mouse = GetMousePosition();
        bool hover = CheckCollisionPointRec(mouse, bounds);
        if (!guiLocked && hover && IsMouseButtonPressed(MouseButton.Left))
        {
            active = !active;
        }

        DrawRectangleLinesEx(bounds, 1, hover ? Color.DarkBlue : Color.Gray);
        if (active)
        {
            DrawRectangle((int)bounds.X + 4, (int)bounds.Y + 4, (int)bounds.Width - 8, (int)bounds.Height - 8, Color.DarkGray);
        }

        if (text != null)
        {
            DrawText(text, (int)(bounds.X + bounds.Width + 8), (int)(bounds.Y + bounds.Height / 2 - 5), 10, Color.DarkGray);
        }
    }

    private static bool GuiDropdownBox(Rectangle bounds, string text, ref int active, bool editMode)
    {
        string[] items = text.Split(';');
        bool pressed = false;
        Vector2 mouse = GetMousePosition();
        bool clickable = !guiLocked;

        bool hoverMain = CheckCollisionPointRec(mouse, bounds);
        DrawRectangleRec(bounds, editMode ? Color.SkyBlue : (hoverMain ? Color.LightGray : Color.RayWhite));
        DrawRectangleLinesEx(bounds, 1, editMode ? Color.Blue : Color.Gray);
        DrawText(items[active], (int)bounds.X + 6, (int)(bounds.Y + bounds.Height / 2 - 5), 10, Color.DarkGray);

        if (editMode)
        {
            for (int i = 0; i < items.Length; i++)
            {
                Rectangle itemRec = new Rectangle(bounds.X, bounds.Y + bounds.Height * (i + 1), bounds.Width, bounds.Height);
                bool hoverItem = CheckCollisionPointRec(mouse, itemRec);
                DrawRectangleRec(itemRec, hoverItem ? Color.SkyBlue : Color.RayWhite);
                DrawRectangleLinesEx(itemRec, 1, Color.Gray);
                DrawText(items[i], (int)itemRec.X + 6, (int)(itemRec.Y + itemRec.Height / 2 - 5), 10, Color.DarkGray);
                if (clickable && hoverItem && IsMouseButtonPressed(MouseButton.Left))
                {
                    active = i;
                    pressed = true;
                }
            }
        }

        if (clickable && hoverMain && IsMouseButtonPressed(MouseButton.Left))
        {
            pressed = true;
        }

        return pressed;
    }

    public static int Main()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        SetConfigFlags(ConfigFlags.Msaa4xHint);
        InitWindow(screenWidth, screenHeight, "raylib [shapes] example - splines drawing");

        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------

        var game = new SplinesDrawing();
        game.Init();

        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            game.Update();
        }

        game.Unload();

        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------

        return 0;
    }
}