@3driseai/3drise-viewer 0.1.27 → 0.1.29

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

@@ -0,0 +1,763 @@
+import * as THREE from 'three';
+import { REVEAL_UNIFORMS, uniformsBase, frag, setReveal } from '../ribbon.js';
+import { prepare, applyDraw, applyErase, extentOf, DRAW_METHODS, ERASE_METHODS } from '../methods.js';
+// =========================================================================================
+// plasmaDischarge — dielectric breakdown (Lichtenberg figure) along the letter contours.
+//
+// MATHS / PHYSICS
+//  * The letter contours are the main conducting channels: a thin white-hot core (the arc column) inside a wider
+//    violet-blue N2 glow, both rendered as an exact distance field of the polyline (MAX-blended capsules).
+//  * Streamers are generated ONCE at build time by a seeded growth process (mulberry32 + `seed`): trunks leave the
+//    contour on the outward normal, weighted by convexity (field enhancement: stroke ends and corners spark most);
+//    each path is a midpoint-displaced crooked line, then forks recursively at shallow angles (16-37 deg) with
+//    length decaying per generation (dense near the channel, thinning with distance). A coarse occupancy grid
+//    (letters + every earlier streamer) truncates a branch where it would cross anything: no crossings, no tangle.
+//    Every branch carries a monotone random rank, so `branches` simply selects the subtree whose rank is below it.
+//  * Time: the leader races both ways round each contour from its sharpest point; a streamer is born where its
+//    parent was at that moment and grows ~2.4x faster than the leader (birth = parent birth + length / speed),
+//    which is written into the shared per-point schedule so every draw method works.
+//  * Colour is a quantity: channel temperature h = base + fresh-strike front + slow cooling burst + current pulse.
+//    h maps through a perceptual ramp  afterglow-magenta -> colour (violet) -> colour2 (hot blue-white).
+//  * Idle: current pulses (soft tail, sharp front) travel along every contour and continue up the streamers that
+//    root there; the pulse phase is integrated on the CPU. Terminal streamers breathe in length, each with its own
+//    phase; all flicker is smooth value noise in time.
+//  * Erase: streamers/channels extinguish and cool through the ramp into a fading magenta afterglow.
+// =========================================================================================
+const hex = (h) => new THREE.Color(h);
+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; }; }
+const clamp = (x, a, b) => Math.max(a, Math.min(b, x));
+const sstep = (a, b, x) => { const t = clamp((x - a) / (b - a), 0, 1); return t * t * (3 - 2 * t); };
+const REACH_MAX = 1.0; // em: the longest a streamer is ever generated (the live `reach` knob clips below it)
+const SEG_CAP = 15000; // instance budget for branch segments
+const W_SCALE = [1, 0.62, 0.46, 0.34, 0.26]; // core width per generation
+const H_SCALE = [1, 0.72, 0.56, 0.46, 0.4]; // halo radius per generation
+// ---------------------------------------------------------------------------------------------
+// build-time: outward normals, convexity, material mask
+// ---------------------------------------------------------------------------------------------
+function glyphEdges(strokes, gN) {
+    const E = [];
+    for (let g = 0; g < gN; g++)
+        E.push([]);
+    for (const s of strokes) {
+        const n = s.pts.length / 2;
+        for (let i = 0; i < n - 1; i++)
+            E[s.glyph].push(s.pts[2 * i], s.pts[2 * i + 1], s.pts[2 * i + 2], s.pts[2 * i + 3]);
+    }
+    return E;
+}
+function insideGlyph(edges, x, y) {
+    let c = false;
+    for (let i = 0; i < edges.length; i += 4) {
+        const ax = edges[i], ay = edges[i + 1], bx = edges[i + 2], by = edges[i + 3];
+        if ((ay <= y) !== (by <= y)) {
+            const xx = ax + ((y - ay) / (by - ay)) * (bx - ax);
+            if (xx > x)
+                c = !c;
+        }
+    }
+    return c;
+}
+// per contour point: outward normal (out of the letter material) and convexity (1/em, > 0 on a convex corner)
+function contourInfo(s, edges) {
+    const m = s.pts.length / 2 - 1;
+    const P = s.pts;
+    const nx = new Float32Array(m), ny = new Float32Array(m), conv = new Float32Array(m);
+    // index step so the chord spans ~0.05 em
+    const mean = s.len / m;
+    const k = Math.max(1, Math.round(0.05 / Math.max(1e-6, mean)));
+    for (let i = 0; i < m; i++) {
+        const a = (i - k + m * 4) % m, b = (i + k) % m;
+        let tx = P[2 * b] - P[2 * a], ty = P[2 * b + 1] - P[2 * a + 1];
+        const tl = Math.hypot(tx, ty) || 1;
+        tx /= tl;
+        ty /= tl;
+        let ox = ty, oy = -tx;
+        if (insideGlyph(edges, P[2 * i] + ox * 0.012, P[2 * i + 1] + oy * 0.012)) {
+            ox = -ox;
+            oy = -oy;
+        }
+        nx[i] = ox;
+        ny[i] = oy;
+        const cx = P[2 * a] + P[2 * b] - 2 * P[2 * i], cy = P[2 * a + 1] + P[2 * b + 1] - 2 * P[2 * i + 1];
+        const ch = Math.hypot(P[2 * b] - P[2 * a], P[2 * b + 1] - P[2 * a + 1]) * 0.5 + 1e-4;
+        conv[i] = -(cx * ox + cy * oy) / (ch * ch);
+    }
+    return { nx, ny, conv, k, m };
+}
+// Field-driven dielectric breakdown (DBM) growth.
+//  1. Solve Laplace's equation  div grad(phi) = 0  on a coarse grid: letters (and later every streamer) are conductors at
+//     phi = 1, the far boundary is ground at phi = 0. The start guess is the log-potential of the nearest conductor and
+//     SOR sweeps relax it, so the field piles up on stroke ends and corners all by itself.
+//  2. Streamers are grown tip by tip, all tips interleaved (competition). A tip samples a fan of candidate directions and
+//     picks one with probability ~ (potential drop towards that direction)^eta: it follows the field lines, curves
+//     towards ground and bends around other letters. eta comes from `branchiness`.
+//  3. Every new segment becomes a conductor (phi = 1) and the potential is re-relaxed around it, so neighbouring streamers
+//     screen each other: repulsion and gaps come out of the field, not from rejection tests.
+//  4. A tip forks where the field at it is strong (fork chance ~ |E|), at shallow angles, with a shorter length budget.
+function buildTree(strokes, gN, seed, info, branchiness) {
+    const rng = mulberry32((seed * 7919 + 1013) | 0);
+    const ETA = 12 - 9.5 * clamp(branchiness, 0, 1);
+    const ext = extentOf(strokes);
+    const PAD = REACH_MAX + 0.15;
+    const x0 = ext.x0 - PAD, y0 = ext.y0 - PAD, Wd = ext.w + 2 * PAD, Hd = ext.h + 2 * PAD;
+    let cell = 0.022;
+    while ((Wd / cell) * (Hd / cell) > 2.5e5)
+        cell *= 1.15;
+    const gw = Math.ceil(Wd / cell), gh = Math.ceil(Hd / cell), N = gw * gh;
+    const fixed = new Uint8Array(N); // 0 free, 1 conductor, 2 ground
+    const owner = new Int32Array(N).fill(-2); // -2 letter, >=0 streamer id
+    const phi = new Float32Array(N);
+    const cellOf = (x, y) => { const cx = Math.floor((x - x0) / cell), cy = Math.floor((y - y0) / cell); return cx < 1 || cy < 1 || cx >= gw - 1 || cy >= gh - 1 ? -1 : cy * gw + cx; };
+    const edges = glyphEdges(strokes, gN);
+    for (let g = 0; g < gN; g++) { // letter material (even-odd per glyph) is conductor
+        const E = edges[g];
+        if (!E.length)
+            continue;
+        let ya = 1e9, yb = -1e9;
+        for (let i = 1; i < E.length; i += 2) {
+            ya = Math.min(ya, E[i]);
+            yb = Math.max(yb, E[i]);
+        }
+        const r0 = Math.max(0, Math.floor((ya - y0) / cell)), r1 = Math.min(gh - 1, Math.ceil((yb - y0) / cell));
+        for (let r = r0; r <= r1; r++) {
+            const y = y0 + (r + 0.5) * cell;
+            const xs = [];
+            for (let i = 0; i < E.length; i += 4) {
+                const ay = E[i + 1], by = E[i + 3];
+                if ((ay <= y) !== (by <= y))
+                    xs.push(E[i] + ((y - ay) / (by - ay)) * (E[i + 2] - E[i]));
+            }
+            xs.sort((a, b) => a - b);
+            for (let k = 0; k + 1 < xs.length; k += 2) {
+                const c0 = Math.max(0, Math.ceil((xs[k] - x0) / cell - 0.5)), c1 = Math.min(gw - 1, Math.floor((xs[k + 1] - x0) / cell - 0.5));
+                for (let c = c0; c <= c1; c++)
+                    fixed[r * gw + c] = 1;
+            }
+        }
+    }
+    for (const s of strokes) { // contour line itself (3x3 dilated) so thin letters are solid conductors
+        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];
+            const l = Math.hypot(bx - ax, by - ay);
+            const st = Math.max(1, Math.ceil(l / (cell * 0.5)));
+            for (let q = 0; q <= st; q++) {
+                const c = cellOf(ax + (bx - ax) * q / st, ay + (by - ay) * q / st);
+                if (c < 0)
+                    continue;
+                const cx = c % gw, cy = (c - cx) / gw;
+                for (let dy = -1; dy <= 1; dy++)
+                    for (let dx = -1; dx <= 1; dx++) {
+                        const X = cx + dx, Y = cy + dy;
+                        if (X >= 0 && Y >= 0 && X < gw && Y < gh)
+                            fixed[Y * gw + X] = 1;
+                    }
+            }
+        }
+    }
+    for (let x = 0; x < gw; x++) {
+        fixed[x] = 2;
+        fixed[(gh - 1) * gw + x] = 2;
+    }
+    for (let y = 0; y < gh; y++) {
+        fixed[y * gw] = 2;
+        fixed[y * gw + gw - 1] = 2;
+    }
+    // start guess: log potential of the nearest conductor (chamfer distance), then SOR relaxation
+    const dist = new Float32Array(N);
+    for (let i = 0; i < N; i++)
+        dist[i] = fixed[i] === 1 ? 0 : 1e9;
+    const rel = (i, v) => { if (v < dist[i])
+        dist[i] = v; };
+    for (let y = 1; y < gh - 1; y++)
+        for (let x = 1; x < gw - 1; x++) {
+            const i = y * gw + x;
+            rel(i, dist[i - 1] + 1);
+            rel(i, dist[i - gw] + 1);
+            rel(i, dist[i - gw - 1] + 1.414);
+            rel(i, dist[i - gw + 1] + 1.414);
+        }
+    for (let y = gh - 2; y > 0; y--)
+        for (let x = gw - 2; x > 0; x--) {
+            const i = y * gw + x;
+            rel(i, dist[i + 1] + 1);
+            rel(i, dist[i + gw] + 1);
+            rel(i, dist[i + gw + 1] + 1.414);
+            rel(i, dist[i + gw - 1] + 1.414);
+        }
+    const lnR = Math.log(1 + PAD / 0.04);
+    for (let i = 0; i < N; i++)
+        phi[i] = fixed[i] === 1 ? 1 : fixed[i] === 2 ? 0 : clamp(1 - Math.log(1 + (dist[i] * cell) / 0.04) / lnR, 0, 1);
+    const OM = 1.9;
+    function sweepAll(n) { for (let s = 0; s < n; s++)
+        for (let y = 1; y < gh - 1; y++)
+            for (let i = y * gw + 1, e = y * gw + gw - 1; i < e; i++) {
+                if (fixed[i])
+                    continue;
+                phi[i] += OM * (0.25 * (phi[i - 1] + phi[i + 1] + phi[i - gw] + phi[i + gw]) - phi[i]);
+            } }
+    function sweepWin(cx, cy, R, n) {
+        const xa = Math.max(1, cx - R), xb = Math.min(gw - 2, cx + R), ya = Math.max(1, cy - R), yb = Math.min(gh - 2, cy + R);
+        for (let s = 0; s < n; s++)
+            for (let y = ya; y <= yb; y++)
+                for (let x = xa; x <= xb; x++) {
+                    const i = y * gw + x;
+                    if (fixed[i])
+                        continue;
+                    phi[i] += 1.5 * (0.25 * (phi[i - 1] + phi[i + 1] + phi[i - gw] + phi[i + gw]) - phi[i]);
+                }
+    }
+    sweepAll(Math.round(clamp(2.4e7 / N, 40, 160)));
+    const phiAt = (x, y) => {
+        const fx = (x - x0) / cell - 0.5, fy = (y - y0) / cell - 0.5;
+        const ix = Math.floor(fx), iy = Math.floor(fy);
+        if (ix < 0 || iy < 0 || ix >= gw - 1 || iy >= gh - 1)
+            return 0;
+        const tx = fx - ix, ty = fy - iy, a = iy * gw + ix;
+        return (phi[a] * (1 - tx) + phi[a + 1] * tx) * (1 - ty) + (phi[a + gw] * (1 - tx) + phi[a + gw + 1] * tx) * ty;
+    };
+    let Ex = 0, Ey = 0;
+    const fieldAt = (x, y) => { Ex = -(phiAt(x + cell, y) - phiAt(x - cell, y)) / (2 * cell); Ey = -(phiAt(x, y + cell) - phiAt(x, y - cell)) / (2 * cell); };
+    // trunk candidates: acceptance ~ field strength just outside the contour (field enhancement at ends and corners)
+    const probe = cell * 1.8;
+    const cands = [];
+    let Emax = 1e-6;
+    const samp = [];
+    strokes.forEach((s, si) => {
+        const I = info[si];
+        const m = I.m;
+        let d = 0.03 + rng() * 0.05;
+        let j = 0;
+        while (d < s.len) {
+            while (j < m - 1 && s.cum[j + 1] < d)
+                j++;
+            fieldAt(s.pts[2 * j] + I.nx[j] * probe, s.pts[2 * j + 1] + I.ny[j] * probe);
+            const e = Math.hypot(Ex, Ey);
+            samp.push({ si, idx: j, e, u: rng() });
+            Emax = Math.max(Emax, e);
+            d += 0.045 + rng() * 0.05;
+        }
+    });
+    const sortedE = samp.map((c) => c.e).sort((a, b) => a - b);
+    const Eref = Math.max(1e-6, sortedE[Math.floor(sortedE.length * 0.92)] || Emax);
+    for (const c of samp) {
+        const w = clamp(0.3 + 0.7 * Math.pow(clamp(c.e / Eref, 0, 1.3), 0.8), 0, 1);
+        if (c.u < w)
+            cands.push({ si: c.si, idx: c.idx, rank: c.u / w, w });
+    }
+    cands.sort((a, b) => a.rank - b.rank);
+    const H = 0.04, KDIR = 9, SPAN = 1.0; // step (em), candidate fan, half-angle of the fan (rad)
+    const all = [];
+    const tips = [];
+    let total = 0, steps = 0;
+    const isAnc = (v, id) => { let b = id; while (b >= 0) {
+        if (b === v)
+            return true;
+        b = all[b].parent;
+    } return false; };
+    function fixSeg(ax, ay, bx, by, id) {
+        const l = Math.hypot(bx - ax, by - ay);
+        const st = Math.max(1, Math.ceil(l / (cell * 0.5)));
+        let lc = -1;
+        for (let q = 0; q <= st; q++) {
+            const c = cellOf(ax + ((bx - ax) * q) / st, ay + ((by - ay) * q) / st);
+            if (c < 0 || c === lc)
+                continue;
+            lc = c;
+            if (!fixed[c]) {
+                fixed[c] = 1;
+                owner[c] = id;
+                phi[c] = 1;
+            }
+        }
+        const c = cellOf((ax + bx) / 2, (ay + by) / 2);
+        if (c >= 0) {
+            const cx = c % gw;
+            sweepWin(cx, (c - cx) / gw, 8, 3);
+        }
+    }
+    function spawn(x, y, h, budget, level, parent, dist0, rank, root, forkCum, w) {
+        const id = all.length;
+        const b = { id, parent, level, rank, dist0, rootStroke: root.si, rootIdx: root.idx, forkCum, glyph: strokes[root.si].glyph, children: 0, phase: rng() * Math.PI * 2, seed: rng(),
+            p: [x, y], len: 0, h, budget, alive: true, since: 0, side: rng() < 0.5 ? 1 : -1 };
+        all.push(b);
+        tips.push(b);
+        if (parent >= 0)
+            all[parent].children++;
+        return b;
+    }
+    const roots = [];
+    for (const cd of cands) {
+        const s = strokes[cd.si], I = info[cd.si];
+        const i = cd.idx % I.m;
+        const px = s.pts[2 * i], py = s.pts[2 * i + 1];
+        if (roots.some((r) => (r[0] - px) * (r[0] - px) + (r[1] - py) * (r[1] - py) < 0.0064))
+            continue;
+        roots.push([px, py]);
+        const L = REACH_MAX * (0.34 + 0.66 * Math.pow(rng(), 1.5)) * (0.7 + 0.3 * cd.w);
+        spawn(px, py, Math.atan2(I.ny[i], I.nx[i]), L, 0, -1, 0, cd.rank, { si: cd.si, idx: i }, 0, cd.w);
+    }
+    const th = [];
+    for (let k = 0; k < KDIR; k++)
+        th.push(((k / (KDIR - 1)) * 2 - 1) * SPAN);
+    const wk = new Float32Array(KDIR), dr = new Float32Array(KDIR);
+    const bF = 0.55 + 0.9 * clamp(branchiness, 0, 1);
+    let active = tips.length;
+    while (active > 0 && total < SEG_CAP && steps < 60000) {
+        active = 0;
+        for (let ti = 0; ti < tips.length; ti++) {
+            const t = tips[ti];
+            if (!t.alive)
+                continue;
+            active++;
+            if (total >= SEG_CAP) {
+                t.alive = false;
+                continue;
+            }
+            steps++;
+            const n = t.p.length;
+            const px = t.p[n - 2], py = t.p[n - 1];
+            fieldAt(px + Math.cos(t.h) * cell * 1.3, py + Math.sin(t.h) * cell * 1.3);
+            const Em = Math.hypot(Ex, Ey);
+            if (Em < 0.012 * Eref || t.len >= t.budget) {
+                t.alive = false;
+                continue;
+            }
+            // fork where the field at the tip is strong
+            t.since += H;
+            if (t.level < 4 && t.since >= 0.085 && t.len > 0.07) {
+                t.since = 0;
+                const pf = 0.8 * Math.pow(0.84, t.level) * clamp(0.3 + 0.9 * (Em / Eref), 0.3, 1.3) * bF;
+                const rem = t.budget - t.len;
+                if (rng() < pf && rem > 0.12 && t.dist0 + t.len < REACH_MAX - 0.1) {
+                    t.side = -t.side;
+                    const ca = t.h + t.side * (0.3 + 0.35 * rng());
+                    const crank = t.rank + (1 - t.rank) * Math.pow(rng(), 1.2) * 0.85;
+                    const ch = spawn(px, py, ca, Math.min(rem * (0.5 + 0.25 * rng()), REACH_MAX - t.dist0 - t.len), t.level + 1, t.id, t.dist0 + t.len, crank, { si: t.rootStroke, idx: t.rootIdx }, t.len, 0);
+                    ch.ownerPar = t.id;
+                }
+            }
+            // choose a direction: p ~ (potential drop ahead)^eta, only with the field (E.d > 0)
+            let dmax = 1e-6, cnt = 0;
+            for (let k = 0; k < KDIR; k++) {
+                const a = t.h + th[k];
+                const ca = Math.cos(a), sa = Math.sin(a);
+                if (Ex * ca + Ey * sa <= 0) {
+                    dr[k] = 0;
+                    continue;
+                }
+                dr[k] = Math.max(1e-5, 1 - phiAt(px + ca * H * 1.3, py + sa * H * 1.3)) * (0.35 + 0.65 * Math.cos(th[k] * 0.9));
+                dmax = Math.max(dmax, dr[k]);
+                cnt++;
+            }
+            if (!cnt) {
+                t.alive = false;
+                continue;
+            }
+            let sum = 0;
+            for (let k = 0; k < KDIR; k++) {
+                wk[k] = dr[k] > 0 ? Math.pow(dr[k] / dmax, ETA) : 0;
+                sum += wk[k];
+            }
+            let r = rng() * sum, kk = 0;
+            for (; kk < KDIR - 1; kk++) {
+                r -= wk[kk];
+                if (r <= 0)
+                    break;
+            }
+            const a = t.h + th[kk] + (rng() - 0.5) * 0.08;
+            const qx = px + Math.cos(a) * H, qy = py + Math.sin(a) * H;
+            // obstacles: a streamer stops at anything that is not its own trail (letters, other streamers, ground)
+            let hit = false;
+            const sl = Math.max(1, Math.ceil(H / (cell * 0.5)));
+            for (let q = 1; q <= sl && !hit; q++) {
+                const c = cellOf(px + ((qx - px) * q) / sl, py + ((qy - py) * q) / sl);
+                if (c < 0 || fixed[c] === 2) {
+                    hit = true;
+                    break;
+                }
+                if (fixed[c] === 1 && t.len > 0.1) {
+                    const o = owner[c];
+                    if (o !== t.id && !(o >= 0 && t.len < 0.2 && isAnc(o, t.id)))
+                        hit = true;
+                }
+            }
+            if (hit) {
+                t.alive = false;
+                continue;
+            }
+            fixSeg(px, py, qx, qy, t.id);
+            t.p.push(qx, qy);
+            t.len += H;
+            total++;
+            t.h = a;
+        }
+    }
+    // finalise: drop stubs (unless they carry children), compact ids
+    const keep = all.filter((b) => b.p.length >= 6 && (b.len >= 0.09 || b.children > 0));
+    const idMap = new Map();
+    keep.forEach((b, i) => idMap.set(b.id, i));
+    const out = [];
+    for (const b of keep) {
+        let par = b.parent;
+        while (par >= 0 && !idMap.has(par))
+            par = all[par].parent;
+        const pts = Float32Array.from(b.p);
+        const n = pts.length / 2;
+        const cum = new Float32Array(n);
+        for (let i = 1; i < n; i++)
+            cum[i] = cum[i - 1] + Math.hypot(pts[2 * i] - pts[2 * i - 2], pts[2 * i + 1] - pts[2 * i - 1]);
+        out.push({ pts, cum, len: cum[n - 1], level: b.level, parent: par < 0 ? -1 : idMap.get(par), rank: b.rank, dist0: b.dist0, rootStroke: b.rootStroke, rootIdx: b.rootIdx, forkCum: b.forkCum,
+            glyph: b.glyph, leaf: true, phase: b.phase, seed: b.seed });
+    }
+    for (const b of out)
+        if (b.parent >= 0)
+            out[b.parent].leaf = false;
+    for (const b of out)
+        if (b.parent >= 0)
+            b.forkCum = Math.min(b.forkCum, out[b.parent].len);
+    return out;
+}
+// ---------------------------------------------------------------------------------------------
+// schedule: look-native 'strike' + branch births for every method
+// ---------------------------------------------------------------------------------------------
+function strikeSched(strokes, o, G, info) {
+    const st = (o.stagger || 0.6) / G, win = 1 - (G - 1) * st;
+    return strokes.map((s, si) => {
+        const m = s.pts.length / 2;
+        const t = new Float32Array(m);
+        const k = info[si].start;
+        const c0 = s.cum[k];
+        for (let i = 0; i < m; i++) {
+            let u = (s.cum[i] - c0) / s.len;
+            u -= Math.floor(u);
+            t[i] = 2 * Math.min(u, 1 - u);
+        }
+        return { seg: [s.glyph * st, s.glyph * st + win], t };
+    });
+}
+function scheduleBranches(ch, brs, strike, clampEnd) {
+    let vr = 0;
+    for (const s of ch)
+        vr += s.len / Math.max(1e-3, (s.seg[1] - s.seg[0]) * (strike ? 2 : 1));
+    vr = Math.max(0.5, vr / Math.max(1, ch.length));
+    const vB = 2.4 * vr;
+    const lead = 0.006;
+    for (const b of brs) {
+        let tp;
+        if (b.parent < 0) {
+            const s = ch[b.rootStroke];
+            const t = s.t;
+            const i = Math.min(Math.floor(b.rootIdx), t.length - 2);
+            const fr = b.rootIdx - i;
+            tp = s.seg[0] + (t[i] + (t[i + 1] - t[i]) * fr) * (s.seg[1] - s.seg[0]);
+        }
+        else {
+            const p = brs[b.parent];
+            tp = p.seg[0] + (b.forkCum / p.len) * (p.seg[1] - p.seg[0]);
+        }
+        let s0 = Math.max(0, tp - (b.parent < 0 ? lead : 0));
+        const span = Math.max(0.01, b.len / vB);
+        let e0 = s0 + span;
+        if (clampEnd) {
+            e0 = Math.min(1, e0);
+            if (e0 - s0 < 0.012)
+                s0 = e0 - 0.012;
+        }
+        b.seg = [s0, e0];
+        b.t = Float32Array.from(b.cum, (c) => c / b.len);
+    }
+    if (!clampEnd) { // strike: stretch the whole schedule so the last streamer lands exactly at progress 1
+        let mx = 0;
+        for (const s of ch)
+            mx = Math.max(mx, s.seg[1]);
+        for (const b of brs)
+            mx = Math.max(mx, b.seg[1]);
+        const f = 1 / Math.max(1e-6, mx);
+        for (const s of ch)
+            s.seg = [s.seg[0] * f, s.seg[1] * f];
+        for (const b of brs)
+            b.seg = [b.seg[0] * f, b.seg[1] * f];
+    }
+}
+// ---------------------------------------------------------------------------------------------
+// geometry: one instanced quad per polyline segment (channels + streamers), MAX-blended distance field
+// ---------------------------------------------------------------------------------------------
+function buildGeometry(ch, brs, pulseN, rng) {
+    let n = 0;
+    for (const s of ch)
+        n += s.pts.length / 2 - 1;
+    for (const b of brs)
+        n += b.pts.length / 2 - 1;
+    const A = new Float32Array(n * 2), B = new Float32Array(n * 2), T = new Float32Array(n * 2), TO = new Float32Array(n * 2), SG = new Float32Array(n * 2), SO = new Float32Array(n * 2), U = new Float32Array(n * 2), D = new Float32Array(n * 2), P = new Float32Array(n * 2), M = new Float32Array(n * 4), N = new Float32Array(n * 4);
+    let k = 0;
+    const pOff = new Float32Array(ch.length);
+    ch.forEach((s, si) => {
+        const m = s.pts.length / 2;
+        const np = pulseN[si];
+        const pa = 0.7 + 0.3 * rng();
+        const ph = rng() * 6.28, sd = rng();
+        const po = rng();
+        pOff[si] = po;
+        for (let i = 0; i < m - 1; i++, k++) {
+            A.set([s.pts[2 * i], s.pts[2 * i + 1]], 2 * k);
+            B.set([s.pts[2 * i + 2], s.pts[2 * i + 3]], 2 * k);
+            T.set([s.t[i], s.t[i + 1]], 2 * k);
+            TO.set([s.tO[i], s.tO[i + 1]], 2 * k);
+            SG.set(s.seg, 2 * k);
+            SO.set(s.segO, 2 * k);
+            const u0 = s.cum[i] / s.len, u1 = s.cum[i + 1] / s.len;
+            U.set([u0, u1], 2 * k);
+            D.set([0, 0], 2 * k);
+            P.set([np * u0 + po, np * u1 + po], 2 * k);
+            M.set([0, 0, 0, H_SCALE[0]], 4 * k);
+            N.set([0, ph, sd, pa], 4 * k);
+        }
+    });
+    for (const b of brs) {
+        const m = b.pts.length / 2;
+        const rs = ch[b.rootStroke];
+        const np = pulseN[b.rootStroke];
+        const ri = Math.min(Math.floor(b.rootIdx), rs.pts.length / 2 - 2);
+        const u0r = (rs.cum[ri] + (rs.cum[ri + 1] - rs.cum[ri]) * (b.rootIdx - ri)) / rs.len;
+        const Kp = np / rs.len;
+        const lv = Math.min(4, b.level + 1);
+        for (let i = 0; i < m - 1; i++, k++) {
+            A.set([b.pts[2 * i], b.pts[2 * i + 1]], 2 * k);
+            B.set([b.pts[2 * i + 2], b.pts[2 * i + 3]], 2 * k);
+            T.set([b.t[i], b.t[i + 1]], 2 * k);
+            TO.set([b.tO[i], b.tO[i + 1]], 2 * k);
+            SG.set(b.seg, 2 * k);
+            SO.set(b.segO, 2 * k);
+            U.set([b.cum[i] / b.len, b.cum[i + 1] / b.len], 2 * k);
+            D.set([b.dist0 + b.cum[i], b.dist0 + b.cum[i + 1]], 2 * k);
+            P.set([np * u0r + pOff[b.rootStroke], np * u0r + pOff[b.rootStroke]], 2 * k);
+            M.set([b.level + 1, b.rank, Kp, H_SCALE[lv]], 4 * k);
+            N.set([b.leaf ? 1 : 0, b.phase, b.seed, 0.7 + 0.3 * ((b.seed * 7.3) % 1)], 4 * k);
+        }
+    }
+    const g = new THREE.InstancedBufferGeometry();
+    g.setAttribute('aq', new THREE.BufferAttribute(new Float32Array([-1, -1, 1, -1, 1, 1, -1, 1]), 2));
+    g.setIndex([0, 1, 2, 0, 2, 3]);
+    const ia = (key, a, c) => g.setAttribute(key, new THREE.InstancedBufferAttribute(a, c));
+    ia('iA', A, 2);
+    ia('iB', B, 2);
+    ia('iT', T, 2);
+    ia('iTO', TO, 2);
+    ia('iSeg', SG, 2);
+    ia('iSegO', SO, 2);
+    ia('iU', U, 2);
+    ia('iDist', D, 2);
+    ia('iP', P, 2);
+    ia('iM', M, 4);
+    ia('iN', N, 4);
+    g.instanceCount = n;
+    g.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e3);
+    return g;
+}
+const PD_VERT = /* glsl */ `
+attribute vec2 aq; attribute vec2 iA; attribute vec2 iB; attribute vec2 iT; attribute vec2 iTO; attribute vec2 iSeg; attribute vec2 iSegO;
+attribute vec2 iU; attribute vec2 iDist; attribute vec2 iP; attribute vec4 iM; attribute vec4 iN;
+${REVEAL_UNIFORMS}
+uniform float uBranches; uniform float uReach;
+varying float vSide; varying vec2 vUU; varying vec4 vTT; varying vec2 vLL; varying vec2 vSI; varying float vVar; varying float vGlyph; varying float vSeed; varying vec2 vPos;
+varying vec2 vXY; varying float vHL; varying float vR; varying vec2 vSO; varying vec2 vDst; varying vec2 vPh; varying vec4 vM; varying vec4 vN;
+void main(){
+  float lvl = iM.x;
+  float vis = lvl < 0.5 ? 1.0 : 1.0 - smoothstep(uBranches - 0.05, uBranches, iM.y);
+  float dmin = min(iDist.x, iDist.y);
+  if (vis < 0.004 || (lvl > 0.5 && dmin > uReach)) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); return; }
+  vec2 d = iB - iA; float l = max(length(d), 1e-6); vec2 dir = d / l; vec2 perp = vec2(-dir.y, dir.x);
+  float hl = 0.5 * l; float R = uHalf * iM.w;
+  vec2 loc = vec2(aq.x * (hl + R), aq.y * R);
+  vec2 w = 0.5 * (iA + iB) + dir * loc.x + perp * loc.y;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(w, 0.0, 1.0);
+  float sp = max(iSeg.y - iSeg.x, 1e-4), so = max(iSegO.y - iSegO.x, 1e-4);
+  vXY = loc; vHL = hl; vR = R; vSide = 0.0; vVar = 0.0; vGlyph = iN.z; vPos = w; vSeed = 0.0;
+  vTT = vec4(iT, iTO); vUU = iU; vSI = vec2(iSeg.x, sp);
+  vLL = vec2((uHead - iSeg.x) / sp, (uErase - iSegO.x) / so);
+  vSO = vec2(iSegO.x, so); vDst = iDist; vPh = iP; vM = iM; vN = iN;
+}`;
+const PD_FRAG = /* glsl */ `
+uniform vec3 uColor; uniform vec3 uColor2; uniform float uCore; uniform float uGlow; uniform float uOpacity; uniform float uPulse; uniform float uSpec;
+uniform float uPulsePh; uniform float uBreathPh; uniform float uBranches; uniform float uReach; uniform float uEDur;
+float vn(float x, float seed){ float i = floor(x); float f = fract(x); f = f*f*(3.0 - 2.0*f); return mix(h21(vec2(i, seed)), h21(vec2(i + 1.0, seed)), f); }
+// channel temperature h (0 cold .. 1 hot) -> perceptual ramp: afterglow magenta -> colour -> colour2
+vec3 ramp(float h){
+  vec3 cool = mix(uColor, vec3(0.60, 0.035, 0.40), 0.62)*0.55;
+  vec3 hot = mix(uColor2, vec3(1.0), 0.1);
+  vec3 a = mix(cool, uColor, smoothstep(0.0, 0.55, h));
+  return mix(a, hot, smoothstep(0.5, 1.0, h));
+}
+// current pulse: sharp leading front, soft exponential tail, exactly 0 at the seam
+float pulseShape(float x){ const float pk = 0.55; return exp(-max(pk - x, 0.0)*6.0)*smoothstep(0.0, 0.3, x)*(1.0 - smoothstep(pk, pk + 0.07, x)); }
+void main(){
+  float d = length(vec2(max(abs(vXY.x) - vHL, 0.0), vXY.y));
+  float fw = max(fwidth(d), 1e-5);
+  float f = clamp((vXY.x + vHL)/(2.0*max(vHL, 1e-6)), 0.0, 1.0);
+  float lvl = vM.x; float isB = step(0.5, lvl);
+  float lit = revealIn(f);
+  float gone = revealOut(f);
+  float age = ageAt(f);
+  float s = mix(vDst.x, vDst.y, f);
+  float ub = mix(vUU.x, vUU.y, f);
+  // erase afterglow: what the erase front has passed cools into a fading magenta ember
+  float tOut = mix(vTT.z, vTT.w, f);
+  float eAge = max(uErase - (vSO.x + tOut*vSO.y), 0.0)*uEDur;
+  float after = (1.0 - gone)*exp(-eAge/0.6)*0.5*(1.0 - smoothstep(0.8, 1.0, uE))*(uFadeOut > 0.5 ? 0.0 : 1.0);
+  float live = gone + after;
+  // streamer gates: branches knob, reach knob, breathing length of terminal streamers
+  float rankV = isB > 0.5 ? 1.0 - smoothstep(uBranches - 0.05, uBranches, vM.y) : 1.0;
+  float reachV = isB > 0.5 ? 1.0 - smoothstep(0.7*uReach, uReach, s) : 1.0;
+  float g = 1.0 - 0.45*vN.x*(0.5 + 0.5*sin(uBreathPh + vN.y));
+  float breathV = 1.0 - vN.x*smoothstep(g - 0.16, g, ub);
+  float vis = lit*live*rankV*reachV*breathV;
+  // temperature
+  float base = isB > 0.5 ? 0.43 - 0.045*lvl - 0.2*clamp(s/max(uReach, 0.05), 0.0, 1.0) : 0.52;
+  float tauF = isB > 0.5 ? 0.13 : 0.24;
+  float front = exp(-age/tauF);
+  float burst = exp(-age/1.4);
+  float x = fract(mix(vPh.x, vPh.y, f) + vM.z*s - uPulsePh);
+  float pu = pulseShape(x)*uPulse*vN.w*exp(-s/0.5)*smoothstep(0.4, 1.4, age);
+  float h0 = clamp(base + 0.36*burst + 0.4*front, 0.0, 1.0);
+  float h = clamp(h0 + 0.45*pu, 0.0, 1.0);
+  h = mix(h, 0.02, 1.0 - gone); h0 = mix(h0, 0.02, 1.0 - gone);
+  // profile: white-hot core, plasma column, N2 halo
+  float wsc = pow(0.68, max(lvl - 1.0, 0.0))*(isB > 0.5 ? 0.62 : 1.0);
+  float cw = max(uCore*wsc*(1.0 + 0.45*front + 0.5*pu), 1.15*fw);
+  float core = 1.0 - smoothstep(0.3*cw, cw, d);
+  float sg = 1.9*cw; float col2 = exp(-0.5*d*d/(sg*sg))*(1.0 - smoothstep(0.5*vR, vR, d));
+  float Rh = vR*(0.78 + 0.2*clamp(front + 0.15*pu, 0.0, 1.0));
+  float halo = pow(max(1.0 - d/Rh, 0.0), 2.3);
+  // brightness by generation, taper along the streamer and with distance from the channel
+  float amp = isB > 0.5 ? pow(0.74, lvl)*(1.0 - 0.5*ub)*(1.0 - 0.45*clamp(s/max(uReach, 0.05), 0.0, 1.0)) : 1.0;
+  float gs = vN.z*37.0 + 5.0;
+  float fl = isB > 0.5 ? 0.82 + 0.18*vn(uTime*2.2 + vN.y, gs) : 0.95 + 0.05*vn(uTime*1.4, gs);
+  vec3 cc = ramp(min(h0, 0.8));
+  vec3 pc = ramp(min(h, 0.72));
+  vec3 coreCol = mix(ramp(min(1.0, h + 0.3)), vec3(1.0), isB > 0.5 ? 0.12 + 0.2*h : 0.3 + 0.4*h);
+  vec3 c = coreCol*core*0.9 + pc*col2*(0.4 + 0.3*pu) + cc*halo*0.36*uGlow*(1.0 + 0.12*pu)*(isB > 0.5 ? 0.6 : 1.0);
+  // emission lines: the hottest channel grows a faint orange-red atomic-line fringe just outside the white core
+  float fringe = exp(-pow((d - 4.6*cw)/(1.5*cw), 2.0))*smoothstep(0.6, 1.0, h);
+  c += vec3(1.0, 0.27, 0.03)*fringe*0.2*uSpec;
+  // recombination afterglow: a very faint, wide, long-lived magenta glow left behind the strike front
+  float rec = exp(-age/5.0)*(1.0 - front);
+  c += ramp(0.1)*rec*pow(max(1.0 - d/vR, 0.0), 1.5)*0.2*uSpec*uGlow;
+  c *= amp*fl*vis*uOpacity;
+  gl_FragColor = vec4(c, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+export default {
+    key: 'plasmaDischarge', source: 'outline',
+    drawMethods: ['strike', ...DRAW_METHODS], eraseMethods: ERASE_METHODS, drawDefault: 'strike', eraseDefault: 'undraw',
+    methodInfo: { strike: { label: 'Strike', hint: 'A leader races both ways round each contour from its sharpest point; streamers shoot out ahead of it.' } },
+    catalog: {
+        name: 'Plasma Discharge',
+        description: 'Electrical breakdown along the letter contours: a white-hot arc channel with a violet halo, fractal streamers forking outward, current pulses and breathing branches. Use for sci-fi, energy and tech titles.',
+        tags: ['plasma', 'electric', 'lightning', 'lichtenberg', 'tesla', 'discharge', 'glow'],
+    },
+    defaults: { branches: 0.72, reach: 0.55, branchiness: 0.6, pulse: 0.8, glow: 1, spectrum: 0.5, core: 0.0065, color: '#6c3dff', color2: '#a9ceff', opacity: 1, seed: 7 },
+    ui: {
+        main: [
+            { name: 'branches', label: 'Branching', description: 'How many streamers fork off the letters', type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'reach', label: 'Reach', description: 'How far the streamers reach from the letters', type: 'number', min: 0.05, max: 1, step: 0.01 },
+            { name: 'branchiness', label: 'Branchiness', description: 'Low: straight streamers that follow the field closely. High: wandering, bushy, more forks', type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'glow', label: 'Glow', description: 'Brightness and size of the plasma halo', type: 'number', min: 0, max: 2, step: 0.01 },
+        ],
+        more: [
+            { name: 'pulse', label: 'Current pulses', description: 'Strength of the current pulses travelling along the channels', type: 'number', min: 0, max: 1.5, step: 0.01 },
+            { name: 'spectrum', label: 'Emission lines', description: 'Orange-red atomic-line tinge in the hottest channel and the faint recombination afterglow', type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'core', label: 'Core width', description: 'Thickness of the white-hot arc core', type: 'number', min: 0.002, max: 0.02, step: 0.0005 },
+            { name: 'color', label: 'Plasma', description: 'Colour of the plasma halo and cooling channels', type: 'color' },
+            { name: 'color2', label: 'Hot core', description: 'Colour of the hottest, freshly struck channel', type: 'color' },
+            { name: 'opacity', label: 'Opacity', description: 'Overall opacity', type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'seed', label: 'Seed', description: 'Different streamer layout', type: 'number', min: 0, max: 99, step: 1 },
+        ],
+    },
+    structural: ['seed', 'branchiness'],
+    presets: [
+        { name: 'Plasma', description: 'Violet-blue plasma, calm and layered', patch: {} },
+        { name: 'Tesla Coil', description: 'Dense, far-reaching streamers', patch: { branches: 0.95, reach: 0.85, pulse: 1.1, glow: 1.2, color: '#6a6cff', color2: '#e6f0ff' } },
+        { name: 'Quiet Arc', description: 'A few short streamers, soft pulses', patch: { branches: 0.3, reach: 0.3, pulse: 0.5, glow: 0.9 } },
+        { name: 'Rose Plasma', description: 'Magenta discharge with a pale hot core', patch: { color: '#e04ab8', color2: '#ffe4f6', branches: 0.7, reach: 0.55 } },
+        { name: 'Mercury Arc', description: 'Cold blue-cyan arc', patch: { color: '#3d8bff', color2: '#e0fbff', branches: 0.5, reach: 0.4, pulse: 0.9 } },
+    ],
+    build(layout, cfg, anim) {
+        const strokes = layout.strokes;
+        const G = Math.max(1, layout.glyphs.length);
+        prepare(strokes, 'outline');
+        strokes.forEach((s) => { s.glyphN = s.glyph / Math.max(1, G - 1); });
+        const edges = glyphEdges(strokes, G);
+        const info = strokes.map((s) => contourInfo(s, edges[s.glyph]));
+        const rngS = mulberry32((cfg.seed * 131 + 17) | 0);
+        info.forEach((I) => { let best = 0, bs = -1e9; for (let i = 0; i < I.m; i++) {
+            const v = I.conv[i] * (1 + 0.15 * rngS());
+            if (v > bs) {
+                bs = v;
+                best = i;
+            }
+        } I.start = best; });
+        const brs = strokes.length ? buildTree(strokes, G, Math.round(cfg.seed), info, cfg.branchiness) : [];
+        brs.forEach((b) => { b.ptime = b.len; b.pt = null; });
+        // ---- schedule: channels first, then every streamer from its parent's birth ----
+        const ctx = { G, ext: extentOf(strokes) };
+        const o = anim.draw;
+        let infoD;
+        if (o.method === 'strike') {
+            const sch = strikeSched(strokes, o, G, info);
+            strokes.forEach((s, i) => { s.seg = sch[i].seg; s.t = sch[i].t; });
+            ctx.drawSched = sch;
+            infoD = { soft: 0.004, tip: false, fade: false };
+        }
+        else
+            infoD = applyDraw(o.method, strokes, o, ctx);
+        scheduleBranches(strokes, brs, o.method === 'strike', o.method !== 'strike');
+        const all = strokes.concat(brs);
+        ctx.drawSched = all.map((s) => ({ seg: s.seg, t: s.t }));
+        ctx.drawInfo = infoD;
+        const infoE = applyErase(anim.erase.method, all, anim.erase, ctx);
+        const pulseN = strokes.map((s) => Math.max(1, Math.round(s.len / 1.4)));
+        const rng = mulberry32((cfg.seed * 977 + 3) | 0);
+        const geo = buildGeometry(strokes, brs, pulseN, rng);
+        const mat = new THREE.ShaderMaterial({
+            uniforms: {
+                ...uniformsBase(), uHalf: { value: 0.1 }, uColor: { value: hex(cfg.color) }, uColor2: { value: hex(cfg.color2) }, uCore: { value: cfg.core }, uGlow: { value: cfg.glow }, uOpacity: { value: 1 },
+                uPulse: { value: cfg.pulse }, uSpec: { value: cfg.spectrum }, uPulsePh: { value: 0 }, uBreathPh: { value: 0 }, uBranches: { value: cfg.branches }, uReach: { value: cfg.reach }, uEDur: { value: 2 },
+            },
+            vertexShader: PD_VERT, fragmentShader: frag(PD_FRAG, 'varying vec2 vXY; varying float vHL; varying float vR; varying vec2 vSO; varying vec2 vDst; varying vec2 vPh; varying vec4 vM; varying vec4 vN;\n'),
+            transparent: true, depthWrite: false, side: THREE.DoubleSide,
+            blending: THREE.CustomBlending, blendEquation: THREE.MaxEquation, blendSrc: THREE.OneFactor, blendDst: THREE.OneFactor,
+        });
+        const mesh = new THREE.Mesh(geo, mat);
+        mesh.frustumCulled = false;
+        const group = new THREE.Group();
+        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.uCore.value = c.core;
+                u.uGlow.value = c.glow;
+                u.uOpacity.value = c.opacity;
+                u.uPulse.value = c.pulse;
+                u.uSpec.value = c.spectrum;
+                u.uBranches.value = c.branches;
+                u.uReach.value = c.reach;
+                u.uHalf.value = 0.07 + 0.03 * Math.min(2, c.glow);
+            },
+            update(S, time) {
+                const u = mat.uniforms;
+                setReveal(u, S, infoD, infoE, anim.draw.duration, time);
+                u.uEDur.value = Math.max(0.05, anim.erase.duration);
+                u.uPulsePh.value = (time * 0.27) % 1; // current-pulse phase, integrated on the CPU
+                u.uBreathPh.value = (time * 0.7) % (Math.PI * 2); // streamer breathing phase
+            },
+            dispose() { geo.dispose(); mat.dispose(); },
+        };
+        api.apply(cfg);
+        return api;
+    },
+};