@3driseai/3drise-viewer 0.1.28 → 0.1.29

package/dist/components/text/engine/looks/frostGrowth.js

@@ -0,0 +1,727 @@
+import * as THREE from 'three';
+import { buildCapsules, capsuleMaterial, setReveal } from '../ribbon.js';
+import { prepare, applyDraw, applyErase, extentOf, DRAW_METHODS, ERASE_METHODS } from '../methods.js';
+const hex = (h) => new THREE.Color(h);
+const clamp01 = (x) => Math.max(0, Math.min(1, x));
+function mulberry32(a) { return function () { a |= 0; a = (a + 0x6D2B79F5) | 0; let t = Math.imul(a ^ (a >>> 15), 1 | a); t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; return ((t ^ (t >>> 14)) >>> 0) / 4294967296; }; }
+// =========================================================================================
+// frostGrowth - hoarfrost / dendritic ice crystallising on the letters.
+//
+// The maths (all computed once, at build, deterministically):
+//  * Ice Ih is hexagonal, so a growing dendrite arm splits sidebranches at +/-60 deg to its own heading (six-fold
+//    lattice), forward leaning, each sidebranch shorter than the part of the parent that lies beyond its root (the
+//    pointed fern envelope), with occasional tip-splitting into a trident (tip + two 60 deg prongs).
+//  * Generation 0 is the rime along every letter contour (the spine). It spreads both ways from a nucleation point.
+//    Generation 1 barbs leave the spine at 60 deg to the local tangent (outward into the frost zone; some inward, short),
+//    generation 2..4 are sidebranches of sidebranches.
+//  * Diffusion-limited screening: a signed-distance grid of the letters bounds the frost zone (reach), and a coarse
+//    segment occupancy grid rejects any step that would come closer than a generation-dependent separation to a branch of
+//    another lineage, so arms never cross; they stop where they meet (generation by generation = the older, larger arms
+//    claim space first, which is exactly what screens the small ones).
+//  * Every point gets a birth time = parent's time at the root + latency + distance along the arm / tip speed. DRAW is
+//    therefore literally the crystal growing (spines first, tips last); ERASE ('sublimate') is the reverse weighted by
+//    thinness: hairs and tips vanish first, the spine last. Shared methods drive only the spine; the branches follow it.
+//  * Shading: thickness tapers with generation and along the arm; colour = ramp between a cool deep tone (thick) and a
+//    pale blue-white (thin), with a Fresnel-like bright rim; sub-pixel hairs are dimmed by their pixel coverage.
+// =========================================================================================
+const CELL = 0.01; // signed-distance grid cell (em)
+const STEP = [0.016, 0.014, 0.01, 0.007, 0.0055]; // step length per generation
+const SEP = [0.0, 0.0125, 0.0075, 0.0058, 0.0046]; // min distance to a foreign arm per generation
+const SIDE_SP = [0, 0, 0.027, 0.018, 0.012]; // side-branch spacing along an arm of generation g -> children
+const SIDE_RATIO = [0, 0, 0.56, 0.5, 0.46]; // child length / remaining length of the parent
+const MIN_LEN = [0, 0.03, 0.02, 0.014, 0.01];
+const SPEED = [0, 2.4, 3.0, 3.6, 4.2]; // progress per em along an arm of generation g (slower = bigger crystal)
+const LATENCY = [0, 0.03, 0.025, 0.02, 0.015];
+const WF = [0.66, 0.5, 0.4, 0.3, 0.22]; // thickness factor per generation
+const MAX_GEN = 4;
+const MAX_SEG = 24000;
+const SIN60 = Math.sqrt(3) / 2, COS60 = 0.5;
+// ---- signed distance grid of the letters (union by non-zero winding, chamfer distance) ----------------------------
+function buildSDF(strokes, ext, pad) {
+    const x0 = ext.x0 - pad, y0 = ext.y0 - pad;
+    const W = Math.ceil((ext.w + 2 * pad) / CELL) + 2, H = Math.ceil((ext.h + 2 * pad) / CELL) + 2;
+    const rows = new Array(H);
+    for (let j = 0; j < H; j++)
+        rows[j] = [];
+    for (const s of strokes) {
+        const n = s.pts.length / 2;
+        for (let i = 0; i < n - 1; i++) {
+            const ax = s.pts[2 * i], ay = s.pts[2 * i + 1], bx = s.pts[2 * i + 2], by = s.pts[2 * i + 3];
+            if (ay === by)
+                continue;
+            const lo = Math.min(ay, by), hi = Math.max(ay, by), dir = by > ay ? 1 : -1;
+            const j0 = Math.max(0, Math.ceil((lo - y0) / CELL - 0.5)), j1 = Math.min(H - 1, Math.ceil((hi - y0) / CELL - 0.5) - 1);
+            for (let j = j0; j <= j1; j++) {
+                const cy = y0 + (j + 0.5) * CELL;
+                rows[j].push(ax + ((cy - ay) * (bx - ax)) / (by - ay), dir);
+            }
+        }
+    }
+    const ins = new Uint8Array(W * H);
+    for (let j = 0; j < H; j++) {
+        const r = rows[j];
+        const m = r.length / 2;
+        if (!m)
+            continue;
+        const idx = Array.from({ length: m }, (_, k) => k).sort((a, b) => r[2 * a] - r[2 * b]);
+        let w = 0;
+        for (let k = 0; k < m - 1; k++) {
+            w += r[2 * idx[k] + 1];
+            if (w !== 0) {
+                const i0 = Math.max(0, Math.ceil((r[2 * idx[k]] - x0) / CELL - 0.5)), i1 = Math.min(W - 1, Math.ceil((r[2 * idx[k + 1]] - x0) / CELL - 0.5) - 1);
+                for (let i = i0; i <= i1; i++)
+                    ins[j * W + i] = 1;
+            }
+        }
+    }
+    const dt = (src) => {
+        const d = new Float32Array(W * H);
+        const INF = 1e6, R2 = Math.SQRT2;
+        for (let k = 0; k < W * H; k++)
+            d[k] = ins[k] === src ? 0 : INF;
+        for (let j = 0; j < H; j++)
+            for (let i = 0; i < W; i++) {
+                const k = j * W + i;
+                let v = d[k];
+                if (i > 0)
+                    v = Math.min(v, d[k - 1] + 1);
+                if (j > 0) {
+                    v = Math.min(v, d[k - W] + 1);
+                    if (i > 0)
+                        v = Math.min(v, d[k - W - 1] + R2);
+                    if (i < W - 1)
+                        v = Math.min(v, d[k - W + 1] + R2);
+                }
+                d[k] = v;
+            }
+        for (let j = H - 1; j >= 0; j--)
+            for (let i = W - 1; i >= 0; i--) {
+                const k = j * W + i;
+                let v = d[k];
+                if (i < W - 1)
+                    v = Math.min(v, d[k + 1] + 1);
+                if (j < H - 1) {
+                    v = Math.min(v, d[k + W] + 1);
+                    if (i < W - 1)
+                        v = Math.min(v, d[k + W + 1] + R2);
+                    if (i > 0)
+                        v = Math.min(v, d[k + W - 1] + R2);
+                }
+                d[k] = v;
+            }
+        return d;
+    };
+    const dOut = dt(1), dIn = dt(0);
+    const sd = new Float32Array(W * H);
+    for (let k = 0; k < W * H; k++)
+        sd[k] = (ins[k] ? -(dIn[k] - 0.5) : dOut[k] - 0.5) * CELL;
+    return { sample(x, y) {
+            const u = (x - x0) / CELL - 0.5, v = (y - y0) / CELL - 0.5;
+            const i = Math.floor(u), j = Math.floor(v);
+            if (i < 0 || j < 0 || i >= W - 1 || j >= H - 1)
+                return 1;
+            const fx = u - i, fy = v - j, k = j * W + i;
+            return (sd[k] * (1 - fx) + sd[k + 1] * fx) * (1 - fy) + (sd[k + W] * (1 - fx) + sd[k + W + 1] * fx) * fy;
+        } };
+}
+// ---- segment occupancy grid (screening) ---------------------------------------------------------------------------
+function makeOccupancy(ext, pad) {
+    const OC = 0.03;
+    const x0 = ext.x0 - pad, y0 = ext.y0 - pad;
+    const OW = Math.ceil((ext.w + 2 * pad) / OC) + 2;
+    const cells = new Map();
+    const ax = [], ay = [], bx = [], by = [], pid = [];
+    const key = (i, j) => i * 4096 + j;
+    const cx = (x) => Math.floor((x - x0) / OC), cy = (y) => Math.floor((y - y0) / OC);
+    return {
+        add(x1, y1, x2, y2, p) {
+            const id = ax.length;
+            ax.push(x1);
+            ay.push(y1);
+            bx.push(x2);
+            by.push(y2);
+            pid.push(p);
+            const e = 0.014;
+            const i0 = cx(Math.min(x1, x2) - e), i1 = cx(Math.max(x1, x2) + e), j0 = cy(Math.min(y1, y2) - e), j1 = cy(Math.max(y1, y2) + e);
+            for (let i = i0; i <= i1; i++)
+                for (let j = j0; j <= j1; j++) {
+                    const k = key(i, j);
+                    let a = cells.get(k);
+                    if (!a) {
+                        a = [];
+                        cells.set(k, a);
+                    }
+                    a.push(id);
+                }
+        },
+        // is (px,py) closer than sep to a segment of another lineage? early = skip ancestors / siblings (they share the root)
+        blocked(px, py, p, sep, early, parentOf) {
+            const a = cells.get(key(cx(px), cy(py)));
+            if (!a)
+                return false;
+            const par = parentOf[p], gpar = par >= 0 ? parentOf[par] : -1;
+            for (let n = 0; n < a.length; n++) {
+                const id = a[n];
+                const o = pid[id];
+                if (o === p)
+                    continue;
+                if (early && (o === par || o === gpar || parentOf[o] === par))
+                    continue;
+                const dx = bx[id] - ax[id], dy = by[id] - ay[id];
+                const l2 = dx * dx + dy * dy;
+                let t = l2 > 0 ? ((px - ax[id]) * dx + (py - ay[id]) * dy) / l2 : 0;
+                t = t < 0 ? 0 : t > 1 ? 1 : t;
+                const ex = ax[id] + dx * t - px, ey = ay[id] + dy * t - py;
+                if (ex * ex + ey * ey < sep * sep)
+                    return true;
+            }
+            return false;
+        },
+    };
+}
+// ---- the crystal --------------------------------------------------------------------------------------------------
+function growCrystal(spines, cfg, rnd) {
+    const ext = extentOf(spines);
+    const reach = cfg.reach, br = Math.max(0.2, cfg.branching);
+    const pad = reach + 0.2;
+    const sdf = buildSDF(spines, ext, pad);
+    const occ = makeOccupancy(ext, pad);
+    const parentOf = [];
+    const nc = spines.length;
+    spines.forEach((s, ci) => { parentOf.push(-1); for (let i = 0; i < s.pts.length / 2 - 1; i++)
+        occ.add(s.pts[2 * i], s.pts[2 * i + 1], s.pts[2 * i + 2], s.pts[2 * i + 3], ci); });
+    let segCount = 0;
+    const branches = [];
+    const reachCap = reach * 1.12 + 0.012, innerDepth = 0.09;
+    // ---- crystal grains: K nucleation sites on the letters (farthest-point spread, seeded). A grain = the (slightly warped) Voronoi
+    // cell of its site; inside it every arm lies on the grain's own 60 deg lattice (orientation phi), growth stops at the boundary.
+    const K = Math.max(1, Math.min(9, Math.round(cfg.grains)));
+    const cand = [];
+    spines.forEach((s, ci) => { for (let i = 0; i < s.pts.length / 2 - 1; i += 3)
+        cand.push([s.pts[2 * i], s.pts[2 * i + 1], ci, i]); });
+    const grains = [];
+    for (let k = 0; k < K; k++) {
+        let best = null, bd = -1;
+        for (let t = 0; t < (k ? 160 : 1); t++) {
+            const c = cand[Math.floor(rnd() * cand.length)];
+            let md = 1e9;
+            for (const g of grains)
+                md = Math.min(md, Math.hypot(c[0] - g.x, c[1] - g.y));
+            if (k === 0)
+                md = 1;
+            if (md > bd) {
+                bd = md;
+                best = c;
+            }
+        }
+        grains.push({ x: best[0], y: best[1], ci: best[2], i: best[3], phi: ((k * 0.618034 + 0.12 * rnd()) % 1) * (Math.PI / 3), delay: k ? rnd() * 0.1 : 0, p1: rnd() * 6.28, p2: rnd() * 6.28, p3: rnd() * 6.28, p4: rnd() * 6.28 });
+    }
+    const score = (k, x, y) => { const g = grains[k]; return Math.hypot(x - g.x, y - g.y) + 0.02 * Math.sin(x * 7.3 + g.p1) * Math.sin(y * 6.1 + g.p2) + 0.012 * Math.sin(x * 17.0 + y * 11.0 + g.p3); };
+    const exactAt = (x, y) => { let b = 0, bs = 1e9; for (let k = 0; k < K; k++) {
+        const v = score(k, x, y);
+        if (v < bs) {
+            bs = v;
+            b = k;
+        }
+    } return b; };
+    // label grid (same lattice as the SDF, 1 cell = 1 cm) so the hot loops are a lookup
+    const gx0 = ext.x0 - pad, gy0 = ext.y0 - pad, gW = Math.ceil((ext.w + 2 * pad) / CELL) + 2, gH = Math.ceil((ext.h + 2 * pad) / CELL) + 2;
+    const gl = new Uint8Array(gW * gH);
+    if (K > 1)
+        for (let j = 0; j < gH; j++)
+            for (let i = 0; i < gW; i++)
+                gl[j * gW + i] = exactAt(gx0 + (i + 0.5) * CELL, gy0 + (j + 0.5) * CELL);
+    const grainAt = (x, y) => { if (K === 1)
+        return 0; const i = Math.floor((x - gx0) / CELL), j = Math.floor((y - gy0) / CELL); if (i < 0 || j < 0 || i >= gW || j >= gH)
+        return exactAt(x, y); return gl[j * gW + i]; };
+    const TH = Math.PI / 3;
+    const snap = (th, phi) => phi + Math.round((th - phi) / TH) * TH;
+    const lattice = (phi, nx, ny, sgn, minDot) => { const out = []; for (let m = 0; m < 6; m++) {
+        const a = phi + m * TH;
+        const dt = (Math.cos(a) * nx + Math.sin(a) * ny) * sgn;
+        if (dt >= minDot)
+            out.push({ a, dt });
+    } out.sort((u, v) => v.dt - u.dt); return out; };
+    // trace one arm; returns its polyline or null
+    function trace(sp) {
+        const g = sp.g, h = STEP[g], n = Math.max(1, Math.floor(sp.len / h));
+        const pid = nc + branches.length;
+        parentOf[pid] = sp.parent;
+        let x = sp.x, y = sp.y, th = sp.th;
+        const bend = (rnd() - 0.5) * 0.04;
+        const pts = [x, y];
+        const phi = grains[sp.grain].phi;
+        const m3 = (((Math.round((sp.th - phi) / TH) % 3) + 3) % 3);
+        for (let k = 1; k <= n; k++) {
+            th += bend * 0.3 + (rnd() - 0.5) * 0.012;
+            const nx = x + Math.cos(th) * h, ny = y + Math.sin(th) * h;
+            const sd = sdf.sample(nx, ny);
+            if (sp.inner) {
+                if (k >= 2 && (sd > -0.004 || sd < -innerDepth))
+                    break;
+            }
+            else if (k >= 2 && (sd < 0.005 || sd > reachCap))
+                break;
+            if (K > 1 && grainAt(nx + Math.cos(th) * 0.007, ny + Math.sin(th) * 0.007) !== sp.grain)
+                break; // grain boundary: growth stops
+            const early = k <= 3;
+            if (occ.blocked(nx, ny, pid, SEP[g], early, parentOf) || occ.blocked((x + nx) / 2, (y + ny) / 2, pid, SEP[g], early, parentOf))
+                break;
+            occ.add(x, y, nx, ny, pid);
+            x = nx;
+            y = ny;
+            pts.push(x, y);
+            segCount++;
+        }
+        if (pts.length < 4) {
+            parentOf.length = pid;
+            return null;
+        }
+        const rec = { pts, g, pid, parent: sp.parent, pidx: sp.pidx, inner: sp.inner, glyph: sp.glyph, th, rid: rnd(), grain: sp.grain, m3 };
+        branches.push(rec);
+        return rec;
+    }
+    // generation 1: barbs along every contour, snapped to the lattice of the grain they sit in.
+    const nuc = [];
+    let specs = [];
+    const rime = [];
+    spines.forEach((s, ci) => {
+        const L = s.len;
+        const list = grains.filter((g) => g.ci === ci).map((g) => ({ c: s.cum[g.i], delay: g.delay }));
+        const own = list.length === 0;
+        if (own)
+            list.push({ c: rnd() * L, delay: 0 });
+        nuc.push({ list, own });
+        const c0 = list[0].c;
+        const at = (c) => {
+            c = ((c % L) + L) % L;
+            let lo = 0, hi = s.cum.length - 1;
+            while (hi - lo > 1) {
+                const m = (lo + hi) >> 1;
+                if (s.cum[m] <= c)
+                    lo = m;
+                else
+                    hi = m;
+            }
+            const f = (c - s.cum[lo]) / Math.max(1e-9, s.cum[hi] - s.cum[lo]);
+            return { x: s.pts[2 * lo] + (s.pts[2 * hi] - s.pts[2 * lo]) * f, y: s.pts[2 * lo + 1] + (s.pts[2 * hi + 1] - s.pts[2 * lo + 1]) * f, i: f > 0.5 ? hi : lo };
+        };
+        const frame = (c) => {
+            const p = at(c), a = at(c - 0.014), b = at(c + 0.014);
+            let tx = b.x - a.x, ty = b.y - a.y;
+            const tl = Math.hypot(tx, ty) || 1;
+            tx /= tl;
+            ty /= tl;
+            let nx = -ty, ny = tx;
+            if (sdf.sample(p.x + 0.008 * nx, p.y + 0.008 * ny) < 0) {
+                nx = -nx;
+                ny = -ny;
+            }
+            return { p, nx, ny, gi: grainAt(p.x, p.y) };
+        };
+        const ds0 = 0.07 / br;
+        const ph1 = rnd() * 6.28, ph2 = rnd() * 6.28, f1 = 5 + rnd() * 6, f2 = 13 + rnd() * 9;
+        for (let c = rnd() * ds0; c < L; c += ds0 * (0.75 + 0.5 * rnd())) {
+            let dd0 = c - c0;
+            if (dd0 > L / 2)
+                dd0 -= L;
+            if (dd0 < -L / 2)
+                dd0 += L;
+            // patchy: ferns are larger near the nucleus (older frost) and in lucky stretches of the contour; some stretches stay bare rime
+            const patch = 0.62 + 0.38 * Math.sin(c * f1 / L * 3 + ph1) * Math.cos(c * f2 + ph2) + 0.2 * (1 - Math.abs(dd0) / (L / 2));
+            if (patch < 0.3 || rnd() < 0.08)
+                continue;
+            const { p, nx, ny, gi } = frame(c);
+            const phi = grains[gi].phi;
+            const r = rnd();
+            const outs = lattice(phi, nx, ny, 1, 0.45);
+            const a1 = (outs.length > 1 && rnd() < 0.4 ? outs[outs.length - 1] : outs[0]).a + (rnd() - 0.5) * 0.04;
+            specs.push({ x: p.x, y: p.y, th: a1, len: (reach * Math.min(1.25, patch) * (0.75 + 0.5 * r)) / SIN60, g: 1, parent: ci, pidx: p.i, inner: false, glyph: s.glyph, grain: gi, key: rnd() });
+            if (rnd() < 0.5) {
+                const ins = lattice(phi, nx, ny, -1, 0.45);
+                specs.push({ x: p.x, y: p.y, th: ins[Math.floor(rnd() * ins.length)].a, len: Math.min(0.07, reach * 0.6) * (0.7 + 0.6 * rnd()), g: 1, parent: ci, pidx: p.i, inner: true, glyph: s.glyph, grain: gi, key: rnd() });
+            }
+        }
+        // rime fringe: short crystals along the whole edge (generation 2 slots, so they fill what the barbs leave)
+        for (let c = rnd() * 0.02; c < L; c += 0.02 * (0.7 + 0.6 * rnd())) {
+            if (rnd() < 0.15)
+                continue;
+            const { p, nx, ny, gi } = frame(c);
+            const outs = lattice(grains[gi].phi, nx, ny, 1, 0.45);
+            rime.push({ x: p.x, y: p.y, th: outs[Math.floor(rnd() * outs.length)].a, len: (0.012 + 0.03 * rnd()) * Math.min(1, reach / 0.12), g: 2, parent: ci, pidx: p.i, inner: false, glyph: s.glyph, grain: gi, key: rnd() });
+        }
+    });
+    for (let g = 1; g <= MAX_GEN; g++) {
+        specs.sort((a, b) => a.key - b.key); // random order inside a generation: nobody is systematically favoured
+        const made = [];
+        for (const sp of specs) {
+            if (segCount > MAX_SEG)
+                break;
+            const rec = trace(sp);
+            if (rec)
+                made.push(rec);
+        }
+        if (g === MAX_GEN)
+            break;
+        const next = g === 1 ? rime.splice(0) : [];
+        for (const b of made) {
+            const P = b.pts, n = P.length / 2;
+            const ng = g + 1;
+            let Ltot = 0;
+            const cum = [0];
+            for (let i = 1; i < n; i++) {
+                Ltot += Math.hypot(P[2 * i] - P[2 * i - 2], P[2 * i + 1] - P[2 * i - 1]);
+                cum.push(Ltot);
+            }
+            b.cum = cum;
+            b.len = Ltot;
+            const sp = SIDE_SP[ng] / br;
+            let last = 0.022;
+            for (let i = 1; i < n - 1; i++) {
+                if (cum[i] - last < sp * (0.8 + 0.4 * rnd()))
+                    continue;
+                const hx = P[2 * i + 2] - P[2 * i - 2], hy = P[2 * i + 3] - P[2 * i - 1];
+                const th = Math.atan2(hy, hx);
+                last = cum[i];
+                for (let sd = -1; sd <= 1; sd += 2) {
+                    if (rnd() > 0.92)
+                        continue;
+                    const Ls = SIDE_RATIO[ng] * (Ltot - cum[i]) * (0.7 + 0.6 * rnd());
+                    if (Ls < MIN_LEN[ng])
+                        continue;
+                    next.push({ x: P[2 * i], y: P[2 * i + 1], th: snap(th + sd * TH, grains[b.grain].phi) + (rnd() - 0.5) * 0.03, len: Ls, g: ng, parent: b.pid, pidx: i, inner: b.inner, glyph: b.glyph, grain: b.grain, key: rnd() });
+                }
+            }
+            // tip splitting: a trident (tip + two 60 deg prongs)
+            if (n > 3 && Ltot > 0.06 && rnd() < 0.38 * Math.min(1.6, br))
+                for (let sd = -1; sd <= 1; sd += 2) {
+                    const Ls = Ltot * 0.3 * (0.7 + 0.6 * rnd());
+                    if (Ls < MIN_LEN[ng])
+                        continue;
+                    next.push({ x: P[2 * n - 2], y: P[2 * n - 1], th: snap(b.th + sd * TH, grains[b.grain].phi) + (rnd() - 0.5) * 0.03, len: Ls, g: ng, parent: b.pid, pidx: n - 1, inner: b.inner, glyph: b.glyph, grain: b.grain, key: rnd() });
+                }
+        }
+        specs = next;
+    }
+    // ---- grain boundaries: trace the (warped) bisector of every pair of grains through the frost zone -> thin bright seams
+    const seams = [];
+    if (K > 1) {
+        const R = Math.hypot(ext.w, ext.h) / 2 + 0.6, cxm = (ext.x0 + ext.x1) / 2, cym = (ext.y0 + ext.y1) / 2;
+        for (let a = 0; a < K; a++)
+            for (let b = a + 1; b < K; b++) {
+                const A = grains[a], B = grains[b];
+                const dx = B.x - A.x, dy = B.y - A.y, dl = Math.hypot(dx, dy) || 1;
+                const nx = dx / dl, ny = dy / dl, ux = -ny, uy = nx;
+                const mx = (A.x + B.x) / 2, my = (A.y + B.y) / 2;
+                let run = [];
+                const flush = () => { if (run.length >= 6)
+                    seams.push({ pts: run.flat() }); run = []; };
+                for (let t = -R; t <= R; t += 0.012) {
+                    const px = mx + ux * t, py = my + uy * t;
+                    if (Math.abs(px - cxm) > ext.w / 2 + pad || Math.abs(py - cym) > ext.h / 2 + pad) {
+                        flush();
+                        continue;
+                    }
+                    const sp0 = sdf.sample(px, py);
+                    if (sp0 > reach + 0.12 || sp0 < -0.14) {
+                        flush();
+                        continue;
+                    }
+                    const f = (sv) => score(a, px + nx * sv, py + ny * sv) - score(b, px + nx * sv, py + ny * sv);
+                    let lo = -0.08, hi = 0.08;
+                    if (f(lo) * f(hi) > 0) {
+                        flush();
+                        continue;
+                    }
+                    for (let it = 0; it < 12; it++) {
+                        const m = (lo + hi) / 2;
+                        if (f(m) * f(lo) > 0)
+                            lo = m;
+                        else
+                            hi = m;
+                    }
+                    const qx = px + nx * lo, qy = py + ny * lo;
+                    const w = grainAt(qx, qy);
+                    const sdv = sdf.sample(qx, qy);
+                    if ((w !== a && w !== b) || sdv < 0.008 || sdv > reach * 0.85) {
+                        flush();
+                        continue;
+                    }
+                    const last = run[run.length - 1];
+                    if (last && Math.hypot(qx - last[0], qy - last[1]) > 0.035)
+                        flush();
+                    run.push([qx, qy]);
+                }
+                flush();
+            }
+    }
+    return { branches, nuc, nc, seams, grains };
+}
+// ---- schedule: birth times of every point -------------------------------------------------------------------------
+function schedule(spines, crystal, anim, G) {
+    const { branches, nuc, nc } = crystal;
+    const rnd = mulberry32(991);
+    const method = anim.draw.method;
+    const tau = []; // tau[pid] = Float32Array per point (raw progress)
+    let infoD;
+    if (method === 'grow') {
+        let half = 1e-3;
+        for (const s of spines)
+            half = Math.max(half, s.len / 2);
+        const vs = 0.26 / half;
+        spines.forEach((s, ci) => {
+            const n = s.pts.length / 2, L = s.len, t = new Float32Array(n);
+            const nu = nuc[ci];
+            const g0 = nu.own ? (G > 1 ? 0.12 * (s.glyph / (G - 1)) : 0) + 0.025 * rnd() : 0;
+            for (let i = 0; i < n; i++) {
+                let m = 1e9;
+                for (const q of nu.list) {
+                    let dd = Math.abs(s.cum[i] - q.c);
+                    dd = Math.min(dd, L - dd);
+                    m = Math.min(m, q.delay + dd * vs);
+                }
+                t[i] = g0 + m;
+            } // grains nucleate at their own moment and compete
+            tau.push(t);
+        });
+        infoD = { soft: 0.012, tip: false, fade: false };
+    }
+    else {
+        const ctx = { G: Math.max(1, G), ext: extentOf(spines) };
+        infoD = applyDraw(method, spines, anim.draw, ctx);
+        spines.forEach((s) => { const n = s.pts.length / 2, t = new Float32Array(n); for (let i = 0; i < n; i++)
+            t[i] = 0.5 * (s.seg[0] + s.t[i] * (s.seg[1] - s.seg[0])); tau.push(t); });
+        infoD = { ...infoD, tip: false };
+    }
+    for (const b of branches) {
+        const n = b.pts.length / 2, t = new Float32Array(n);
+        const t0 = tau[b.parent][Math.min(b.pidx, tau[b.parent].length - 1)] + LATENCY[b.g];
+        if (!b.cum) {
+            b.cum = [0];
+            let L = 0;
+            for (let i = 1; i < n; i++) {
+                L += Math.hypot(b.pts[2 * i] - b.pts[2 * i - 2], b.pts[2 * i + 1] - b.pts[2 * i - 1]);
+                b.cum.push(L);
+            }
+            b.len = L;
+        }
+        for (let i = 0; i < n; i++)
+            t[i] = t0 + b.cum[i] * SPEED[b.g];
+        tau[b.pid] = t;
+    }
+    // seams appear when the arms of the two grains have reached the boundary: nearest spine point time + arm travel
+    (crystal.seams || []).forEach((sm, si) => {
+        const n = sm.pts.length / 2, t = new Float32Array(n);
+        sm.cum = [0];
+        let Lc = 0;
+        for (let i = 0; i < n; i++) {
+            if (i) {
+                Lc += Math.hypot(sm.pts[2 * i] - sm.pts[2 * i - 2], sm.pts[2 * i + 1] - sm.pts[2 * i - 1]);
+                sm.cum.push(Lc);
+            }
+            let bd = 1e9, bt = 0;
+            spines.forEach((s, ci) => { for (let k = 0; k < s.pts.length / 2; k += 2) {
+                const d2 = (s.pts[2 * k] - sm.pts[2 * i]) ** 2 + (s.pts[2 * k + 1] - sm.pts[2 * i + 1]) ** 2;
+                if (d2 < bd) {
+                    bd = d2;
+                    bt = tau[ci][k];
+                }
+            } });
+            t[i] = bt + LATENCY[1] + SPEED[1] * Math.sqrt(bd) / SIN60 + 0.03;
+        }
+        sm.len = Lc;
+        tau[nc + branches.length + si] = t;
+        sm.pid = nc + branches.length + si;
+    });
+    let mx = 1e-6;
+    for (const t of tau)
+        for (let i = 0; i < t.length; i++)
+            mx = Math.max(mx, t[i]);
+    const f = 0.985 / mx;
+    for (const t of tau)
+        for (let i = 0; i < t.length; i++)
+            t[i] *= f;
+    return { tau, infoD };
+}
+// ---- fragment: ice rod cross-section, rim, front glow, sparkle ------------------------------------------------------
+const FROST_FRAG = /* glsl */ `
+uniform vec3 uColor; uniform vec3 uColor2; uniform float uOpacity; uniform float uSparkle; uniform float uHaze; uniform float uW0; uniform float uSeam; uniform float uPhi[9];
+float h11(float x){ return fract(sin(x*127.1 + 7.7)*43758.5453); }
+void main(){
+  float d = length(vec2(max(abs(vXY.x) - vHL, 0.0), vXY.y));
+  float px = max(length(dFdx(vPos)), length(dFdy(vPos))); px = max(px, 1e-5);   // em per pixel
+  float seam = step(3.5, vVar); float v2 = vVar - 4.0*seam; float inner = step(1.5, v2); float wf = v2 - 2.0*inner;
+  float ig = floor(vGlyph); float grain = floor(ig/4.0); float m3 = ig - 4.0*grain; float lat = step(m3, 2.5);
+  float w = uW0*wf;
+  float weff = max(w, 0.5*px);
+  float amp = min(1.0, w/weff);                                   // sub-pixel hairs are dimmer, never aliased
+  float cov = clamp((weff + 0.5*px - d)/px, 0.0, 1.0);
+  float s = abs(vXY.y)/weff;
+  float rim = smoothstep(0.2, 0.95, s);
+  float f = clamp((vXY.x + vHL)/(2.0*max(vHL, 1e-6)), 0.0, 1.0);
+  float lit = revealIn(f); float gone = revealOut(f);
+  float age = ageAt(f);
+  float front = exp(-age/0.28);                                  // the growing front is brighter and whiter
+  float settled = smoothstep(0.4, 1.8, age);
+  // colour from thickness: thick spines are a deeper cooler tone, thin edges pale blue-white (Fresnel-like rim)
+  vec3 body = mix(uColor2, uColor, clamp(0.3 + 1.0*(1.0 - wf), 0.0, 1.0));
+  vec3 col = mix(body, uColor, rim*0.85);
+  // each grain has its own slightly different cool tint
+  float gt = h11(grain*3.7 + 1.3) - 0.5;
+  col *= mix(vec3(1.0), vec3(1.0 - 0.24*gt, 1.0 + 0.03*gt, 1.0 + 0.16*gt), lat);
+  // facet angle (lattice line orientation of this arm) against a slowly moving light
+  float alpha = lat > 0.5 ? uPhi[int(clamp(grain, 0.0, 8.0) + 0.5)] + m3*1.0471976 : h11(vGlyph)*3.14159;
+  float psi = 1.1*sin(uTime*0.09*uIdleSpeed) + 0.5*sin(uTime*0.037*uIdleSpeed + 1.3);
+  float dl = mod(alpha - psi + 1.5708, 3.14159) - 1.5708;
+  float align = exp(-pow(dl/0.22, 2.0));
+  float I = (0.64 + 0.36*rim)*(0.5 + 0.5*clamp(wf*1.25, 0.0, 1.0))*(1.0 + 0.16*align*uSparkle*uIdle*lat);
+  // grain boundary: thin bright seam / dislocation line
+  col = mix(col, mix(uColor, vec3(0.92, 0.98, 1.0), 0.6), seam);
+  I = mix(I, uSeam*(0.8 + 0.2*sin(arcAt(f)*120.0)), seam);
+  float breath = 1.0 + 0.07*uIdle*sin(uTime*0.5*uIdleSpeed - vPos.x*0.9 + vPos.y*0.4);   // slow cold breathing wave through the rim light
+  col = mix(col, vec3(1.0), 0.55*front);
+  I *= (1.0 + 0.45*front);
+  // sublimation: a faint bright edge at the erase front
+  float tOv = mix(vTT.z, vTT.w, f); float dE = tOv - vLL.y;
+  float sub = (1.0 - uFadeOut)*smoothstep(0.0, 0.03, uE)*exp(-max(dE, 0.0)/0.05)*0.6;
+  // sparkle: narrow-peaked glints, each sitting in a cell along its arm and drifting along it while it flashes
+  float cellL = 0.05; float aid = vGlyph*61.0;
+  float a = arcAt(f)/cellL + aid; float k = floor(a); float fr = fract(a);
+  float h1 = h11(k*1.31 + aid), h2 = h11(k*2.17 + aid*3.1), h3 = h11(k*0.73 + aid*5.3);
+  float on = step(h3, (0.07 + 0.3*align)*uSparkle);
+  float P = mix(3.0, 9.0, h2); float ph = fract(uTime*uIdleSpeed/P + h1);
+  float pulse = exp(-pow((ph - 0.5)/0.03, 2.0));
+  float cpos = 0.5 + (ph - 0.5)*9.0;
+  float da = (fr - cpos)*cellL;
+  float rr = length(vec2(da, d));
+  float glint = pulse*on*(exp(-pow(rr/0.0035, 2.0)) + 0.35*exp(-pow(rr/0.011, 2.0)) + 0.5*exp(-abs(da)/0.016)*exp(-pow(d/0.0012, 2.0)))*uSparkle*uIdle*settled*(1.0 - 0.5*inner);
+  // thin prismatic dispersion: cool to warm with the facet angle against the light, kept close to white
+  vec3 spec = mix(vec3(0.92, 0.97, 1.0), mix(vec3(0.55, 0.85, 1.0), vec3(1.0, 0.84, 0.62), 0.5 + 0.5*clamp(dl/0.4, -1.0, 1.0)), 0.6);
+  float hz = uHaze*0.2*(0.3 + 0.7*wf)*exp(-pow(d/(0.012 + 0.7*w), 2.0))*(1.0 - 0.5*inner);   // frosted glow around the ice
+  vec3 hcol = mix(uColor2, uColor, 0.45);
+  vec3 c = col*(cov*amp*I*breath*(1.0 - 0.45*inner)) + hcol*hz + uColor*sub*cov + spec*glint*0.95;
+  c *= lit*gone*uOpacity;
+  gl_FragColor = vec4(c, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+const num = (name, label, description, min, max, step, unit) => ({ name, label, description, type: 'number', min, max, step, ...(unit ? { unit } : {}) });
+const col = (name, label, description) => ({ name, label, description, type: 'color' });
+export default {
+    key: 'frostGrowth', source: 'outline', drawMethods: ['grow', ...DRAW_METHODS], eraseMethods: ['sublimate', ...ERASE_METHODS], drawDefault: 'grow', eraseDefault: 'sublimate',
+    animDefaults: { drawDuration: 6, drawEase: 'linear', eraseDuration: 3, eraseEase: 'linear' },
+    methodInfo: {
+        grow: { label: 'Grow', hint: 'Rime spreads along the contours from a nucleation point, branches follow; tips are last' },
+        sublimate: { label: 'Sublimate', hint: 'Tips and thin branches vanish first, the spine last' },
+    },
+    catalog: { name: 'Frost Growth', description: 'Dendritic hoarfrost nucleates in competing crystal grains on the letter outlines, each with its own six-fold lattice and bright boundary seams, then throws prismatic glints. Use for winter, cold-brand and fantasy titles.', tags: ['frost', 'ice', 'crystal', 'dendrite', 'winter', 'cold', 'hoarfrost'] },
+    defaults: { reach: 0.15, branching: 1, grains: 5, sparkle: 0.6, thickness: 1, seams: 0.75, haze: 0.5, seed: 7, color: '#d6edff', color2: '#4a90d4', opacity: 1 },
+    ui: {
+        main: [
+            num('reach', 'Reach', 'How far the frost spreads from the letters', 0.04, 0.5, 0.005, 'em'),
+            num('branching', 'Branching', 'Side-branch density of the ice ferns', 0.3, 1.8, 0.05),
+            num('grains', 'Grains', 'Number of crystal grains; each has its own lattice orientation', 1, 9, 1),
+            num('sparkle', 'Sparkle', 'Sharp glints travelling over the crystal facets', 0, 1, 0.01),
+        ],
+        more: [
+            num('thickness', 'Thickness', 'Thickness of the ice arms', 0.4, 2.5, 0.05),
+            num('seams', 'Grain seams', 'Brightness of the boundary lines where grains meet', 0, 1, 0.01),
+            num('haze', 'Frost haze', 'Soft frosted glow around the ice', 0, 1.5, 0.01),
+            col('color', 'Ice', 'Pale colour of thin edges and tips'),
+            col('color2', 'Deep ice', 'Cooler deeper tone of thick spines'),
+            num('opacity', 'Opacity', 'Overall opacity', 0, 1, 0.01),
+            num('seed', 'Seed', 'Random seed of the crystal pattern', 0, 999, 1),
+        ],
+    },
+    structural: ['reach', 'branching', 'grains', 'seed'],
+    presets: [
+        { name: 'Hoarfrost', description: 'Pale blue-white window frost', patch: {} },
+        { name: 'Glacier', description: 'Deep cyan ice, heavier arms', patch: { color: '#9fe6ff', color2: '#1d6fb8', thickness: 1.4, haze: 0.8 } },
+        { name: 'Moonlit', description: 'Silver-violet rime with many glints', patch: { color: '#eaeeff', color2: '#7f8fd8', sparkle: 1, haze: 0.3 } },
+        { name: 'Fine lace', description: 'Hair-fine, faint crystal', patch: { thickness: 0.6, sparkle: 0.35, haze: 0.2, opacity: 0.9 } },
+        { name: 'Arctic', description: 'Teal glow with strong frosted haze', patch: { color: '#c8fff4', color2: '#2aa59a', haze: 1.1, sparkle: 0.8 } },
+    ],
+    build(layout, cfg, anim) {
+        const spines = layout.strokes;
+        const G = Math.max(1, layout.glyphs.length);
+        const empty = !spines.length;
+        const group = new THREE.Group();
+        if (empty)
+            return { object: group, apply() { }, update() { }, dispose() { } };
+        prepare(spines, 'outline');
+        const rnd = mulberry32(Math.round(cfg.seed) * 7919 + 13);
+        const crystal = growCrystal(spines, { reach: cfg.reach, branching: cfg.branching, grains: cfg.grains }, rnd);
+        const { tau, infoD } = schedule(spines, crystal, anim, G);
+        // strokes: contours first, then arms. Every stroke gets the full window [0,1] and its own per-point birth times.
+        const strokes = spines.slice();
+        const pr = (g, inner, u) => Math.max(0.1, WF[g] * (1 - 0.5 * u)) + (inner ? 2 : 0);
+        const gen = []; // generation per stroke
+        spines.forEach((s, i) => { s.t = tau[i]; s.seg = [0, 1]; s.pressure = new Float32Array(s.pts.length / 2).fill(0.66); s.glyphN = 3 + ((i * 0.6180339) % 1) * 0.98; gen.push(0); });
+        crystal.branches.forEach((b) => {
+            const n = b.pts.length / 2;
+            const st = { pts: Float32Array.from(b.pts), cum: Float32Array.from(b.cum), len: Math.max(1e-6, b.len), closed: false, glyph: b.glyph, ptime: Math.max(1e-3, b.len), pt: null };
+            st.t = tau[b.pid];
+            st.seg = [0, 1];
+            st.pressure = new Float32Array(n);
+            for (let i = 0; i < n; i++)
+                st.pressure[i] = pr(b.g, b.inner, i / Math.max(1, n - 1));
+            st.glyphN = b.grain * 4 + b.m3 + b.rid * 0.98;
+            strokes.push(st);
+            gen.push(b.g);
+        });
+        crystal.seams.forEach((sm, si) => {
+            const n = sm.pts.length / 2;
+            const st = { pts: Float32Array.from(sm.pts), cum: Float32Array.from(sm.cum), len: Math.max(1e-6, sm.len), closed: false, glyph: 0, ptime: Math.max(1e-3, sm.len), pt: null };
+            st.t = tau[sm.pid];
+            st.seg = [0, 1];
+            st.pressure = new Float32Array(n).fill(4.38);
+            st.glyphN = 3 + ((si * 0.7548777) % 1) * 0.98;
+            strokes.push(st);
+            gen.push(9);
+        });
+        // erase
+        const ctx = { G, ext: extentOf(strokes), drawSched: strokes.map((s) => ({ seg: s.seg, t: s.t })), drawInfo: infoD };
+        let infoE;
+        if (anim.erase.method === 'sublimate') {
+            // arms: thin and late-born first. spines next; grain seams (the boundaries) are the very last thing to go
+            const r2 = mulberry32(4242);
+            let mxv = 1e-6, mnv = 1e6;
+            const raw = strokes.map((s, si) => {
+                const n = s.pts.length / 2, o = new Float32Array(n);
+                const jit = (r2() - 0.5) * 0.12;
+                for (let i = 0; i < n; i++) {
+                    o[i] = 0.5 * (1 - s.t[i] / 0.985) + 0.5 * (1 - Math.min(gen[si], MAX_GEN) / MAX_GEN) + jit;
+                    if (gen[si] >= 1 && gen[si] <= MAX_GEN) {
+                        mxv = Math.max(mxv, o[i]);
+                        mnv = Math.min(mnv, o[i]);
+                    }
+                }
+                return o;
+            });
+            mxv = Math.max(mxv, mnv + 1e-3);
+            strokes.forEach((s, si) => {
+                const g = gen[si];
+                s.segO = [0, 1];
+                s.tO = raw[si].map((v, i) => g === 0 ? 0.9 + 0.05 * clamp01(1 - s.t[i] / 0.985) : g > MAX_GEN ? 0.97 + 0.03 * clamp01(1 - s.t[i] / 0.985) : 0.88 * clamp01((v - mnv) / (mxv - mnv)));
+            });
+            infoE = { soft: 0.05, fade: false };
+        }
+        else
+            infoE = applyErase(anim.erase.method, strokes, anim.erase, ctx);
+        strokes.forEach((s) => { s.len = 1; }); // arc coordinate becomes absolute em along the arm (glints use it)
+        const geo = buildCapsules(strokes);
+        const mat = capsuleMaterial(FROST_FRAG, { uColor: { value: hex(cfg.color) }, uColor2: { value: hex(cfg.color2) }, uOpacity: { value: 1 }, uSparkle: { value: cfg.sparkle }, uHaze: { value: cfg.haze }, uSeam: { value: cfg.seams }, uPhi: { value: Array.from({ length: 9 }, (_, k) => (crystal.grains[k] ? crystal.grains[k].phi : 0)) }, uW0: { value: 0.0068 } });
+        const mesh = new THREE.Mesh(geo, mat);
+        mesh.frustumCulled = false;
+        group.add(mesh);
+        const api = {
+            object: group,
+            apply(c) { const u = mat.uniforms; u.uColor.value.set(c.color); u.uColor2.value.set(c.color2); u.uOpacity.value = c.opacity; u.uSparkle.value = c.sparkle; u.uHaze.value = c.haze; u.uSeam.value = c.seams; u.uW0.value = 0.0068 * c.thickness; u.uHalf.value = 0.028 + 0.005 * c.thickness; api.c = c; },
+            update(S, time) { setReveal(mat.uniforms, S, infoD, infoE, anim.draw.duration, time); },
+            dispose() { geo.dispose(); mat.dispose(); },
+        };
+        api.stats = { segments: geo.instanceCount, arms: crystal.branches.length };
+        api.apply(cfg);
+        return api;
+    },
+};