@3driseai/3drise-viewer 0.1.28 → 0.1.29

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

@@ -0,0 +1,135 @@
+import * as THREE from 'three';
+declare const _default: {
+    key: string;
+    source: string;
+    drawMethods: string[];
+    eraseMethods: string[];
+    drawDefault: string;
+    eraseDefault: string;
+    methodInfo: {
+        smudge: {
+            label: string;
+            hint: string;
+        };
+    };
+    catalog: {
+        name: string;
+        description: string;
+        tags: string[];
+    };
+    defaults: {
+        pressure: number;
+        chatter: number;
+        grain: number;
+        weight: number;
+        dust: number;
+        ghost: number;
+        swing: number;
+        board: number;
+        opacity: number;
+        color: string;
+        color2: string;
+    };
+    ui: {
+        main: {
+            unit?: any;
+            name: any;
+            label: any;
+            description: any;
+            type: string;
+            min: any;
+            max: any;
+            step: any;
+        }[];
+        more: ({
+            unit?: any;
+            name: any;
+            label: any;
+            description: any;
+            type: string;
+            min: any;
+            max: any;
+            step: any;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+        })[];
+    };
+    structural: any[];
+    presets: ({
+        name: string;
+        description: string;
+        patch: {
+            pressure?: undefined;
+            grain?: undefined;
+            dust?: undefined;
+            weight?: undefined;
+            ghost?: undefined;
+            board?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            pressure: number;
+            grain: number;
+            dust: number;
+            weight: number;
+            ghost?: undefined;
+            board?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            pressure: number;
+            grain: number;
+            dust: number;
+            weight: number;
+            ghost: number;
+            board?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            board: number;
+            ghost: number;
+            pressure: number;
+            color: string;
+            grain?: undefined;
+            dust?: undefined;
+            weight?: undefined;
+            color2?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            color: string;
+            color2: string;
+            pressure: number;
+            grain?: undefined;
+            dust?: undefined;
+            weight?: undefined;
+            ghost?: undefined;
+            board?: undefined;
+        };
+    })[];
+    build(layout: any, cfg: any, anim: any): {
+        object: THREE.Group<THREE.Object3DEventMap>;
+        apply(c: any): void;
+        update(S: any, time: any, px: any): void;
+        dispose(): void;
+    };
+};
+export default _default;
+//# sourceMappingURL=chalkboard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chalkboard.d.ts","sourceRoot":"","sources":["../../../../../src/components/text/engine/looks/chalkboard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyQ/B,wBAkHE"}

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

@@ -0,0 +1,426 @@
+import * as THREE from 'three';
+import { REVEAL_UNIFORMS, setReveal } from '../ribbon.js';
+import { prepare, applyAnim, extentOf, DRAW_METHODS, ERASE_METHODS } from '../methods.js';
+import { buildField, fieldMaterial, fieldQuad } from '../fieldkit.js';
+const hex = (h) => new THREE.Color(h);
+const mulberry32 = (a) => () => { 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; };
+// =========================================================================================
+// chalkboard — chalk on slate.
+//
+// THE MATHS. The board is a fixed height field H(p) (fractal gradient noise, 5 octaves from 0.07 em down to 0.005 em, plus
+// thin directional scratch grooves), anchored in glyph space: it is the board, it never moves. A stick of chalk drags over
+// it and leaves a deposit thickness T(p) = pressure * profile(distance to the pen path) * streaks. Chalk lodges on the
+// highest spots first and only fills the valleys as T grows, so the covered fraction is
+//        coverage = smoothstep( T - (1 - H) * depthScale )
+// i.e. the level set {H > 1 - T} of the same relief. Light pressure -> only the peaks catch (broken, grainy line); heavy
+// pressure -> every valley fills (nearly solid). The profile has a soft shoulder plus an exponential tail: the tail is far
+// below the valley depth, so only the highest peaks catch it, which IS the powdery dust halo (low-density speckle that falls
+// off over a short distance). Pressure per point = pen pressure (slow = pressed hard) mixed with the stroke width factor.
+// Alpha is coverage times a thickness term (thin film is translucent, the slate shows through); colour moves from a warm
+// dim shade (thin) to a bluish-white highlight (thick), brightened by the relief height (peaks catch more).
+//
+// ERASE (smudge). A felt swipes along a seeded direction: the band is the wipe sweep g(p), exact per pixel. Inside the band
+// the chalk is dragged along the swipe: the deposit thickness is replaced by the mean stroke density sampled along the
+// swipe direction (anisotropic blur, 10 taps from the signed-distance field), thinned to a ghost film that is read through
+// the same relief (grainy haze). The ghost fades out over the last 30 percent of the erase, so S.e = 1 is fully clean.
+//
+// FALLING DUST. Per stroke, 36 particles are born on the pen path (weighted by pressure) at the moment the pen passes; their
+// position is a closed form of (time since birth): drag-limited fall + slow drift, fade in/out.
+//
+// IDLE. Mineral crystals in the chalk are cells fixed on the board; each has a facet angle, and a light whose angle sweeps
+// slowly (with a phase that travels across the board) makes a crystal flash when facet and light line up: tiny sparkles
+// glinting at different times. Freshly written lines also settle slowly from brighter to normal.
+// =========================================================================================
+const COMMON = /* glsl */ `
+vec2 hash22(vec2 p){ vec3 p3 = fract(vec3(p.xyx)*vec3(0.1031, 0.1030, 0.0973)); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.xx + p3.yz)*p3.zy); }
+float hash12(vec2 p){ vec3 p3 = fract(vec3(p.xyx)*0.1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y)*p3.z); }
+float gnoise(vec2 p){
+  vec2 i = floor(p); vec2 f = fract(p); vec2 u = f*f*f*(f*(f*6.0 - 15.0) + 10.0);
+  float a = dot(hash22(i) - 0.5, f);
+  float b = dot(hash22(i + vec2(1.0, 0.0)) - 0.5, f - vec2(1.0, 0.0));
+  float c = dot(hash22(i + vec2(0.0, 1.0)) - 0.5, f - vec2(0.0, 1.0));
+  float d = dot(hash22(i + vec2(1.0, 1.0)) - 0.5, f - vec2(1.0, 1.0));
+  return mix(mix(a, b, u.x), mix(c, d, u.x), u.y)*2.0;     // roughly [-0.7, 0.7]
+}
+// board relief 0..1, anchored in glyph space; octaves finer than a pixel fade out so nothing aliases
+float relief(vec2 p, float px, float seed){
+  float s = 0.0; float v = 0.0; float lam = 0.07; float amp = 0.3;
+  for (int i = 0; i < 5; i++) {
+    float w = 1.0 - smoothstep(0.3, 0.85, px/lam);
+    s += amp*w*gnoise(p/lam + float(i)*7.31 + seed);
+    v += amp*amp*w*w;
+    lam *= 0.5; amp *= 1.3;
+  }
+  float h = s/max(sqrt(v), 1e-3);
+  // scratch grooves: thin streaks stretched along the board (two slightly different angles)
+  vec2 q1 = vec2(dot(p, vec2(0.9877, 0.1564)), dot(p, vec2(-0.1564, 0.9877)));
+  vec2 q2 = vec2(dot(p, vec2(0.9703, -0.2419)), dot(p, vec2(0.2419, 0.9703)));
+  float w1 = 1.0 - smoothstep(0.3, 0.85, px/0.0055); float w2 = 1.0 - smoothstep(0.3, 0.85, px/0.009);
+  float g1 = smoothstep(0.30, 0.55, gnoise(vec2(q1.x/0.28, q1.y/0.0055 + 3.7 + seed)));
+  float g2 = smoothstep(0.30, 0.55, gnoise(vec2(q2.x/0.55, q2.y/0.009 + 9.1 + seed)));
+  return clamp(0.5 + 1.25*h - 0.38*g1*w1 - 0.30*g2*w2, 0.0, 1.0);
+}
+`;
+const CHALK_FRAG = /* glsl */ `
+uniform vec3 uColor; uniform vec3 uColor2; uniform float uOpacity; uniform float uPress; uniform float uGrain; uniform float uGhost;
+uniform float uHW; uniform float uSm; uniform float uSmLen; uniform float uWo; uniform float uWspan; uniform float uSeed;
+uniform vec2 uWdir;
+uniform float uChatter; uniform float uK; uniform float uSg; uniform float uR; uniform float uHH;
+uniform vec2 uC; uniform vec2 uC0; uniform vec2 uNrm;
+${COMMON}
+float streakFn(float d, float u, float sid, float px){
+  float w1 = 1.0 - smoothstep(0.3, 0.85, px/0.012); float w2 = 1.0 - smoothstep(0.3, 0.85, px/0.0065);
+  float a = gnoise(vec2(d/0.012 + sid*13.7, u*0.24 + sid*3.1)); float b = gnoise(vec2(d/0.0065 + sid*5.3, u*0.56 + sid*9.9));
+  return clamp(0.5 + 0.9*(0.6*a*w1 + 0.4*b*w2), 0.0, 1.0);
+}
+// swipe coordinate: the felt pivots on the elbow, so the sweep is an arc about the pivot uC (angle times radius); uK < 0.004 = straight band
+float sweepCoord(vec2 p){
+  if (uK < 0.004) return dot(p, uWdir);
+  vec2 d = p - uC; vec2 a = (uC0 - uC)/uR;
+  return uSg*atan(a.x*d.y - a.y*d.x, dot(a, d))*uR;
+}
+// stroke density along the swipe path (anisotropic, curved): chalk dragged by the felt, so strokes shear along the arc
+float smearDen(vec2 p, float L, float hw){
+  vec2 dv = p - uC; float rr = max(length(dv), 0.05);
+  float lat = uK < 0.004 ? dot(p, uNrm) : rr;
+  float ln = floor(lat/0.011); float j = hash12(vec2(ln, 3.3));          // one jitter per streak line: coherent streaks along the swipe
+  float a = 0.0;
+  for (int i = 0; i < 16; i++) {
+    float u = (float(i) + j)/16.0; float s = u*u*L; float w = exp(-1.2*u)*mix(0.5, 1.0, smoothstep(0.0, 0.25, u));
+    float wb = 0.012*gnoise(vec2(u*2.0, ln*0.31));
+    vec2 q;
+    if (uK < 0.004) q = p - uWdir*s + uNrm*wb;
+    else { float dl = -uSg*s/rr; float cs = cos(dl); float sn = sin(dl); vec2 dd = dv*(1.0 + wb/rr); q = uC + vec2(cs*dd.x - sn*dd.y, sn*dd.x + cs*dd.y); }
+    a = max(a, w*(1.0 - smoothstep(0.3*hw, 1.5*hw, fieldA(q).x)));     // trailing streak behind every stroke crossing
+  }
+  return a;
+}
+// stick-slip: the dash phase is the pen's own time (pen time / slip time), so dash spacing = speed x slip time
+float chatterMod(float ph, float fwp, float prs, float sid, float px){
+  float spacing = 1.3*px/max(fwp, 1e-5);                                                             // em between dashes = pen speed x slip time
+  float gate = uChatter*(1.0 - smoothstep(0.35, 1.0, uPress))*smoothstep(0.0, 0.35, 1.0 - prs)*smoothstep(0.07, 0.115, spacing)*(1.0 - smoothstep(0.22, 0.5, fwp));   // fast and light only; fades before dashes alias
+  float pw = ph + 0.34*gnoise(vec2(ph*0.55 + sid*7.0, sid*1.7)) + 0.18*gnoise(vec2(ph*1.7 + sid*3.0, 9.0));                                   // seeded period jitter
+  float kk = floor(pw); float f = fract(pw); float hh = hash12(vec2(kk, sid + 0.5));
+  float ew = max(0.03, 1.3*fwp);
+  float onset = smoothstep(0.0, ew, f);                                                          // the stick catches abruptly
+  float en = 0.4 + 0.42*hh;
+  float tl = 1.0 - smoothstep(en - 0.16, en + 0.06, f);                                          // then slips and tapers
+  float catchw = 0.72 + 0.55*exp(-f*3.5);                                                        // heavier at the start of each dash
+  float shape = onset*tl*catchw*(0.35 + 0.65*hh);
+  return mix(1.0, shape + 0.07, clamp(gate*1.7, 0.0, 1.0));
+}
+float crystals(vec2 p, float px){
+  float CS = 0.014; vec2 q = p/CS; vec2 id = floor(q); vec2 f = fract(q);
+  vec3 r = vec3(hash22(id), hash12(id + 7.7));
+  float has = step(r.x, 0.16);
+  vec2 c = 0.3 + 0.4*hash22(id + 3.1);
+  float rad = max(0.2, 1.0*px/CS);
+  float dd = length(f - c)/rad;
+  float spot = exp(-dd*dd*1.6);
+  float phi = r.z*6.2831853 + r.y*3.0;
+  float L = uTime*0.23*uIdleSpeed + dot(id, vec2(0.061, 0.037)) + 1.7*sin(dot(id, vec2(0.021, -0.017)));   // light angle: sweeps slowly, phase travels across the board
+  float a = 0.5 + 0.5*cos(phi - L);
+  return has*spot*pow(a, 36.0);
+}
+void main(){
+  vec2 p = vPos;
+  float px = 0.5*(length(dFdx(p)) + length(dFdy(p))) + 1e-5;
+  vec4 A = fieldA(p); vec4 B = fieldB(p);
+  float prs = texture2D(uP, fieldUV(p)).y;
+  float ph = A.w; float fwp = fwidth(ph);
+  float d = max(A.x, 0.0); float wf = clamp(B.y, 0.3, 2.0); float sid = B.z*255.0;
+  float pl = clamp(0.55*prs + 0.45*clamp((wf - 0.55)/0.9, 0.0, 1.0), 0.0, 1.0);
+  float wob = 0.6*gnoise(vec2(A.w*0.3 + sid*3.7, sid*11.3)) + 0.4*gnoise(p*1.9 + sid*7.0);     // the stick wears: slow width wobble
+  float hw = uHW*(0.6 + 0.4*wf)*(1.0 + 0.3*wob);
+  float peff = (0.2 + 1.5*uPress*(0.45 + 0.7*pl))*(0.94 + 0.3*gnoise(p/0.11 + sid));
+  float hl = 0.009 + 0.16*hw;
+  float core = 1.0 - smoothstep(0.55*hw, 1.05*hw, d);
+  float tail = 0.4*exp(-max(d - 0.8*hw, 0.0)/hl)*(1.0 - smoothstep(0.8*hw + 4.0*hl, 0.8*hw + 6.0*hl, d));
+  float prof = core + tail*(1.0 - core);
+  float st = streakFn(d, A.w, sid, px);
+  float Tsh = peff*prof*(0.72 + 0.56*st)*chatterMod(ph, fwp, prs, sid, px);
+  float rin = revealInG(A.y);
+  float outv = 1.0; float Tf = Tsh; float gmix = 1.0;
+  if (uSm > 0.5) {
+    float gU = (sweepCoord(p) - uWo)/uWspan; float gP = clamp(gU, 0.0, 1.0);
+    float k = clamp((gP - uErase)/max(uSoftOut, 1e-4), 0.0, 1.0);
+    if (k < 0.999) {
+      float den = smearDen(p, uSmLen, uHW);
+      float Tsm = den*(0.55 + 0.9*uPress)*1.0;
+      float sm = 1.0 - smoothstep(0.45, 1.0, k);
+      float ghostFade = 1.0 - smoothstep(0.7, 1.0, uE);
+      float amp = mix(uGhost*1.4*ghostFade, 1.0, smoothstep(0.0, 0.7, k));
+      Tf = mix(Tsh, Tsm, sm)*amp; gmix = mix(1.0, 0.38, sm);
+    }
+    // crescent of smeared chalk dust where the felt lifts at the end of the arc; gone before the erase ends
+    float lat = uK < 0.004 ? dot(p - uC0, uNrm) : length(p - uC) - uR;
+    float lens = clamp(1.0 - (lat/uHH)*(lat/uHH), 0.0, 1.0);
+    float gc = 0.94 - 0.045*(1.0 - lens);
+    float cw = 0.034*(0.3 + 0.7*lens);
+    float cres = exp(-pow((gU - gc)/cw, 2.0))*lens;
+    float cAmp = smoothstep(0.55, 0.85, uE)*(1.0 - smoothstep(0.9, 1.0, uE))*(0.35 + 0.65*uGhost);
+    float eEdge = min(min(p.x - uFExt.x, uFExt.x + uFExt.z - p.x), min(p.y - uFExt.y, uFExt.y + uFExt.w - p.y));
+    float Tcr = 1.3*cres*cAmp*(0.6 + 0.8*gnoise(p/0.05 + 3.0))*smoothstep(0.0, 0.03, eEdge);
+    if (Tcr > Tf) { Tf = Tcr; gmix = 0.5; }
+    outv = 1.0 - smoothstep(0.985, 1.0, uE);
+  } else outv = revealOutG(A.z);
+  float vis = rin*outv*uOpacity;
+  if (vis < 0.003 || Tf < 0.004) discard;
+  float H = relief(p, px, uSeed);
+  float Hc = clamp(0.5 + (H - 0.5)*(0.35 + 1.9*uGrain)*gmix, 0.0, 1.0);
+  float x = Tf - (1.0 - Hc)*0.95;
+  float cov = smoothstep(0.0, 0.17, x);
+  float thick = smoothstep(0.25, 1.15, Tf);
+  float a = cov*(0.45 + 0.55*thick)*vis;
+  float tk = smoothstep(0.3, 1.4, Tf);
+  vec3 thin = uColor*vec3(1.0, 0.95, 0.87)*0.88;
+  vec3 dense = mix(uColor, uColor2, 0.8);
+  float shade = 0.74 + 0.26*Hc;
+  float age = ageG(A.y);
+  float fresh = exp(-age/9.0);
+  vec3 col = mix(thin, dense, tk)*shade*(1.0 + 0.08*fresh*smoothstep(0.0, 0.5, age + 0.5));
+  col = min(col, vec3(0.985));
+  float gl = crystals(p, px)*smoothstep(0.35, 0.9, cov)*vis*uIdle;
+  gl_FragColor = vec4(col*a + vec3(0.95, 0.97, 1.0)*gl*1.2, max(a, gl*0.6));
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+const BOARD_FRAG = /* glsl */ `
+uniform vec3 uSlate; uniform vec3 uChalk; uniform float uBoard; uniform float uSeed; uniform vec2 uWdir;
+uniform float uChatter; uniform float uK; uniform float uSg; uniform float uR; uniform float uHH;
+uniform vec2 uC; uniform vec2 uC0; uniform vec2 uNrm;
+${COMMON}
+float oldDen(vec2 pp, float hw, float j){
+  float a = 0.0; float ws = 0.0;
+  for (int i = 0; i < 6; i++) { float u = (float(i) + j)/6.0; float w = exp(-1.4*u); a += w*(1.0 - smoothstep(0.3*hw, 1.6*hw, fieldA(pp - vec2(0.55*u, 0.0)).x)); ws += w; }
+  return a/ws;
+}
+void main(){
+  vec2 p = vPos;
+  float px = 0.5*(length(dFdx(p)) + length(dFdy(p))) + 1e-5;
+  float vis = smoothstep(0.0, 0.1, uD)*(1.0 - smoothstep(0.55, 1.0, uE));
+  vec2 e = min(p - uFExt.xy, uFExt.xy + uFExt.zw - p);
+  float ed = min(e.x, e.y);
+  float edge = smoothstep(0.0, max(0.02, 1.5*px), ed);
+  float a0 = uBoard*vis*edge;
+  if (a0 < 0.003) discard;
+  float H = relief(p*1.3, px, uSeed + 4.0);
+  vec2 q = vec2(dot(p, uWdir), dot(p, vec2(-uWdir.y, uWdir.x)));
+  float cloud = 0.5 + 0.5*(0.7*gnoise(vec2(q.x/1.1, q.y/0.16) + uSeed) + 0.5*gnoise(vec2(q.x/0.45, q.y/0.07) + 5.0));
+  float haze = smoothstep(0.35, 0.95, cloud);
+  float j = hash12(floor(p/max(px, 1e-4)));
+  vec2 p1 = vec2(0.9903*p.x - 0.1392*p.y, 0.1392*p.x + 0.9903*p.y)*0.62 + vec2(0.15, 0.25);
+  vec2 p2 = vec2(0.9962*p.x + 0.0872*p.y, -0.0872*p.x + 0.9962*p.y)*1.35 + vec2(-0.4, -0.15);
+  float old = 0.0;
+  old += oldDen(p1, 0.05, j)*smoothstep(0.1, 0.8, gnoise(p*0.9 + 2.0) + 0.5);
+  old += 0.7*oldDen(p2, 0.04, j)*smoothstep(0.1, 0.8, gnoise(p*0.8 + 8.0) + 0.5);
+  float vig = 0.78 + 0.22*smoothstep(0.0, 0.5, ed);
+  vec3 col = uSlate*(0.84 + 0.3*H)*vig;
+  float chalk = (0.010*haze + 0.022*clamp(old, 0.0, 1.0))*(0.45 + 0.9*H);
+  col += uChalk*chalk;
+  gl_FragColor = vec4(col*a0, a0);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+const DUST_VERT = /* glsl */ `
+attribute vec4 aR; attribute float aB;
+${REVEAL_UNIFORMS}
+uniform float uScale; uniform float uDust; uniform float uOn; uniform float uOpacity;
+varying float vA;
+void main(){
+  float tau = (uHead - aB)*uDur + uSince;
+  float life = 1.3 + 1.5*aR.x;
+  float t = tau/life;
+  float on = step(0.0, tau)*(1.0 - step(1.0, t))*uOn*step(aR.w, uDust);
+  float k = 0.45;
+  vec3 pos = position;
+  pos.y -= (0.15 + 0.16*aR.y)*(tau - k*(1.0 - exp(-tau/k)));
+  pos.x += 0.05*(aR.z - 0.5)*tau + 0.012*sin(tau*2.1 + aR.z*6.2831);
+  vec4 mv = modelViewMatrix*vec4(pos, 1.0);
+  gl_Position = projectionMatrix*mv;
+  float sz = (0.009 + 0.014*aR.y)*(1.0 + 1.2*t);
+  gl_PointSize = max(2.0, sz*uScale/-mv.z);
+  float cl = (sz*uScale/-mv.z)/gl_PointSize;
+  vA = smoothstep(0.0, 0.06, t)*pow(max(1.0 - t, 0.0), 1.5)*0.6*on*(1.0 - smoothstep(0.0, 0.2, uE))*uOpacity*min(1.0, cl*cl*1.5);
+  if (on < 0.5) gl_Position = vec4(2.0, 2.0, 2.0, 1.0);
+}`;
+const DUST_FRAG = /* glsl */ `
+precision highp float; uniform vec3 uColor; varying float vA;
+void main(){
+  vec2 c = gl_PointCoord*2.0 - 1.0; float r2 = dot(c, c);
+  float a = exp(-r2*3.2)*(1.0 - smoothstep(0.6, 1.0, sqrt(r2)))*vA;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(uColor*a, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+const row = (name, label, description, min, max, step, unit) => ({ name, label, description, type: 'number', min, max, step, ...(unit ? { unit } : {}) });
+export default {
+    key: 'chalkboard', source: 'hand', drawMethods: DRAW_METHODS, eraseMethods: ['smudge', ...ERASE_METHODS], drawDefault: 'pen', eraseDefault: 'smudge',
+    methodInfo: { smudge: { label: 'Smudge', hint: 'A felt swipes across: strokes smear along the swipe and leave a faint ghost that fades out.' } },
+    catalog: {
+        name: 'Chalkboard',
+        description: 'Single-stroke chalk on slate: pressure-dependent deposit on a fixed grainy board with powdery halo, falling dust at the pen and a felt-smudge erase leaving ghosts. Use for classrooms, menus and hand-made titles.',
+        tags: ['chalk', 'chalkboard', 'slate', 'handwriting', 'classroom', 'dust', 'smudge', 'grain'],
+    },
+    defaults: { pressure: 0.55, chatter: 0.6, grain: 0.55, weight: 1, dust: 0.6, ghost: 0.5, swing: 0.6, board: 0, opacity: 1, color: '#ebe6d8', color2: '#c4dcf2' },
+    ui: {
+        main: [
+            row('pressure', 'Pressure', 'How hard the chalk is pressed: light = broken grainy line, heavy = nearly solid', 0, 1, 0.01),
+            row('chatter', 'Chatter', 'Stick-slip skipping: fast, light strokes break into dashes whose spacing follows pen speed', 0, 1, 0.01),
+            row('grain', 'Grain', 'Contrast of the board relief the chalk catches on', 0, 1, 0.01),
+            row('dust', 'Dust', 'Falling chalk dust at the tip while writing', 0, 1, 0.01),
+        ],
+        more: [
+            row('weight', 'Weight', 'Thickness of the chalk stick', 0.4, 2.5, 0.01),
+            row('swing', 'Swing', 'Curvature of the felt swipe: 0 = straight band, 1 = tight arc about the elbow', 0, 1, 0.01),
+            row('ghost', 'Ghost', 'Chalk residue left by the smudge erase before it fades out', 0, 1, 0.01),
+            row('board', 'Board', 'Slate board behind the text with faint old writing', 0, 1, 0.01),
+            row('opacity', 'Opacity', 'Overall opacity', 0, 1, 0.01),
+            { name: 'color', label: 'Chalk', description: 'Chalk colour', type: 'color' },
+            { name: 'color2', label: 'Highlight', description: 'Tint of the dense deposit', type: 'color' },
+        ],
+    },
+    structural: [],
+    presets: [
+        { name: 'Classroom', description: 'Balanced white chalk on a dark board', patch: {} },
+        { name: 'Fresh stick', description: 'New chalk pressed hard: dense, bright, heavy dust', patch: { pressure: 0.9, grain: 0.35, dust: 0.9, weight: 1.15 } },
+        { name: 'Worn stub', description: 'Light touch with a short stub: broken and gritty', patch: { pressure: 0.25, grain: 0.85, dust: 0.3, weight: 0.8, ghost: 0.8 } },
+        { name: 'Old board', description: 'Slate with years of old writing under the text', patch: { board: 1, ghost: 0.8, pressure: 0.5, color: '#e4e0d2' } },
+        { name: 'Pink chalk', description: 'Coloured pigment chalk', patch: { color: '#f4b8c8', color2: '#ffd7e2', pressure: 0.6 } },
+    ],
+    build(layout, cfg, anim) {
+        const strokes = layout.strokes;
+        prepare(strokes, 'hand');
+        const G = layout.glyphs.length;
+        strokes.forEach((s) => { s.glyphN = s.glyph / Math.max(1, G - 1); });
+        const natural = layout.natural || 0.06;
+        const smudge = anim.erase.method === 'smudge';
+        const seedH = Math.abs(Math.sin(G * 12.9898 + strokes.length * 78.233)) * 43758.5453 % 1;
+        const ang = (anim.erase.angle || 0) + (seedH - 0.5) * 24; // seeded swipe direction (degrees)
+        const anim2 = smudge ? { draw: anim.draw, play: anim.play, erase: { ...anim.erase, method: 'wipe', angle: ang } } : anim;
+        const { infoD, infoE } = applyAnim(strokes, anim2, G);
+        const ex = extentOf(strokes);
+        const a = (ang * Math.PI) / 180, dx = Math.cos(a), dy = Math.sin(a), nx = -dy, ny = dx;
+        const cx0 = (ex.x0 + ex.x1) / 2, cy0 = (ex.y0 + ex.y1) / 2, sg = seedH > 0.5 ? 1 : -1;
+        const pd = 0.28, corners = [[ex.x0 - pd, ex.y0 - pd], [ex.x1 + pd, ex.y0 - pd], [ex.x0 - pd, ex.y1 + pd], [ex.x1 + pd, ex.y1 + pd]]; // sweep spans the whole field quad, so the arc end (crescent) lies inside it
+        const hh = Math.max(0.5, (ex.y1 - ex.y0) / 2 + 0.35);
+        // swipe geometry for a given swing: pivot far to one side (sg), sweep coordinate = angle x radius (JS mirror of sweepCoord in the shader)
+        const geom = (swing) => {
+            const K = swing * 0.3, arc = K >= 0.004, R = arc ? 1 / K : 1, Cx = cx0 + nx * sg * R, Cy = cy0 + ny * sg * R;
+            const ax = (cx0 - Cx) / R, ay = (cy0 - Cy) / R;
+            const co = (x, y) => (arc ? sg * Math.atan2(ax * (y - Cy) - ay * (x - Cx), ax * (x - Cx) + ay * (y - Cy)) * R : x * dx + y * dy);
+            const cs = corners.map(([x, y]) => co(x, y));
+            const lo = Math.min(...cs);
+            return { K: arc ? K : 0, R, Cx, Cy, lo, span: Math.max(1e-6, Math.max(...cs) - lo) };
+        };
+        const g0 = geom(cfg.swing);
+        // main field: the arc slot carries the stick-slip phase = pen time / slip time (absolute, independent of the draw method)
+        const field = buildField(strokes.map((s) => { const ph = new Float32Array(s.pts.length / 2); for (let i = 0; i < ph.length; i++)
+            ph[i] = s.pt[i] * s.ptime / 0.13; return { ...s, cum: ph, len: 1 }; }), { source: 'hand', texels: 512 });
+        const pfield = buildField(strokes.map((s) => ({ ...s, wfactor: s.pressure })), { source: 'hand', texels: 192 }); // pen pressure (wfactor slot)
+        const seed = (seedH * 40) % 40;
+        const common = { uColor: { value: hex(cfg.color) }, uColor2: { value: hex(cfg.color2) }, uOpacity: { value: 1 }, uSeed: { value: seed }, uWdir: { value: new THREE.Vector2(dx, dy) } };
+        const mat = fieldMaterial(field, CHALK_FRAG, {
+            ...common, uP: { value: pfield.f1 }, uPress: { value: cfg.pressure }, uGrain: { value: cfg.grain }, uGhost: { value: cfg.ghost }, uHW: { value: natural * 0.7 },
+            uSm: { value: smudge ? 1 : 0 }, uSmLen: { value: 1.3 }, uWo: { value: g0.lo }, uWspan: { value: g0.span }, uChatter: { value: cfg.chatter },
+            uK: { value: g0.K }, uSg: { value: sg }, uR: { value: g0.R }, uHH: { value: hh }, uC: { value: new THREE.Vector2(g0.Cx, g0.Cy) }, uC0: { value: new THREE.Vector2(cx0, cy0) }, uNrm: { value: new THREE.Vector2(nx, ny) },
+        }, { extra: 'uniform sampler2D uP;\n' });
+        const mesh = fieldQuad(field, mat);
+        mesh.renderOrder = 2;
+        const bmat = fieldMaterial(field, BOARD_FRAG, { uSlate: { value: hex('#1b2326') }, uChalk: { value: hex(cfg.color) }, uBoard: { value: cfg.board }, uSeed: { value: seed }, uWdir: { value: new THREE.Vector2(dx, dy) } });
+        const board = fieldQuad(field, bmat);
+        board.renderOrder = 0;
+        board.visible = cfg.board > 0.001;
+        // falling dust: 36 particles per stroke, born on the pen path (pressure-weighted) when the pen passes
+        const PER = 36;
+        const pos = [], aB = [], aR = [];
+        strokes.forEach((s, si) => {
+            const rnd = mulberry32(1000 + si * 77);
+            const n = s.pts.length / 2;
+            if (n < 2)
+                return;
+            const cw = new Float32Array(n);
+            let c = 0;
+            for (let i = 0; i < n; i++) {
+                c += (i ? s.cum[i] - s.cum[i - 1] : 0) * (0.35 + (s.pressure ? s.pressure[i] : 0.5)) + 1e-6;
+                cw[i] = c;
+            }
+            for (let k = 0; k < PER; k++) {
+                const target = ((k + rnd()) / PER) * c;
+                let lo2 = 0, hi = n - 1;
+                while (hi - lo2 > 1) {
+                    const m = (lo2 + hi) >> 1;
+                    if (cw[m] <= target)
+                        lo2 = m;
+                    else
+                        hi = m;
+                }
+                const i = lo2;
+                const i2 = Math.min(n - 1, i + 1), i0 = Math.max(0, i - 1);
+                let nx = -(s.pts[2 * i2 + 1] - s.pts[2 * i0 + 1]), ny = s.pts[2 * i2] - s.pts[2 * i0];
+                const nl = Math.hypot(nx, ny) || 1;
+                nx /= nl;
+                ny /= nl;
+                const off = (rnd() - 0.5) * natural * 0.9;
+                pos.push(s.pts[2 * i] + nx * off, s.pts[2 * i + 1] + ny * off - natural * 0.15, 0);
+                aB.push(s.seg[0] + s.t[i] * (s.seg[1] - s.seg[0]));
+                aR.push(rnd(), rnd(), rnd(), rnd());
+            }
+        });
+        const dg = new THREE.BufferGeometry();
+        dg.setAttribute('position', new THREE.BufferAttribute(new Float32Array(pos), 3));
+        dg.setAttribute('aB', new THREE.BufferAttribute(new Float32Array(aB), 1));
+        dg.setAttribute('aR', new THREE.BufferAttribute(new Float32Array(aR), 4));
+        dg.boundingSphere = new THREE.Sphere(new THREE.Vector3(), 1e3);
+        const dmat = new THREE.ShaderMaterial({
+            uniforms: { ...mat.uniforms, uScale: { value: 800 }, uDust: { value: cfg.dust }, uOn: { value: infoD.tip ? 1 : 0 }, uOpacity: { value: 1 }, uColor: { value: hex(cfg.color) } },
+            vertexShader: DUST_VERT, fragmentShader: DUST_FRAG, transparent: true, depthWrite: false,
+            blending: THREE.CustomBlending, blendEquation: THREE.AddEquation, blendSrc: THREE.OneFactor, blendDst: THREE.OneMinusSrcAlphaFactor,
+        });
+        const dust = new THREE.Points(dg, dmat);
+        dust.frustumCulled = false;
+        dust.renderOrder = 3;
+        const group = new THREE.Group();
+        group.add(board, mesh, dust);
+        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.uPress.value = c.pressure;
+                u.uGrain.value = c.grain;
+                u.uGhost.value = c.ghost;
+                u.uChatter.value = c.chatter;
+                {
+                    const g = geom(c.swing);
+                    u.uK.value = g.K;
+                    u.uR.value = g.R;
+                    u.uWo.value = g.lo;
+                    u.uWspan.value = g.span;
+                    u.uC.value.set(g.Cx, g.Cy);
+                }
+                u.uHW.value = natural * 0.7 * c.weight;
+                const b = bmat.uniforms;
+                b.uBoard.value = c.board;
+                b.uChalk.value.set(c.color);
+                board.visible = c.board > 0.001;
+                const d = dmat.uniforms;
+                d.uColor.value.set(c.color);
+                d.uDust.value = c.dust;
+                d.uOpacity.value = c.opacity;
+            },
+            update(S, time, px) {
+                setReveal(mat.uniforms, S, infoD, infoE, anim.draw.duration, time);
+                setReveal(bmat.uniforms, S, infoD, infoE, anim.draw.duration, time);
+                setReveal(dmat.uniforms, S, infoD, infoE, anim.draw.duration, time);
+                dmat.uniforms.uScale.value = px;
+            },
+            dispose() { field.dispose(); pfield.dispose(); mesh.geometry.dispose(); board.geometry.dispose(); mat.dispose(); bmat.dispose(); dg.dispose(); dmat.dispose(); },
+        };
+        api.apply(cfg);
+        return api;
+    },
+};

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

@@ -0,0 +1,111 @@
+declare const _default: {
+    key: string;
+    source: string;
+    drawMethods: string[];
+    eraseMethods: string[];
+    drawDefault: string;
+    eraseDefault: string;
+    catalog: {
+        name: string;
+        description: string;
+        tags: string[];
+    };
+    defaults: {
+        stars: number;
+        brightness: number;
+        twinkle: number;
+        lines: number;
+        temperature: number;
+        seed: number;
+        color: string;
+        color2: string;
+        opacity: number;
+    };
+    ui: {
+        main: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit: string;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+            unit?: undefined;
+        })[];
+        more: ({
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min: number;
+            max: number;
+            step: number;
+        } | {
+            name: string;
+            label: string;
+            description: string;
+            type: string;
+            min?: undefined;
+            max?: undefined;
+            step?: undefined;
+        })[];
+    };
+    structural: string[];
+    presets: ({
+        name: string;
+        description: string;
+        patch: {
+            temperature?: undefined;
+            color?: undefined;
+            color2?: undefined;
+            brightness?: undefined;
+            twinkle?: undefined;
+            lines?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            temperature: number;
+            color: string;
+            color2: string;
+            brightness: number;
+            twinkle?: undefined;
+            lines?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            temperature: number;
+            color: string;
+            color2: string;
+            twinkle: number;
+            brightness?: undefined;
+            lines?: undefined;
+        };
+    } | {
+        name: string;
+        description: string;
+        patch: {
+            brightness: number;
+            lines: number;
+            twinkle: number;
+            temperature?: undefined;
+            color?: undefined;
+            color2?: undefined;
+        };
+    })[];
+    build(layout: any, cfg: any, anim: any): any;
+};
+export default _default;
+//# sourceMappingURL=constellation.d.ts.map

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

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