@3driseai/3drise-viewer 0.1.27 → 0.1.29

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

@@ -0,0 +1,496 @@
+import * as THREE from 'three';
+import { prepare, applyAnim, DRAW_METHODS, ERASE_METHODS } from '../methods.js';
+import { uniformsBase, setReveal, frag, REVEAL_UNIFORMS } from '../ribbon.js';
+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; }; }
+// =========================================================================================
+// constellation — the pen strokes become a star chart figure, the way an IAU constellation plate draws Orion or Cassiopeia.
+//
+//  Placement (CPU, seeded): along each stroke the star density rho(s) = (1/spacing)(1 + 1.3*kappa_n(s)) follows the curvature
+//  kappa of the pen path, so tight bends carry more stars; stars sit at the quantiles of the cumulative density (stratified
+//  inverse-CDF sampling = jittered, blue-noise-like spacing) and the strongest curvature extrema and both stroke ends are fixed
+//  anchors where a real figure would have its stars. Stars are joined in order by thin chart lines that stop a small gap short
+//  of each star and taper towards it.
+//
+//  Population: apparent magnitudes follow the power-law luminosity function N(m) ~ 10^(beta m) (many faint, few bright),
+//  inverse-CDF sampled; flux ~ 10^(-0.4 m) sets sprite size and peak. Blackbody temperature per star is drawn from a
+//  skewed law (most stars cool, a few hot) and mapped through the Planckian locus (Kang et al. xy fit -> XYZ -> linear sRGB).
+//  Scintillation is smooth value noise per star, slower and weaker for the brighter ones. A sparse layer of
+//  fainter-than-limit dust stars hugs the figure; it is revealed by the limiting magnitude (brightness knob), like a real sky.
+//
+//  Binaries: ~8% of the brighter stars are visual binaries. The companion sits on a Kepler ellipse (Kepler's equation solved with
+//  Newton steps from the mean anomaly M = 2 pi (t/P + M0)), projected by an inclination, and both members orbit the barycentre
+//  with shares 1/(1+k); the pair's combined flux equals the original star (m1 = m + 2.5 log10(1+k), flux2 = k flux1). Colours
+//  are an orange / blue pair like Albireo. The motion is internal to each pair (separation ~0.05 em), never a global move.
+//
+//  Motion: lines extend with the pen, each star ignites as the pen reaches it (white flash cooling to its class colour);
+//  idle life is twinkle plus a slow brightening wave travelling along arc length of every stroke.
+// =========================================================================================
+// ---- shared GLSL ------------------------------------------------------------------------
+const COMMON = /* glsl */ `
+uniform float uMlim; uniform float uPx;
+float figX(float m){ return max(uMlim - m, 0.5); }
+float figR(float m){ return 0.0055 + 0.0026*figX(m); }
+float pxPerLocal(float w){ return uPx*length(modelViewMatrix[0].xyz)/max(w, 1e-3); }
+// travelling brightening: a narrow wave in absolute arc length (em), phase offset per stroke
+float pulseAt(float arc, float off){ float ph = arc/2.2 - uTime*0.32*uIdleSpeed/2.2 + off; return pow(0.5 + 0.5*cos(6.2831853*ph), 8.0); }
+`;
+// ---- stars ------------------------------------------------------------------------------
+const STAR_VERT = /* glsl */ `
+attribute vec2 aq; attribute vec2 iP; attribute vec2 iTT; attribute vec2 iSeg; attribute vec2 iSegO; attribute vec4 iS; attribute vec2 iA; attribute vec4 iO; attribute vec4 iB;
+${REVEAL_UNIFORMS}
+uniform float uTwinkle; uniform float uTemp; uniform float uOpacity; uniform float uDurE; uniform vec3 uTint;
+${COMMON}
+varying vec2 vQ; varying float vInt; varying vec3 vCol; varying float vSp; varying float vRpx;
+float h11(float x){ return fract(sin(x*127.1)*43758.5453); }
+float vn(float x, float seed){ float i = floor(x); float f = fract(x); f = f*f*(3.0 - 2.0*f); float s = seed*31.7; return mix(h11(i + s), h11(i + 1.0 + s), f); }
+// blackbody -> linear sRGB (Kang et al. Planckian-locus fit in CIE xy, Y = 1)
+vec3 blackbody(float T){
+  T = clamp(T, 1700.0, 25000.0); float it = 1.0/T;
+  float x1 = -0.2661239e9*it*it*it - 0.2343589e6*it*it + 0.8776956e3*it + 0.179910;
+  float x2 = -3.0258469e9*it*it*it + 2.1070379e6*it*it + 0.2226347e3*it + 0.240390;
+  float x = T < 4000.0 ? x1 : x2;
+  float y1 = -1.1063814*x*x*x - 1.34811020*x*x + 2.18555832*x - 0.20219683;
+  float y2 = -0.9549476*x*x*x - 1.37418593*x*x + 2.09137015*x - 0.16748867;
+  float y3 = 3.0817580*x*x*x - 5.87338670*x*x + 3.75112997*x - 0.37001483;
+  float y = T < 2222.0 ? y1 : (T < 4000.0 ? y2 : y3);
+  float X = x/y; float Z = (1.0 - x - y)/y;
+  vec3 c = max(vec3(3.2406*X - 1.5372 - 0.4986*Z, -0.9689*X + 1.8758 + 0.0415*Z, 0.0557*X - 0.2040 + 1.0570*Z), 0.0);
+  return c/max(max(c.r, c.g), max(c.b, 1e-4));
+}
+void main(){
+  // binary orbit: Kepler's equation E - e sin E = M by Newton, relative vector projected by inclination, barycentric share
+  vec2 P0 = iP;
+  if (iO.z > 0.0) {
+    float Mn = 6.2831853*(uTime*uIdleSpeed*uIdle/iO.y + iO.w);
+    float ec = iO.x; float E = Mn + ec*sin(Mn);
+    for (int k = 0; k < 5; k++) { E -= (E - ec*sin(E) - Mn)/(1.0 - ec*cos(E)); }
+    vec2 rr = vec2(cos(E) - ec, sqrt(1.0 - ec*ec)*sin(E))*iO.z;
+    float co = cos(iB.x), si = sin(iB.x);
+    rr = vec2(co*rr.x - si*rr.y, (si*rr.x + co*rr.y)*iB.y);
+    P0 += rr*iB.z;
+  }
+  float m = iS.x; float T = iS.y; float rnd = iS.z; float dust = step(0.5, iS.w);
+  float x = uMlim - m; float xe = max(x, 0.5);
+  float R = mix(0.0055 + 0.0026*xe, 0.0036 + 0.0006*clamp(x, -2.0, 1.0), dust);
+  float I = mix(clamp(0.2 + 0.13*xe, 0.0, 0.92), 0.22*smoothstep(-2.6, 0.5, x), dust);
+  float spike = (1.0 - dust)*smoothstep(3.5, 4.4, xe);
+  // ---- schedule (global progress units; shaders never know which draw / erase method ran)
+  float sp = max(iSeg.y - iSeg.x, 1e-4); float so = max(iSegO.y - iSegO.x, 1e-4);
+  float lI = (uHead - iSeg.x)/sp;
+  float lit = uFadeIn > 0.5 ? smoothstep(rnd*0.6, rnd*0.6 + 0.4, uD) : smoothstep(0.0, max(uSoftIn, 1e-4), lI - iTT.x);
+  float age = uFadeIn > 0.5 ? max(0.0, uD - rnd*0.6)*uDur + uSince : max(0.0, uHead - (iSeg.x + iTT.x*sp))*uDur + uSince;
+  float wG = clamp(0.5/max(uDurE, 0.05), 0.05, 0.5);
+  float tG = iSegO.x + iTT.y*so; float ts = tG*(1.0 - wG);
+  float gone = uFadeOut > 0.5 ? 1.0 - smoothstep(rnd*0.6, rnd*0.6 + 0.4, uE) : 1.0 - smoothstep(ts, ts + wG, uE);
+  lit *= mix(1.0, smoothstep(0.0, 1.1, age), dust);
+  // ---- scintillation: smooth value noise, brighter = slower and weaker
+  float f = clamp(m/5.0, 0.0, 1.0);
+  float tt = uTime*mix(0.45, 1.25, f)*uIdleSpeed;
+  float n = 0.65*vn(tt + rnd*40.0, rnd) + 0.35*vn(tt*2.7 + rnd*70.0, rnd + 3.0);
+  float amp = uTwinkle*mix(0.10, 0.25, f)*uIdle;
+  float tw = max(0.2, 1.0 + 1.25*amp*(2.0*n - 1.0));
+  // ---- birth flash: white overshoot cooling to the class colour
+  float settled = smoothstep(0.3, 1.8, age);
+  float pulse = pulseAt(iA.x, iA.y)*settled*uIdle;
+  float flash = exp(-age/0.22)*(1.0 - 0.7*dust);
+  float white = exp(-age/0.26)*(1.0 - 0.6*dust);
+  float life = lit*gone*uOpacity;
+  float Iv = I*tw*(1.0 + 0.4*pulse)*(1.0 + 0.9*flash)*life;
+  vec3 bbc = mix(blackbody(T*exp(0.55*uTemp)), vec3(1.0), 0.1)*mix(vec3(1.0), uTint, 0.35);
+  vCol = mix(bbc, vec3(1.0), 0.9*white);
+  // ---- sprite size, with a one-pixel floor and flux conservation (no sub-pixel shimmer)
+  vec4 mv = modelViewMatrix*vec4(P0, 0.0, 1.0); vec4 cp = projectionMatrix*mv;
+  float pxl = pxPerLocal(cp.w);
+  float Rw = R*(1.0 + 0.6*amp*(2.0*n - 1.0))*(1.0 + 0.6*flash)*(0.55 + 0.45*gone);
+  float Re = max(Rw, 1.0/pxl);
+  float energy = min(1.0, (Rw*Rw)/(Re*Re));
+  vInt = Iv*energy; vSp = spike; vRpx = Re*pxl;
+  float Hm = mix(5.5, 12.0, spike);
+  vQ = aq*Hm;
+  if (Iv < 0.002) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); return; }
+  vec2 w = P0 + aq*(Re*Hm);
+  gl_Position = projectionMatrix*modelViewMatrix*vec4(w, 0.0, 1.0);
+}`;
+const STAR_FRAG = /* glsl */ `
+precision highp float;
+varying vec2 vQ; varying float vInt; varying vec3 vCol; varying float vSp; varying float vRpx;
+void main(){
+  float r2 = dot(vQ, vQ); float r = sqrt(r2);
+  float core = exp(-r2*1.7);
+  float halo = 0.22/pow(1.0 + r2/0.8, 1.5)*(1.0 - smoothstep(3.0, 5.5, r));
+  // four-point diffraction spikes: thin Gaussian across, power-law decay along, always at least ~1px wide
+  float wq = max(0.06, 0.8/max(vRpx, 0.5));
+  vec2 a = abs(vQ);
+  float s1 = exp(-pow(a.y/wq, 2.0))/pow(1.0 + a.x*0.9, 2.0)*(1.0 - smoothstep(7.0, 12.0, a.x));
+  float s2 = exp(-pow(a.x/wq, 2.0))/pow(1.0 + a.y*0.9, 2.0)*(1.0 - smoothstep(7.0, 12.0, a.y));
+  float spk = vSp*0.85*(s1 + s2);
+  vec3 col = (vCol*(halo + spk) + mix(vCol, vec3(1.0), 0.6)*core)*vInt;
+  if (max(col.r, max(col.g, col.b)) < 0.0015) discard;
+  gl_FragColor = vec4(col, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+// ---- chart lines ------------------------------------------------------------------------
+const LINE_VERT = /* glsl */ `
+attribute vec2 aq; attribute vec2 iA; attribute vec2 iB; attribute vec4 iT; attribute vec2 iSeg; attribute vec2 iSegO; attribute vec2 iM; attribute vec3 iL;
+${REVEAL_UNIFORMS}
+${COMMON}
+uniform float uLineW;
+varying float vSide; varying vec2 vUU; varying vec4 vTT; varying vec2 vLL; varying vec2 vSI; varying float vSeed;
+varying vec2 vXY; varying vec3 vLN; varying vec2 vG;
+void main(){
+  vec2 d = iB - iA; float l = max(length(d), 1e-6); vec2 dir = d/l; vec2 perp = vec2(-dir.y, dir.x);
+  vec4 cp = projectionMatrix*modelViewMatrix*vec4(0.5*(iA + iB), 0.0, 1.0);
+  float pxl = pxPerLocal(cp.w);
+  float hw = max(uLineW, 0.7/pxl); float mg = 1.5/pxl; float hl = 0.5*l;
+  vec2 loc = vec2(aq.x*(hl + mg), aq.y*(hw + mg));
+  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; vLN = vec3(hl, hw, min(1.0, uLineW/hw)); vG = vec2(1.25*figR(iM.x) + 0.005, 1.25*figR(iM.y) + 0.005);
+  vSide = 0.0; vTT = iT; vUU = iL.xy; vSeed = iL.z; vSI = vec2(iSeg.x, sp);
+  vLL = vec2((uHead - iSeg.x)/sp, (uErase - iSegO.x)/so);
+}`;
+const LINE_FRAG = /* glsl */ `
+uniform vec3 uColor; uniform vec3 uColor2; uniform float uLines; uniform float uOpacity;
+void main(){
+  float hl = vLN.x; float hw = vLN.y; float amp = vLN.z;
+  float fw = max(fwidth(vXY.y), 1e-5);   // derivatives first: no discard before them
+  float l = 2.0*hl; float u = vXY.x + hl;
+  float gA = vG.x; float gB = vG.y; float room = l - gA - gB;
+  float taper = clamp(0.5*room, 1e-4, 0.05);
+  float tap = smoothstep(gA, gA + taper, u)*(1.0 - smoothstep(l - gB - taper, l - gB, u))*smoothstep(0.02, 0.06, room);
+  float hwe = hw*mix(0.45, 1.0, tap);
+  float lineA = 1.0 - smoothstep(hwe - fw, hwe + fw, abs(vXY.y));
+  float f = clamp(u/l, 0.0, 1.0);
+  float lit = revealIn(f); float gone = revealOut(f); float age = ageAt(f);
+  lit *= smoothstep(0.0, 0.035, age);
+  float settled = smoothstep(0.3, 1.8, age);
+  float P = pulseAt(mix(vUU.x, vUU.y, f), vSeed)*settled*uIdle;
+  float born = exp(-age/0.12);
+  float a = lineA*tap*lit*gone*amp*uLines*0.62*(0.6 + 0.9*P)*(1.0 + 0.6*born)*uOpacity;
+  vec3 col = mix(uColor, uColor2, clamp(0.6*P + 0.5*born, 0.0, 1.0));
+  gl_FragColor = vec4(col*a, 1.0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+// ---- CPU: stroke sampling -----------------------------------------------------------------
+function sampler(s) {
+    const n = s.pts.length / 2, P = s.pts, C = s.cum, L = s.len;
+    const at = (a) => { a = Math.max(0, Math.min(L, a)); let lo = 0, hi = n - 1; while (hi - lo > 1) {
+        const m = (lo + hi) >> 1;
+        if (C[m] <= a)
+            lo = m;
+        else
+            hi = m;
+    } const d = C[hi] - C[lo]; return [lo, hi, d > 1e-9 ? (a - C[lo]) / d : 0]; };
+    return {
+        pos(a) { const [i, j, f] = at(a); return [P[2 * i] + (P[2 * j] - P[2 * i]) * f, P[2 * i + 1] + (P[2 * j + 1] - P[2 * i + 1]) * f]; },
+        val(arr, a) { const [i, j, f] = at(a); return arr[i] + (arr[j] - arr[i]) * f; },
+    };
+}
+const BETA = 0.5;
+function lumFn(u, m0, m1) { const a = Math.pow(10, BETA * m0), b = Math.pow(10, BETA * m1); return Math.log10(a + u * (b - a)) / BETA; }
+function placeStroke(s, spacing, rng) {
+    const L = s.len;
+    const smp = sampler(s);
+    if (L < 0.55 * spacing)
+        return [{ s: L / 2, off: 0, anchor: 1 }];
+    const h = 0.008, N = Math.max(4, Math.ceil(L / h)), step = L / N;
+    const X = new Float32Array(N + 1), Y = new Float32Array(N + 1);
+    for (let k = 0; k <= N; k++) {
+        const p = smp.pos(k * step);
+        X[k] = p[0];
+        Y[k] = p[1];
+    }
+    const k0 = Math.max(2, Math.round(0.035 / step));
+    const kap = new Float32Array(N + 1);
+    for (let k = 0; k <= N; k++) {
+        const a = Math.max(0, k - k0), b = Math.min(N, k + k0);
+        if (k === 0 || k === N || b - a < 2)
+            continue;
+        const ax = X[k] - X[a], ay = Y[k] - Y[a], bx = X[b] - X[k], by = Y[b] - Y[k];
+        const la = Math.hypot(ax, ay), lb = Math.hypot(bx, by);
+        if (la < 1e-9 || lb < 1e-9)
+            continue;
+        kap[k] = Math.abs(Math.atan2(ax * by - ay * bx, ax * bx + ay * by)) / (0.5 * (la + lb));
+    }
+    const ks = new Float32Array(N + 1);
+    for (let k = 0; k <= N; k++) {
+        let t = 0, c = 0;
+        for (let j = Math.max(0, k - k0); j <= Math.min(N, k + k0); j++) {
+            t += kap[j];
+            c++;
+        }
+        ks[k] = Math.min(1.5, t / c / 9);
+    }
+    const rho = (k) => (1 / spacing) * (1 + 1.3 * ks[k]);
+    const M = new Float32Array(N + 1);
+    for (let k = 1; k <= N; k++)
+        M[k] = M[k - 1] + 0.5 * (rho(k) + rho(k - 1)) * step;
+    // anchors: both ends + the strongest curvature maxima (>= 0.8 spacing apart, away from the ends)
+    const w = Math.max(1, Math.round(0.5 * spacing / step));
+    const cand = [];
+    for (let k = w; k <= N - w; k++) {
+        if (ks[k] < 0.5 || k * step < 0.6 * spacing || (N - k) * step < 0.6 * spacing)
+            continue;
+        let ok = true;
+        for (let j = k - w; j <= k + w; j++)
+            if (ks[j] > ks[k] || (ks[j] === ks[k] && j < k)) {
+                ok = false;
+                break;
+            }
+        if (ok)
+            cand.push(k);
+    }
+    cand.sort((a, b) => ks[b] - ks[a]);
+    const picked = [];
+    for (const k of cand)
+        if (picked.every((q) => Math.abs(q - k) * step >= 0.8 * spacing))
+            picked.push(k);
+    picked.sort((a, b) => a - b);
+    const anchors = [0, ...picked, N];
+    const out = [];
+    const kOfMass = (mass) => { let lo = 0, hi = N; while (hi - lo > 1) {
+        const m = (lo + hi) >> 1;
+        if (M[m] <= mass)
+            lo = m;
+        else
+            hi = m;
+    } const d = M[hi] - M[lo]; return lo + (d > 1e-9 ? (mass - M[lo]) / d : 0); };
+    for (let ai = 0; ai < anchors.length; ai++) {
+        const ka = anchors[ai];
+        out.push({ s: ka * step, off: 0, anchor: 1, end: ai === 0 || ai === anchors.length - 1 });
+        if (ai === anchors.length - 1)
+            break;
+        const kb = anchors[ai + 1];
+        const mass = M[kb] - M[ka];
+        const nInt = Math.max(1, Math.round(mass));
+        for (let j = 1; j < nInt; j++) {
+            const q = (j + (rng() - 0.5) * 0.55) / nInt;
+            const kf = kOfMass(M[ka] + q * mass);
+            out.push({ s: kf * step, off: (rng() - 0.5) * 2 * 0.18 / rho(Math.round(kf)), anchor: 0 });
+        }
+    }
+    for (const o of out)
+        if (o.anchor && !o.end)
+            o.off = (rng() - 0.5) * 2 * 0.1 * spacing;
+    return out;
+}
+export default {
+    key: 'constellation', source: 'hand', drawMethods: DRAW_METHODS, eraseMethods: ERASE_METHODS, drawDefault: 'pen', eraseDefault: 'undraw',
+    catalog: {
+        name: 'Constellation',
+        description: 'Pen strokes become a planetarium star plate: blackbody-coloured stars with Kepler binaries, tapered chart lines and faint dust stars. Use for space, astronomy, night-sky and elegant title cards.',
+        tags: ['constellation', 'stars', 'star-chart', 'binary-star', 'astronomy', 'night-sky', 'planetarium', 'space'],
+    },
+    defaults: { stars: 5.5, brightness: 0, twinkle: 1, lines: 1, temperature: 0, seed: 7, color: '#7f9bd0', color2: '#dce8ff', opacity: 1 },
+    ui: {
+        main: [
+            { name: 'stars', label: 'Stars', description: 'Stars per em of pen stroke (density along the figure)', type: 'number', min: 3, max: 16, step: 0.5, unit: '/em' },
+            { name: 'brightness', label: 'Brightness', description: 'Limiting magnitude shift: brighter, larger stars and more of the faint dust show', type: 'number', min: -1.5, max: 1.5, step: 0.05, unit: 'mag' },
+            { name: 'temperature', label: 'Temperature', description: 'Shifts the whole star population cooler (amber) or hotter (blue-white)', type: 'number', min: -1, max: 1, step: 0.02 },
+            { name: 'lines', label: 'Chart lines', description: 'Visibility of the lines joining the stars', type: 'number', min: 0, max: 1.5, step: 0.02 },
+        ],
+        more: [
+            { name: 'twinkle', label: 'Twinkle', description: 'Scintillation strength (0 = steady stars)', type: 'number', min: 0, max: 2, step: 0.02 },
+            { name: 'color', label: 'Line colour', description: 'Colour of the chart lines', type: 'color' },
+            { name: 'color2', label: 'Highlight / tint', description: 'Pulse highlight on the lines and a soft tint on the stars', type: 'color' },
+            { name: 'opacity', label: 'Opacity', description: 'Overall opacity', type: 'number', min: 0, max: 1, step: 0.01 },
+            { name: 'seed', label: 'Seed', description: 'Which sky: star positions, magnitudes and colours', type: 'number', min: 0, max: 999, step: 1 },
+        ],
+    },
+    structural: ['stars', 'seed'],
+    presets: [
+        { name: 'Default', description: 'Cool planetarium chart', patch: {} },
+        { name: 'Winter sky', description: 'Hotter, bluer stars with icy lines', patch: { temperature: 0.55, color: '#8fb4ee', color2: '#eaf2ff', brightness: 0.2 } },
+        { name: 'Ember', description: 'Cool amber population with warm lines', patch: { temperature: -0.75, color: '#c79a6c', color2: '#ffe0b0', twinkle: 1.2 } },
+        { name: 'Sparse chart', description: 'Fewer visible stars, bolder figure lines', patch: { brightness: -0.8, lines: 1.35, twinkle: 0.7 } },
+        { name: 'Deep field', description: 'Faint dust fully visible, lines in the background', patch: { brightness: 1.1, lines: 0.55, twinkle: 1.3 } },
+    ],
+    build(layout, cfg, anim) {
+        const strokes = layout.strokes;
+        prepare(strokes, 'hand');
+        const G = layout.glyphs.length;
+        const { infoD, infoE } = applyAnim(strokes, anim, G);
+        const rng = mulberry32(((Math.round(cfg.seed) | 0) * 7919 + 12345) | 0);
+        const spacing = 1 / Math.max(1, cfg.stars);
+        // ---- stars
+        const stars = [];
+        const lineSegs = [];
+        strokes.forEach((s, si) => {
+            if (!(s.len > 0))
+                return;
+            const smp = sampler(s);
+            const off = ((si * 0.6180339) % 1);
+            const pl = placeStroke(s, spacing, rng);
+            const row = [];
+            for (const o of pl) {
+                const p = smp.pos(o.s), q = smp.pos(o.s + 0.01), p0 = smp.pos(o.s - 0.01);
+                let tx = q[0] - p0[0], ty = q[1] - p0[1];
+                const tl = Math.hypot(tx, ty) || 1;
+                tx /= tl;
+                ty /= tl;
+                const u = rng();
+                const uu = o.anchor ? Math.pow(u, 1.6) : u;
+                const st = { si, s: o.s, x: p[0] - ty * o.off, y: p[1] + tx * o.off, m: lumFn(uu, 0.2, 4.6), T: 3200 + 21000 * Math.pow(rng(), 3), rnd: rng(), anchor: o.anchor, arc: o.s, off, dust: 0 };
+                st.tI = smp.val(s.t, o.s);
+                st.tO = smp.val(s.tO, o.s);
+                st.stroke = s;
+                row.push(st);
+                stars.push(st);
+            }
+            for (let i = 0; i + 1 < row.length; i++)
+                lineSegs.push([row[i], row[i + 1]]);
+        });
+        // a real figure always has a few brilliant stars: promote some anchors if the luminosity function gave none
+        const want = Math.max(1, Math.round(stars.length * 0.018));
+        let have = stars.filter((t) => t.m < 1.3).length;
+        const pool = stars.filter((t) => t.anchor && t.m >= 1.3);
+        while (have < want && pool.length) {
+            const t = pool.splice(Math.floor(rng() * pool.length), 1)[0];
+            t.m = 0.2 + 0.9 * rng();
+            have++;
+        }
+        // ---- dust: fainter-than-limit stars hugging the figure
+        const total = strokes.reduce((a, s) => a + s.len, 0);
+        const nDust = Math.round(stars.length * 0.7);
+        const dust = [];
+        for (let k = 0, guard = 0; k < nDust && guard < nDust * 20 && total > 0; guard++) {
+            let r = rng() * total, si = 0;
+            for (; si < strokes.length - 1; si++) {
+                if (r < strokes[si].len)
+                    break;
+                r -= strokes[si].len;
+            }
+            const s = strokes[si];
+            if (!(s.len > 0))
+                continue;
+            const smp = sampler(s);
+            const a = r;
+            const p = smp.pos(a), q = smp.pos(a + 0.01), p0 = smp.pos(a - 0.01);
+            let tx = q[0] - p0[0], ty = q[1] - p0[1];
+            const tl = Math.hypot(tx, ty) || 1;
+            tx /= tl;
+            ty /= tl;
+            const g = (rng() + rng() + rng() - 1.5) * 2;
+            const dd = (0.06 + Math.abs(g) * 0.12) * (rng() < 0.5 ? -1 : 1);
+            const x = p[0] - ty * dd, y = p[1] + tx * dd;
+            if (stars.some((t) => Math.hypot(t.x - x, t.y - y) < 0.05) || dust.some((t) => Math.hypot(t.x - x, t.y - y) < 0.07))
+                continue;
+            const d = { si, x, y, m: lumFn(rng(), 4.6, 7.2), T: 3600 + 16000 * Math.pow(rng(), 2.2), rnd: rng(), arc: a, off: ((si * 0.6180339) % 1), dust: 1, stroke: s };
+            d.tI = Math.min(1, smp.val(s.t, a) + 0.03 * rng());
+            d.tO = smp.val(s.tO, a);
+            dust.push(d);
+            k++;
+        }
+        stars.forEach((t) => { t.mr = t.m; t.bin = null; });
+        // ---- binaries (own seeded stream, so the rest of the sky is unchanged)
+        const brng = mulberry32(((Math.round(cfg.seed) | 0) * 104729 + 31337) | 0);
+        const companions = [];
+        const cand = stars.filter((t) => t.m < 2.9);
+        const nb = stars.length >= 8 ? Math.max(1, Math.round(stars.length * 0.08)) : 0;
+        for (let b = 0; b < nb && cand.length; b++) {
+            const t = cand.splice(Math.floor(brng() * cand.length), 1)[0];
+            const k = 0.35 + 0.45 * brng();
+            const e = 0.15 + 0.55 * brng();
+            const per = 35 + 55 * brng();
+            const a = 0.07 + 0.04 * brng();
+            const om = 6.2831853 * brng(), ci = 0.45 + 0.5 * brng(), M0 = brng();
+            const swap = brng() < 0.4;
+            const Tc = 3700 + 900 * brng(), Th = 11000 + 4500 * brng();
+            const m1 = t.m + 2.5 * Math.log10(1 + k), m2 = m1 - 2.5 * Math.log10(k);
+            t.mr = m1;
+            t.T = swap ? Th : Tc;
+            t.bin = { o: [e, per, a, M0], b: [om, ci, -k / (1 + k), 0] };
+            const c = Object.assign({}, t, { mr: m2, T: swap ? Tc : Th, rnd: brng(), anchor: 0, bin: { o: [e, per, a, M0], b: [om, ci, 1 / (1 + k), 0] } });
+            companions.push(c);
+        }
+        const all = stars.concat(companions, dust);
+        // ---- geometry
+        const quad = new Float32Array([-1, -1, 1, -1, 1, 1, -1, 1]);
+        const sg = new THREE.InstancedBufferGeometry();
+        sg.setAttribute('aq', new THREE.BufferAttribute(quad, 2));
+        sg.setIndex([0, 1, 2, 0, 2, 3]);
+        const n = all.length;
+        const aP = new Float32Array(n * 2), aTT = new Float32Array(n * 2), aSeg = new Float32Array(n * 2), aSegO = new Float32Array(n * 2), aS = new Float32Array(n * 4), aA = new Float32Array(n * 2), aO = new Float32Array(n * 4), aBn = new Float32Array(n * 4);
+        all.forEach((t, i) => { aP.set([t.x, t.y], 2 * i); aTT.set([t.tI, t.tO], 2 * i); aSeg.set(t.stroke.seg, 2 * i); aSegO.set(t.stroke.segO, 2 * i); aS.set([t.mr !== undefined ? t.mr : t.m, t.T, t.rnd, t.dust], 4 * i); if (t.bin) {
+            aO.set(t.bin.o, 4 * i);
+            aBn.set(t.bin.b, 4 * i);
+        } aA.set([t.arc, t.off], 2 * i); });
+        const ia = (g, k, a, c) => g.setAttribute(k, new THREE.InstancedBufferAttribute(a, c));
+        ia(sg, 'iP', aP, 2);
+        ia(sg, 'iTT', aTT, 2);
+        ia(sg, 'iSeg', aSeg, 2);
+        ia(sg, 'iSegO', aSegO, 2);
+        ia(sg, 'iS', aS, 4);
+        ia(sg, 'iA', aA, 2);
+        ia(sg, 'iO', aO, 4);
+        ia(sg, 'iB', aBn, 4);
+        sg.instanceCount = n;
+        sg.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e3);
+        const lg = new THREE.InstancedBufferGeometry();
+        lg.setAttribute('aq', new THREE.BufferAttribute(quad, 2));
+        lg.setIndex([0, 1, 2, 0, 2, 3]);
+        const nl = lineSegs.length;
+        const lA = new Float32Array(nl * 2), lB = new Float32Array(nl * 2), lT = new Float32Array(nl * 4), lS = new Float32Array(nl * 2), lSO = new Float32Array(nl * 2), lM = new Float32Array(nl * 2), lL = new Float32Array(nl * 3);
+        lineSegs.forEach(([a, b], i) => { lA.set([a.x, a.y], 2 * i); lB.set([b.x, b.y], 2 * i); lT.set([a.tI, b.tI, a.tO, b.tO], 4 * i); lS.set(a.stroke.seg, 2 * i); lSO.set(a.stroke.segO, 2 * i); lM.set([a.m, b.m], 2 * i); lL.set([a.arc, b.arc, a.off], 3 * i); });
+        ia(lg, 'iA', lA, 2);
+        ia(lg, 'iB', lB, 2);
+        ia(lg, 'iT', lT, 4);
+        ia(lg, 'iSeg', lS, 2);
+        ia(lg, 'iSegO', lSO, 2);
+        ia(lg, 'iM', lM, 2);
+        ia(lg, 'iL', lL, 3);
+        lg.instanceCount = nl;
+        lg.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e3);
+        const common = () => ({ uMlim: { value: 5.2 }, uPx: { value: 800 }, uOpacity: { value: 1 } });
+        const smat = new THREE.ShaderMaterial({
+            uniforms: { ...uniformsBase(), ...common(), uTwinkle: { value: 1 }, uTemp: { value: 0 }, uDurE: { value: anim.erase.duration || 2 }, uTint: { value: new THREE.Vector3(1, 1, 1) } },
+            vertexShader: STAR_VERT, fragmentShader: STAR_FRAG, transparent: true, depthWrite: false, side: THREE.DoubleSide, blending: THREE.AdditiveBlending,
+        });
+        const lmat = new THREE.ShaderMaterial({
+            uniforms: { ...uniformsBase(), ...common(), uLineW: { value: 0.0042 }, uLines: { value: 1 }, uColor: { value: hex(cfg.color) }, uColor2: { value: hex(cfg.color2) } },
+            vertexShader: LINE_VERT, fragmentShader: frag(LINE_FRAG, 'varying vec2 vXY; varying vec3 vLN; varying vec2 vG;\nuniform float uMlim; uniform float uPx;\nfloat pulseAt(float arc, float off){ float ph = arc/2.2 - uTime*0.32*uIdleSpeed/2.2 + off; return pow(0.5 + 0.5*cos(6.2831853*ph), 8.0); }\n'),
+            transparent: true, depthWrite: false, side: THREE.DoubleSide, blending: THREE.AdditiveBlending,
+        });
+        const lines = new THREE.Mesh(lg, lmat);
+        lines.frustumCulled = false;
+        lines.renderOrder = 1;
+        const starsMesh = new THREE.Mesh(sg, smat);
+        starsMesh.frustumCulled = false;
+        starsMesh.renderOrder = 2;
+        const group = new THREE.Group();
+        group.add(lines, starsMesh);
+        const tint = new THREE.Color();
+        const api = {
+            object: group,
+            apply(c) {
+                for (const m of [smat, lmat]) {
+                    m.uniforms.uMlim.value = 5.2 + c.brightness;
+                    m.uniforms.uOpacity.value = c.opacity;
+                }
+                smat.uniforms.uTwinkle.value = c.twinkle;
+                smat.uniforms.uTemp.value = c.temperature;
+                tint.set(c.color2);
+                const mx = Math.max(tint.r, tint.g, tint.b, 1e-3);
+                smat.uniforms.uTint.value.set(tint.r / mx, tint.g / mx, tint.b / mx);
+                lmat.uniforms.uColor.value.set(c.color);
+                lmat.uniforms.uColor2.value.set(c.color2);
+                lmat.uniforms.uLines.value = c.lines;
+                api.c = c;
+            },
+            update(S, time, px) {
+                for (const m of [smat, lmat]) {
+                    setReveal(m.uniforms, S, infoD, infoE, anim.draw.duration, time);
+                    m.uniforms.uPx.value = px;
+                }
+                smat.uniforms.uDurE.value = Math.max(0.05, anim.erase.duration || 0.05);
+            },
+            dispose() { sg.dispose(); lg.dispose(); smat.dispose(); lmat.dispose(); },
+        };
+        api.apply(cfg);
+        return api;
+    },
+};

package/dist/components/text/engine/looks/embroidery.d.ts

@@ -0,0 +1,165 @@
+declare const _default: {
+    key: string;
+    source: string;
+    drawMethods: string[];
+    eraseMethods: string[];
+    drawDefault: string;
+    eraseDefault: string;
+    methodInfo: {
+        stitch: {
+            label: string;
+            hint: string;
+        };
+        unpick: {
+            label: string;
+            hint: string;
+        };
+    };
+    catalog: {
+        name: string;
+        description: string;
+        tags: string[];
+    };
+    defaults: {
+        color: string;
+        color2: string;
+        density: number;
+        slant: number;
+        thickness: number;
+        sheen: number;
+        relief: number;
+        outline: number;
+        fabric: number;
+        pucker: number;
+        style: string;
+        opacity: number;
+    };
+    ui: {
+        main: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit: string;
+        })[];
+        more: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+            options?: undefined;
+            optionLabels?: undefined;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            options?: undefined;
+            optionLabels?: undefined;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            options: string[];
+            optionLabels: string[];
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+            unit?: undefined;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit: string;
+            options?: undefined;
+            optionLabels?: undefined;
+        })[];
+    };
+    structural: string[];
+    presets: ({
+        name: string;
+        description: string;
+        patch: {
+            color?: undefined;
+            color2?: undefined;
+            sheen?: undefined;
+            fabric?: undefined;
+            outline?: undefined;
+            pucker?: undefined;
+            relief?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            sheen: number;
+            fabric: number;
+            outline?: undefined;
+            pucker?: undefined;
+            relief?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            sheen: number;
+            fabric: number;
+            outline: number;
+            pucker: number;
+            relief?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            sheen: number;
+            relief: number;
+            fabric: number;
+            outline: number;
+            pucker: number;
+        };
+    })[];
+    build(layout: any, cfg: any, anim: any): any;
+};
+export default _default;
+//# sourceMappingURL=embroidery.d.ts.map

package/dist/components/text/engine/looks/embroidery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embroidery.d.ts","sourceRoot":"","sources":["../../../../../src/components/text/engine/looks/embroidery.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsZA,wBA8FE"}