dragon.nt

/**
 * Developed primarily by gpt-3.5-turbo/Sage! Thanks, poe.com!
 */
module dragon;

macro import std.macro.cimport;
macro import std.macro.listcomprehension;

import std.math;

import c_header("raylib.h");
pragma(lib, "raylib");
version (windows) {
    pragma(lib, "gdi32");
    pragma(lib, "glfw3");
    pragma(lib, "winmm");
} else {
    pragma(lib, "glfw");
}
pragma(lib, "m");
pragma(lib, "pthread");

alias vec2f = Vector(float, 2);

class Button {
    private Rectangle rec;

    private string label;

    private ColorFade color;

    this(this.rec, this.label, this.color) {}

    bool clicked() => IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && hovered;

    bool hovered() => GetMousePosition.CheckCollisionPointRec(this.rec);

    void draw() {
        this.color.update(hovered);
        DrawRectangleRec(rec, this.color.currentValue);
        import std.string : toStringz;
        auto labelPtr = label.toStringz;
        DrawText(labelPtr,
            cast(int) (rec.x + rec.width / 2 - MeasureText(labelPtr, 20) / 2),
            cast(int) (rec.y + rec.height / 2 - 10),
            20,
            RAYWHITE,
        );
        free(labelPtr);
    }
}

class ColorFade {
    private Color normalColor, hoverColor;

    private mut float transition;

    this(this.normalColor, this.hoverColor) {
        this.transition = 0;
    }

    Color currentValue() => lerp(normalColor, hoverColor, transition);

    void update(bool active) {
        float δ = GetFrameTime * 8.0;
        if (active) transition = (transition + δ).wrap(0, 1);
        else transition = (transition - δ).wrap(0, 1);
    }
}

float wrap(float a, float from, float to) {
    return from if a < from else to if a > to else a;
}

void draw(vec2f from, vec2f to, float depth) {
    auto delta = to - from;
    auto perpendicular = vec2f(delta.y, -delta.x);
    auto midpoint = from + delta * 0.5f;
    auto controlPoint = midpoint + perpendicular * 0.5f;
    if (depth < 1) {
        auto blendDepth = sin(depth * cast(float) pi / 2);
        auto fadeMid = blend(midpoint, controlPoint, blendDepth);

        DrawLineEx(from.fromVec, fadeMid.fromVec, 3, BLACK);
        DrawLineEx(fadeMid.fromVec, to.fromVec, 3, BLACK);
    } else {
        draw(from, controlPoint, depth - 1);
        draw(to, controlPoint, depth - 1);
    }
}

T blend(T)(T a, T b, float by) {
    return a + (b - a) * by;
}

void main() {
    SetConfigFlags(FLAG_WINDOW_RESIZABLE);
    InitWindow(width=1200, height=1000, "Dragon Curve");
    SetTargetFPS(60);

    mut float depth = 0;
    mut int targetDepth = 0;

    auto plusButton = new Button(Rectangle(10, 10, 40, 40), "+",
        new ColorFade(GRAY, BLACK));
    auto minusButton = new Button(Rectangle(10 + 40 + 10, 10, 40, 40), "-",
        new ColorFade(GRAY, BLACK));

    while (!WindowShouldClose) {
        if (plusButton.clicked) targetDepth++;
        if (minusButton.clicked && targetDepth >= 1) targetDepth--;
        auto from = vec2f(GetScreenWidth * 0.25f, GetScreenHeight * 0.65f);
        auto to = vec2f(GetScreenWidth * 0.85f, GetScreenHeight * 0.65f);
        BeginDrawing;
        ClearBackground(RAYWHITE);
        draw(from, to, depth);
        plusButton.draw;
        minusButton.draw;
        EndDrawing;
        depth += (targetDepth - depth) * GetFrameTime * 6.0;
    }

    CloseWindow;
}

alias toVec = v => vec2f(v.x, v.y);
alias fromVec = v => Vector2(v.x, v.y);

alias RAYWHITE = color(245, 245, 245, 255);
alias LIGHTGRAY = color(200, 200, 200, 255);
alias GRAY = color(128, 128, 128, 255);
alias BLACK = color(0, 0, 0, 255);

alias color = (r, g, b, a) => Color(
    cast(char) r, cast(char) g, cast(char) b, cast(char) a);

Color lerp(Color x, Color y, float t) {
    int i(char c) => cast(int) c;
    int f(float f) => cast(int) f;
    int r = (x.r.i + (y.r.i - x.r) * t).f;
    int g = (x.g.i + (y.g.i - x.g) * t).f;
    int b = (x.b.i + (y.b.i - x.b) * t).f;
    int a = (x.a.i + (y.a.i - x.a) * t).f;
    return color(r, g, b, a);
}