Attached sketches

public override void Settings() =>
    Attach(WindowTarget.Terminal, mode: AttachMode.EachWindow);

# >>> DanaProcessing shell signals >>>
# Lets DanaProcessing sketches attached to this terminal react to commands.
# Works with oh-my-posh, starship, Abyss Tide and custom prompts: it wraps whatever
# prompt is active, wraps it again whenever something replaces it, and keeps $? and
# $LASTEXITCODE for the prompt underneath. Check: Get-EventSubscriber shows PowerShell.OnIdle.
if (-not (Test-Path variable:global:__danaWrap)) {
    $global:__danaSignalFile = Join-Path $env:LOCALAPPDATA 'DanaProcessing\shell-signal.txt'
    New-Item -ItemType Directory -Force (Split-Path $global:__danaSignalFile) | Out-Null
    $global:__danaLastHistoryId = (Get-History -Count 1).Id
    $global:__danaInPrompt = $false
    function global:dana-signal([string]$name) {
        [IO.File]::WriteAllText($global:__danaSignalFile, "signal $name $PID")
    }
    $global:__danaWrap = {
        # Already in the prompt chain? Walk down through the wrappers (ours, Abyss Tide's, others
        # that follow the '# __PromptWrapper:<variable>' convention) looking for this one.
        $p = $function:prompt
        for ($i = 0; $p -and $i -lt 30; $i++) {
            $t = "$p"
            if ($t -match '__DanaShellSignals|__danaSignalFile') { return }   # this hook (or an older copy)
            if ($t -match '# __PromptWrapper:(\w+)') { $name = $Matches[1] }
            elseif ($t -match '__AbyssTideMarker') { $name = '__AbyssTidePrompt' }
            else { break }
            $inner = $null
            if ($p.Module) { $inner = $p.Module.SessionState.PSVariable.GetValue($name) }
            if (-not $inner) { $inner = Get-Variable -Scope Global -Name $name -ValueOnly -ErrorAction Ignore }
            $p = $inner
        }
        $inner = $function:prompt
        $function:global:prompt = {
            # __PromptWrapper:inner
            # __DanaShellSignals
            $ok = $?; $code = $global:LASTEXITCODE
            if ($global:__danaInPrompt) { return "PS $($executionContext.SessionState.Path.CurrentLocation)> " }
            $global:__danaInPrompt = $true
            try {
                try {
                    $last = Get-History -Count 1
                    if ($last -and $last.Id -ne $global:__danaLastHistoryId) {
                        $global:__danaLastHistoryId = $last.Id
                        $line = if ($ok) { "ok 0 $PID" } elseif ($code) { "error $code $PID" } else { "error 1 $PID" }
                        [IO.File]::WriteAllText($global:__danaSignalFile, $line)
                    }
                } catch { }
                # The prompt underneath reads $? and $LASTEXITCODE too: hand them back.
                $global:LASTEXITCODE = $code
                if (-not $ok) { Write-Error '' -ErrorAction Ignore }
                & $inner
            } finally {
                $global:__danaInPrompt = $false
            }
        }.GetNewClosure()
    }
    & $global:__danaWrap
    $null = Register-EngineEvent -SourceIdentifier PowerShell.OnIdle -Action { & $global:__danaWrap }
}
# <<< DanaProcessing shell signals <<<

// Water in the terminal: drag Windows Terminal around and the water inside
// sloshes, hits the walls and splashes -- the same trick as a glass of
// water in a moving car: what's inside feels the opposite of
// TargetAcceleration.
//
// 1. Open Windows Terminal and press Run.
// 2. Drag the window and let go suddenly. Shake it. Yank it down: the water jumps.
// 3. Type in the terminal: every key drops a drop, Enter makes a splash.
//    Click the water to drop one where you click.
// 4. Switch to another window: the water dims until you come back.
//
// ListenToTargetKeys()/ListenToTargetMouse() read keys typed into the terminal
// and clicks over it (the terminal still gets all of them). Windows only.
public class TerminalWater : AttachedSketch
{
    const float Cell = 8;          // width of one water column, in pixels
    const float Gravity = 900;     // px/s²
    const float Inertia = 0.28f;   // how strongly the window's motion pushes the water
    const float FillLevel = 0.3f;  // how full the window is

    float[] _h = new float[0];     // water height per column
    float[] _u = new float[0];     // flow between columns
    float[] _flux = new float[0];
    int _cols;
    float _dim = 1;
    readonly List<PVector> _drops = new();
    readonly List<PVector> _dropSpeeds = new();

    public override void Settings() => Attach(WindowTarget.Terminal);

    public override void Setup()
    {
        ListenToTargetKeys();
        ListenToTargetMouse();
        Rebuild();
    }

    public override void WindowResized() => Rebuild();

    void Rebuild()
    {
        _cols = Math.Max(8, (int)(Width / Cell));
        _h = new float[_cols];
        _u = new float[_cols + 1];
        _flux = new float[_cols + 1];
        for (int i = 0; i < _cols; i++)
            _h[i] = Height * FillLevel;
    }

    // --- input from the terminal -------------------------------------------

    public override void KeyTyped() => Drop(Random(Width), 1);

    public override void KeyPressed()
    {
        if (Key == ENTER)
            for (int i = 0; i < 6; i++)
                Drop(Random(Width), 2);
    }

    public override void MousePressed() => Drop(MouseX, 1.5f);

    public override void TargetShown() => Splash(_cols / 2, 60); // welcome back

    void Drop(float x, float size)
    {
        _drops.Add(new PVector(x, -10, size));
        _dropSpeeds.Add(new PVector(Random(-20, 20), Random(0, 80)));
    }

    void Splash(int col, float amount)
    {
        if (col < 1 || col >= _cols - 1) return;
        float take = Math.Min(amount, _h[col] * 0.5f);
        _h[col] -= take;               // a dent in the surface...
        _h[col - 1] += take / 2;       // ...pushes water to both sides: a wave
        _h[col + 1] += take / 2;
    }

    // --- simulation -----------------------------------------------------------

    public override void Draw()
    {
        Clear();
        float dt = DeltaTime;   // real seconds: same speed at 60 fps or in eco mode
        var a = TargetAcceleration;
        float fx = -a.X * Inertia;                                        // sideways push
        float g = Constrain(Gravity - a.Y * Inertia, Gravity * 0.25f, Gravity * 4);  // moving down = lighter

        Step(dt, fx, g);
        UpdateDrops(dt, g);

        _dim = Lerp(_dim, IsTargetFocused ? 1 : 0.45f, 0.08f);
        DrawWater();
        DrawDrops();
    }

    void Step(float dt, float fx, float g)
    {
        int sub = 8;
        float sdt = dt / sub;
        float damp = Exp(-0.8f * sdt);
        float maxU = 0.45f * Cell / sdt;
        for (int s = 0; s < sub; s++)
        {
            for (int i = 1; i < _cols; i++)
            {
                float v = _u[i] + sdt * (-g * (_h[i] - _h[i - 1]) / Cell + fx);
                if (_h[i] < 0.5f && _h[i - 1] < 0.5f) v = 0;
                _u[i] = Constrain(v * damp, -maxU, maxU);
            }
            _u[0] = _u[_cols] = 0;   // the window's walls
            for (int i = 1; i < _cols; i++)
                _flux[i] = _u[i] * (_u[i] > 0 ? _h[i - 1] : _h[i]);
            for (int i = 0; i < _cols; i++)
                _h[i] = Constrain(_h[i] - sdt * (_flux[i + 1] - _flux[i]) / Cell, 0, Height);
        }

        // Keep the volume constant (rounding slowly leaks it).
        float target = FillLevel * Height * _cols, vol = 0;
        foreach (var h in _h) vol += h;
        if (vol > 1)
            for (int i = 0; i < _cols; i++) _h[i] *= 1 + (target / vol - 1) * 0.1f;
    }

    void UpdateDrops(float dt, float g)
    {
        for (int i = _drops.Count - 1; i >= 0; i--)
        {
            var p = _drops[i];
            var v = _dropSpeeds[i];
            v.Y += g * dt;
            p.X += v.X * dt;
            p.Y += v.Y * dt;
            int col = Constrain((int)(p.X / Cell), 0, _cols - 1);
            if (p.Y >= Height - _h[col])
            {
                Splash(col, 6 * p.Z);
                _drops.RemoveAt(i);
                _dropSpeeds.RemoveAt(i);
            }
        }
    }

    void DrawWater()
    {
        // The body: one polygon through the middle of every column's top.
        NoStroke();
        Fill(20, 90, 170, 110 * _dim);
        BeginShape();
        Vertex(0, Height);
        Vertex(0, Height - _h[0]);
        for (int i = 0; i < _cols; i++)
            Vertex(i * Cell + Cell / 2, Height - _h[i]);
        Vertex(Width, Height - _h[_cols - 1]);
        Vertex(Width, Height);
        EndShape(close: true);

        // The surface line, brighter (foam) where it's steep.
        StrokeWeight(2);
        for (int i = 1; i < _cols; i++)
        {
            float steep = Abs(_h[i] - _h[i - 1]);
            Stroke(150, 230, 255, (110 + Math.Min(steep * 25, 145)) * _dim);
            Line((i - 1) * Cell + Cell / 2, Height - _h[i - 1], i * Cell + Cell / 2, Height - _h[i]);
        }
    }

    void DrawDrops()
    {
        NoStroke();
        Fill(170, 230, 255, 220 * _dim);
        foreach (var p in _drops)
            Ellipse(p.X, p.Y, 4 * p.Z, 6 * p.Z);
    }
}

// Flow field in the terminal: particles drift along a vector field drawn
// behind Windows Terminal's text -- and every terminal window gets a field of its own.
//
// Idea from "Vector field with particles" by jcponcemath on OpenProcessing
// (openprocessing.org/sketch/3017881); this is a fresh take written for Dana.
//
// 1. Open one or more Windows Terminal windows and press Run.
// 2. Drag a terminal: the particles lag behind (inertia, -TargetAcceleration)
//    and the field twists with the speed (TargetVelocity). Let go: it untwists.
// 3. Run a command that fails (try:  cmd /c exit 3): the field becomes a red
//    storm and shows the exit code. A command that works calms it with a cyan
//    pulse. dana-signal reset draws a new field.
//    Commands need the PowerShell snippet once: run ShellSignals.InstallForPowerShell()
//    (or use the tray menu of the exported app), then open a new terminal.
public class TerminalFlowField : AttachedSketch
{
    const int Tail = 10;  // positions kept per particle for its trail

    sealed class Particle
    {
        public float X, Y, VX, VY, Age, Life;
        public readonly float[] TX = new float[Tail], TY = new float[Tail];
        public int Head;
    }

    readonly List<Particle> _particles = new();

    // Trails are drawn in batches: every segment of the same color and alpha goes
    // into one shape (BeginShape(ShapeKind.Lines) = one Skia call) instead of a
    // Stroke() + Line() per segment, thousands of calls a frame otherwise.
    const int HueSteps = 24, AlphaSteps = 8;   // 15° hue steps, 8 alpha levels
    readonly List<float>[] _batches = Enumerable.Range(0, HueSteps * (AlphaSteps + 1)).Select(_ => new List<float>()).ToArray();
    float _a, _b, _swirl, _phase;   // the field's shape: different per window (each instance has its own seed)
    float _storm;                   // 1 right after a failed command, fades out
    float _calm;                    // 1 right after a command that worked
    float _twist;                   // follows how fast the window is dragged
    float _ringRadius = -1, _ringHue;

    public override void Settings() =>
        Attach(WindowTarget.Terminal, mode: AttachMode.EachWindow);

    public override void Setup()
    {
        ListenToShell();
        ColorMode(ColorSpaceMode.HSB, 360, 100, 100, 255);
        TextAlign(TextAlignH.Right, TextAlignV.Bottom);
        NewField();
        FitParticles();
    }

    public override void WindowResized() => FitParticles();

    void NewField()
    {
        _a = Random(1.5f, 3.5f);
        _b = Random(1.5f, 3.5f);
        _swirl = Random(-0.8f, 0.8f);
        _phase = Random(TWO_PI);
    }

    void FitParticles()
    {
        int wanted = Constrain(Width * Height / 900, 150, 1000);
        while (_particles.Count < wanted)
            _particles.Add(Respawn(new Particle()));
        if (_particles.Count > wanted)
            _particles.RemoveRange(wanted, _particles.Count - wanted);
    }

    Particle Respawn(Particle p)
    {
        p.X = Random(Width);
        p.Y = Random(Height);
        p.VX = p.VY = 0;
        p.Age = 0;
        p.Life = Random(2, 6);
        for (int i = 0; i < Tail; i++) { p.TX[i] = p.X; p.TY[i] = p.Y; }
        return p;
    }

    // --- the vector field -------------------------------------------------------

    (float X, float Y) Field(float x, float y, float t)
    {
        // Smooth swirls in coordinates centred on the window, scaled to it.
        float s = Math.Max(1, Math.Min(Width, Height));
        float u = (x - Width / 2f) / s * 2, v = (y - Height / 2f) / s * 2;
        float fx = Sin(_a * v + _phase + t * 0.2f) - _swirl * v;
        float fy = Cos(_b * u - _phase + t * 0.15f) + _swirl * u;

        // After an error: noisy turbulence on top.
        if (_storm > 0)
        {
            float n = Noise(x * 0.008f + t * 0.4f, y * 0.008f) * TWO_PI * 3;
            fx += Cos(n) * 2.5f * _storm;
            fy += Sin(n) * 2.5f * _storm;
        }

        // While the window is dragged: the whole field turns.
        float c = Cos(_twist), sn = Sin(_twist);
        return (fx * c - fy * sn, fx * sn + fy * c);
    }

    // --- the shell ----------------------------------------------------------------

    public override void CommandFinished()
    {
        if (LastCommandOk)
        {
            _calm = 1;
            Ring(170);
        }
        else
        {
            _storm = 1;
            Ring(5);
            foreach (var p in _particles)   // a kick in every direction
            {
                float a = Random(TWO_PI);
                p.VX += Cos(a) * 250;
                p.VY += Sin(a) * 250;
            }
        }
    }

    public override void OnShellSignal(string name)
    {
        if (name == "reset")
        {
            NewField();
            foreach (var p in _particles) Respawn(p);
            Ring(270);
        }
    }

    void Ring(float hue)
    {
        _ringRadius = 0;
        _ringHue = hue;
    }

    // --- every frame ----------------------------------------------------------------

    void DrawBatches()
    {
        // StrokeWeight(0) is a hairline: exactly one physical pixel at any DPI,
        // and Skia's fastest antialiased line -- about 10x cheaper than 1.6 px
        // with round ends (the trails are thousands of tiny segments).
        StrokeWeight(0);
        NoFill();
        for (int b = 0; b < _batches.Length; b++)
        {
            var batch = _batches[b];
            if (batch.Count == 0) continue;
            int hueStep = b / (AlphaSteps + 1), alphaStep = b % (AlphaSteps + 1);
            Stroke(hueStep * (360f / HueSteps), 65 + 35 * _storm, 100, 255f * alphaStep / AlphaSteps);
            BeginShape(ShapeKind.Lines);
            for (int i = 0; i < batch.Count; i += 2)
                Vertex(batch[i], batch[i + 1]);
            EndShape();
            batch.Clear();
        }
    }

    public override void Draw()
    {
        Clear(); // transparent: the terminal stays visible underneath
        float dt = DeltaTime;   // real seconds: same speed at 60 fps or in eco mode
        float t = Millis() / 1000f;

        _storm = Math.Max(0, _storm - dt / 2.5f);
        _calm = Math.Max(0, _calm - dt / 1.5f);
        _twist = Lerp(_twist, Constrain(TargetVelocity.X / 1500f, -1.3f, 1.3f), Math.Min(1, dt * 4));
        var push = TargetAcceleration;
        float speed = 110 * (1 + 1.5f * _storm) * (1 - 0.5f * _calm);
        float follow = Math.Min(1, dt * 3);

        foreach (var p in _particles)
        {
            var (fx, fy) = Field(p.X, p.Y, t);
            // Follow the field, and feel the window's motion the other way round.
            p.VX += (fx * speed - p.VX) * follow - push.X * 0.15f * dt;
            p.VY += (fy * speed - p.VY) * follow - push.Y * 0.15f * dt;
            p.X += p.VX * dt;
            p.Y += p.VY * dt;
            p.Age += dt;
            p.Head = (p.Head + 1) % Tail;
            p.TX[p.Head] = p.X;
            p.TY[p.Head] = p.Y;

            if (p.Age > p.Life || p.X < -20 || p.Y < -20 || p.X > Width + 20 || p.Y > Height + 20)
            {
                Respawn(p);
                continue;
            }

            // Blue-violet by direction; red in a storm; cyan when calm.
            float hue = 190 + 50 * Sin(Atan2(p.VY, p.VX));
            hue = Lerp(hue, 5, _storm);
            hue = Lerp(hue, 175, _calm * (1 - _storm));
            float fade = Math.Min(1, Math.Min(p.Age * 2, (p.Life - p.Age) * 2));
            int hueStep = ((int)Math.Round(hue / (360f / HueSteps)) % HueSteps + HueSteps) % HueSteps;
            for (int k = 1; k < Tail; k++)   // oldest segment first, fainter
            {
                int alphaStep = (int)Math.Round(fade * k / Tail * AlphaSteps);
                if (alphaStep == 0) continue;
                int i0 = (p.Head + k) % Tail, i1 = (p.Head + k + 1) % Tail;
                var batch = _batches[hueStep * (AlphaSteps + 1) + alphaStep];
                batch.Add(p.TX[i0]); batch.Add(p.TY[i0]); batch.Add(p.TX[i1]); batch.Add(p.TY[i1]);
            }
        }
        DrawBatches();

        // The pulse after a command, from the centre outwards.
        if (_ringRadius >= 0)
        {
            float max = Dist(0, 0, Width, Height) / 2;
            _ringRadius += 700 * dt;
            Stroke(_ringHue, 80, 100, 220 * (1 - _ringRadius / max));
            StrokeWeight(3);
            Ellipse(Width / 2f, Height / 2f, _ringRadius * 2, _ringRadius * 2);
            if (_ringRadius > max) _ringRadius = -1;
        }

        if (_storm > 0)
        {
            NoStroke();
            Fill(5, 80, 100, 255 * _storm);
            TextSize(28);
            Text($"exit {LastExitCode}", Width - 16, Height - 12);
        }
    }
}

// Cloth on the terminal: the whole Windows Terminal window is covered by a
// sheet of see-through cloth hanging from its top edge. Move the window and
// the cloth swings, ripples and folds.
//
// Idea from "Cloth!!" by Millie on OpenProcessing (openprocessing.org/sketch/2999200);
// its code is hidden, so this is written from scratch for Dana: a grid of
// points joined by sticks (Verlet integration), pinned along the top, drawn
// as one shaded mesh plus a fine weave.
//
// 1. Open Windows Terminal and press Run.
// 2. Drag the terminal: the cloth lags behind and swings (-TargetAcceleration).
//    Shake it hard and it flaps.
// 3. Move the mouse through it to push it; click to cut a hole (the click
//    still reaches the terminal). Too much stretch tears it too.
// 4. A command that fails rips a hole and flashes red; one that works sends a
//    gust of wind through it. dana-signal reset hangs a new cloth.
public class TerminalCloth : AttachedSketch
{
    sealed class Point
    {
        public float X, Y, OldX, OldY, RestX;
        public bool Pinned;
    }

    sealed class Stick
    {
        public Point A, B;
        public float Length;
        public bool Broken;
    }

    const float Gravity = 500;       // px/s²
    const float Inertia = 0.7f;      // how much the window's motion moves the cloth
    const float TearStretch = 3f;    // a stick breaks past this many times its length

    readonly List<Point> _points = new();
    readonly List<Stick> _sticks = new();
    Stick[] _right = new Stick[0], _down = new Stick[0];   // the stick to the right of / below each point
    int _cols, _rows;
    float _redness;                  // 1 right after a failed command
    float _gust;                     // 1 right after a command that worked

    public override void Settings() => Attach(WindowTarget.Terminal);

    public override void Setup()
    {
        ListenToShell();
        ListenToTargetMouse();
        Hang();
    }

    public override void WindowResized() => Hang();

    // A cloth exactly the size of the window, its top row pinned to the top edge.
    void Hang()
    {
        _points.Clear();
        _sticks.Clear();
        _cols = Constrain(Width / 28, 12, 60) + 1;
        _rows = Constrain(Height / 28, 8, 40) + 1;
        float sx = Width / (float)(_cols - 1), sy = Height / (float)(_rows - 1);
        _right = new Stick[_cols * _rows];
        _down = new Stick[_cols * _rows];
        for (int r = 0; r < _rows; r++)
            for (int c = 0; c < _cols; c++)
            {
                float x = c * sx, y = r * sy;
                _points.Add(new Point { X = x, Y = y, OldX = x, OldY = y, RestX = x, Pinned = r == 0 });
            }
        for (int r = 0; r < _rows; r++)
            for (int c = 0; c < _cols; c++)
            {
                int i = r * _cols + c;
                if (c + 1 < _cols) _right[i] = Join(_points[i], _points[i + 1], sx);
                if (r + 1 < _rows) _down[i] = Join(_points[i], _points[i + _cols], sy);
            }
    }

    Stick Join(Point a, Point b, float length)
    {
        var s = new Stick { A = a, B = b, Length = length };
        _sticks.Add(s);
        return s;
    }

    // --- input ------------------------------------------------------------------

    public override void MousePressed() => Cut(MouseX, MouseY, 22);

    public override void CommandFinished()
    {
        if (LastCommandOk) { _gust = 1; return; }
        _redness = 1;
        Cut(Random(Width * 0.2f, Width * 0.8f), Random(Height * 0.3f, Height * 0.7f), Math.Min(Width, Height) * 0.12f);
    }

    public override void OnShellSignal(string name)
    {
        if (name == "reset") Hang();
    }

    void Cut(float x, float y, float radius)
    {
        foreach (var s in _sticks)
        {
            float mx = (s.A.X + s.B.X) / 2, my = (s.A.Y + s.B.Y) / 2;
            if (Dist(mx, my, x, y) < radius) s.Broken = true;
        }
    }

    // --- every frame ----------------------------------------------------------------

    public override void Draw()
    {
        Clear();
        float dt = Math.Min(DeltaTime, 1 / 30f);
        float t = Millis() / 1000f;
        var a = TargetAcceleration;
        _redness = Math.Max(0, _redness - dt / 2);
        _gust = Math.Max(0, _gust - dt / 1.5f);

        // A jerk of the window is felt, but capped: a real drag shouldn't throw the cloth off.
        float ax = Constrain(-a.X * Inertia, -5000, 5000), ay = Constrain(-a.Y * Inertia, -5000, 5000);
        Simulate(dt, t, ax, Gravity + ay);
        DrawMesh();
        DrawWeave();
    }

    void Simulate(float dt, float t, float ax, float ay)
    {
        bool mouseInside = MouseX >= 0 && MouseX < Width && MouseY >= 0 && MouseY < Height;
        float gustX = _gust * 2500;

        // Verlet: the velocity is just "where it was" vs "where it is".
        foreach (var p in _points)
        {
            if (p.Pinned) continue;
            float vx = (p.X - p.OldX) * 0.985f, vy = (p.Y - p.OldY) * 0.985f;
            // A light breeze so the cloth is never perfectly still, plus the gust.
            float breeze = (Noise(p.Y * 0.004f, t * 0.4f) - 0.5f) * 90 + gustX * Noise(p.Y * 0.01f, t * 3);
            p.OldX = p.X;
            p.OldY = p.Y;
            p.X += vx + (ax + breeze) * dt * dt;
            p.Y += vy + ay * dt * dt;

            // The mouse pushes the cloth away (no click needed: MouseX/MouseY follow the cursor).
            if (mouseInside)
            {
                float d = Dist(p.X, p.Y, MouseX, MouseY);
                if (d < 45 && d > 0.01f)
                {
                    p.X += (p.X - MouseX) / d * (45 - d) * 0.25f;
                    p.Y += (p.Y - MouseY) / d * (45 - d) * 0.25f;
                }
            }
        }

        // Sticks pull their two points back to their length, a few times per frame.
        for (int iteration = 0; iteration < 6; iteration++)
            foreach (var s in _sticks)
            {
                if (s.Broken) continue;
                float dx = s.B.X - s.A.X, dy = s.B.Y - s.A.Y;
                float d = Math.Max(0.001f, Sqrt(dx * dx + dy * dy));
                if (d > s.Length * TearStretch) { s.Broken = true; continue; }
                // Cloth resists stretching fully and squeezing only a little, so it can fold.
                float stiffness = d > s.Length ? 1 : 0.3f;
                float push = (d - s.Length) / d * (s.A.Pinned || s.B.Pinned ? 1 : 0.5f) * stiffness;
                if (!s.A.Pinned) { s.A.X += dx * push; s.A.Y += dy * push; }
                if (!s.B.Pinned) { s.B.X -= dx * push; s.B.Y -= dy * push; }
            }

        // Torn-off pieces that fell away stop below the window.
        foreach (var p in _points)
            if (p.Y > Height + 300) { p.Y = p.OldY = Height + 300; p.OldX = p.X; }
    }

    // --- drawing --------------------------------------------------------------------

    // The cloth itself: every quad whose four sides hold, filled with a shade for
    // how the cloth bends there -- folds darker, stretched or swung parts lighter.
    // Quads of the same shade go in one shape (one contour each): a handful of
    // draw calls for the whole window instead of one per quad.
    const int Shades = 6;
    readonly List<int>[] _byShade = Enumerable.Range(0, Shades).Select(_ => new List<int>()).ToArray();

    void DrawMesh()
    {
        foreach (var list in _byShade) list.Clear();
        for (int r = 0; r < _rows - 1; r++)
            for (int c = 0; c < _cols - 1; c++)
            {
                int i = r * _cols + c;
                if (_right[i].Broken || _down[i].Broken || _right[i + _cols].Broken || _down[i + 1].Broken) continue;
                _byShade[(int)(Light(i) * (Shades - 0.01f))].Add(i);
            }

        // Without antialiasing: much faster for shapes this big, and neighbouring
        // quads meet exactly (no faint seams). The weave drawn on top hides the edges.
        NoSmooth();
        NoStroke();
        for (int k = 0; k < Shades; k++)
        {
            if (_byShade[k].Count == 0) continue;
            float shade = k / (float)(Shades - 1);
            Fill(Lerp(60, 150, shade) + 150 * _redness,
                 Lerp(80, 190, shade) * (1 - 0.6f * _redness),
                 Lerp(150, 255, shade) * (1 - 0.5f * _redness),
                 Lerp(26, 62, Math.Abs(shade - 0.5f) * 2) + 45 * _redness);
            BeginShape();
            foreach (int i in _byShade[k])
            {
                BeginContour();
                Vertex(_points[i].X, _points[i].Y);
                Vertex(_points[i + 1].X, _points[i + 1].Y);
                Vertex(_points[i + _cols + 1].X, _points[i + _cols + 1].Y);
                Vertex(_points[i + _cols].X, _points[i + _cols].Y);
                EndContour();
            }
            EndShape();
        }
        Smooth();
    }

    // 0 (a fold) to 1 (stretched or swung out) for the quad at point i.
    float Light(int i)
    {
        Point a = _points[i], b = _points[i + 1], d = _points[i + _cols];
        float span = Dist(a.X, a.Y, b.X, b.Y) / _right[i].Length;              // < 1 where it folds
        float slant = ((d.X - a.X) + (a.X - a.RestX) * 0.15f) / _down[i].Length;  // swinging sideways
        return Constrain(0.5f + (span - 1) * 2.5f + slant * 0.6f, 0, 1);
    }

    // The weave: every stick as a hairline (Skia's fastest line), one shape per
    // color; the stretched ones, warm, go in a second shape on top.
    readonly List<Stick> _stretched = new();

    void DrawWeave()
    {
        StrokeWeight(0);
        Stroke(170 + 85 * _redness, 200 - 120 * _redness, 255 - 150 * _redness, 55);
        _stretched.Clear();
        BeginShape(ShapeKind.Lines);
        foreach (var s in _sticks)
        {
            if (s.Broken) continue;
            float dx = s.B.X - s.A.X, dy = s.B.Y - s.A.Y;
            if (dx * dx + dy * dy > s.Length * s.Length * 1.69f) { _stretched.Add(s); continue; }   // over 1.3x its length
            Vertex(s.A.X, s.A.Y);
            Vertex(s.B.X, s.B.Y);
        }
        EndShape();

        Stroke(255, 160 - 100 * _redness, 90 - 60 * _redness, 200);
        BeginShape(ShapeKind.Lines);
        foreach (var s in _stretched)
        {
            Vertex(s.A.X, s.A.Y);
            Vertex(s.B.X, s.B.Y);
        }
        EndShape();

        // The top hem the cloth hangs from.
        Stroke(220, 230, 255, 140);
        StrokeWeight(2);
        Line(0, 1, Width, 1);
    }
}