@3driseai/3drise-viewer 0.1.26 → 0.1.28

package/dist/operations/catalogue/jelly.js

@@ -0,0 +1,50 @@
+// Jelly — a volume-preserving squash-and-stretch spring, anchored at the base:
+// it squashes first, then rings out like soft rubber (critically tuned so it
+// settles exactly at rest when the duration ends). One-shot.
+import { gsap } from 'gsap';
+import { Quaternion, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { acquireRest, poseAbout, releaseRest } from './restPose.js';
+const KEY = '__opJelly';
+const NO_TURN = new Quaternion();
+export default defineOperation({
+    value: 'jelly',
+    label: 'Jelly',
+    description: 'Squash and wobble like soft rubber, keeping its volume — settles back to rest',
+    channel: 'transform',
+    multi: true,
+    toggles: false,
+    usableIn: ['interaction', 'action'],
+    params: {
+        strength: { type: 'number', label: 'Squash', default: 0.28, min: 0.02, max: 0.7, step: 0.01 },
+        wobbles: { type: 'number', label: 'Wobbles', default: 3, min: 1, max: 8, step: 0.5 },
+        duration: { type: 'number', label: 'Duration', default: 1.1, min: 0.2, max: 5, step: 0.05, unit: 's' },
+    },
+    apply(target, p) {
+        const running = target.userData[KEY];
+        if (running) {
+            gsap.killTweensOf(running.proxy);
+            releaseRest(target);
+        }
+        const rest = acquireRest(target);
+        const proxy = { t: 0 };
+        target.userData[KEY] = { proxy };
+        const A = Number(p.strength);
+        const D = Number(p.duration);
+        const w = 2 * Math.PI * (Number(p.wobbles) / D); // rad/s
+        const k = 4.6 / D; // decays to 1% by the end
+        const s = new Vector3();
+        gsap.to(proxy, {
+            t: D, duration: D, ease: 'none',
+            onUpdate: () => {
+                const t = proxy.t;
+                // damped spring, squash first
+                const sy = 1 - A * Math.exp(-k * t) * Math.sin(w * t);
+                const sxz = 1 / Math.sqrt(Math.max(sy, 0.05)); // keep the volume
+                s.set(sxz, sy, sxz);
+                poseAbout(target, rest, rest.bottomLocal, NO_TURN, s);
+            },
+            onComplete: () => { delete target.userData[KEY]; releaseRest(target); },
+        });
+    },
+});

package/dist/operations/catalogue/kintsugi.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=kintsugi.d.ts.map

package/dist/operations/catalogue/kintsugi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kintsugi.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/kintsugi.ts"],"names":[],"mappings":";AAmIA,wBA+CG"}

package/dist/operations/catalogue/kintsugi.js

@@ -0,0 +1,173 @@
+// Kintsugi — the object is mended with gold. A network of cracks opens over the
+// surface (3D cellular seams in the object's own space, domain-warped so they
+// wander like real fractures, with finer hairline branches in patches), and
+// molten gold wicks along them behind a hot, glowing tip. The seams are raised
+// (a bump from the seam profile bends the reflection), so the gold reads as
+// lacquered metal standing proud of the surface, with a fine glitter that keeps
+// moving while it holds. The rest of the surface keeps its own material.
+// A state, not an exit: the gold stays while on; reverting draws it back and the
+// cracks close.
+import { Color } from 'three';
+import { defineOperation } from '../types.js';
+import { GLSL_WORLEY, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+const P = 'Kin';
+const KEY = 'kintsugi';
+const STATE = '__opKintsugi';
+/**
+ * Distance, measured along the surface, from p to the nearest cell border of a 3D
+ * Voronoi lattice (cell units). The exact distance to the bisector plane of the two
+ * nearest feature points, divided by how steeply the surface crosses that plane —
+ * so a surface running parallel to a border never turns into a wide blob.
+ */
+const BORDER = /* glsl */ `
+float kinBorder(vec3 p, vec3 n) {
+  vec3 i = floor(p); vec3 f = fract(p);
+  float d1 = 8.0, d2 = 8.0; vec3 p1 = vec3(0.0), p2 = vec3(0.0);
+  for (int z = -1; z <= 1; z++) for (int y = -1; y <= 1; y++) for (int x = -1; x <= 1; x++) {
+    vec3 g = vec3(float(x), float(y), float(z));
+    vec3 r = g + fxHash3(i + g) - f;
+    float d = dot(r, r);
+    if (d < d1) { d2 = d1; p2 = p1; d1 = d; p1 = r; } else if (d < d2) { d2 = d; p2 = r; }
+  }
+  vec3 m = p2 - p1; float lm = max(length(m), 1e-4);
+  float c = dot(m / lm, n);
+  return (d2 - d1) / (2.0 * lm) / sqrt(max(1.0 - c * c, 0.16));
+}
+`;
+function layerFor(st) {
+    return {
+        uniforms: {
+            ...fieldUniforms(P, st.field), uKinGold: st.gold, uKinDensity: st.density, uKinWidth: st.width, uKinBranch: st.branch,
+        },
+        common: `varying vec3 vKinQ;\nvarying vec3 vKinR;\nvarying vec3 vKinN;\nvarying vec3 vKinView;\n${fieldGlsl(P)}\n${GLSL_WORLEY}\n${BORDER}`,
+        // computed once in the first anchor (diffuse), shared with the later ones
+        fragmentPars: 'float kinG = 0.0; float kinH = 0.0; float kinHot = 0.0; float kinDark = 0.0; float kinW = 0.0;',
+        vertex: /* glsl */ `
+        vKinR = (uKinRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vKinQ = KinNorm(vKinR);
+        vKinN = (uKinRootInv * modelMatrix * vec4(normal, 0.0)).xyz;
+        vKinView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
+        diffuse: /* glsl */ `
+        {
+          vec3 nq = normalize(vKinN);
+          vec3 rr = vKinR / uKinExtent * uKinDensity;
+          // domain warp: fractures wander instead of running straight cell to cell
+          vec3 wp = rr + 0.5 * (vec3(fxNoise(rr * 0.9), fxNoise(rr * 0.9 + 7.1), fxNoise(rr * 0.9 + 13.7)) - 0.5);
+          float e1 = kinBorder(wp, nq);
+          float w1 = uKinWidth * 0.028 * (0.45 + 1.1 * fxNoise(rr * 2.3 + 3.0));
+          float aa1 = fwidth(e1) + 1e-4;
+          float s1 = 1.0 - smoothstep(w1 - aa1, w1 + aa1, e1);
+          // hairline branches, only in patches
+          float e2 = kinBorder(wp * 2.37 + 5.3, nq);
+          float patchy = smoothstep(0.5, 0.62, fxNoise(rr * 1.1 + 9.0)) * uKinBranch;
+          float w2 = uKinWidth * 0.03 * (0.5 + fxNoise(rr * 4.1));
+          float aa2 = fwidth(e2) + 1e-4;
+          float s2 = (1.0 - smoothstep(w2 - aa2, w2 + aa2, e2)) * patchy;
+          float seam = max(s1, s2 * 0.9);
+          // raised profile across the seam (0 at the lips, 1 on the ridge)
+          float h1 = s1 * sqrt(clamp(1.0 - (e1 / max(w1, 1e-4)) * (e1 / max(w1, 1e-4)), 0.0, 1.0));
+          float h2 = s2 * sqrt(clamp(1.0 - (e2 / max(w2, 1e-4)) * (e2 / max(w2, 1e-4)), 0.0, 1.0));
+          kinH = max(h1, h2 * 0.6);
+          kinW = w1;
+          // the gold arrives along the front; the crack opens just ahead of it
+          float a = KinField(vKinQ);
+          float T = KinThreshold();
+          float fill = smoothstep(0.0, 0.012, T - a);
+          float open = smoothstep(0.0, 0.03, T + 0.09 - a);
+          float on = step(0.0001, uKinProgress) * step(uKinProgress, 0.9999);
+          kinG = seam * fill;
+          kinDark = seam * open * (1.0 - fill);
+          kinHot = seam * fill * exp(-max(T - a, 0.0) / 0.035) * on;
+          diffuseColor.rgb = mix(diffuseColor.rgb, diffuseColor.rgb * 0.12, kinDark * 0.92);
+          diffuseColor.rgb = mix(diffuseColor.rgb, uKinGold, kinG);
+        }`,
+        material: /* glsl */ `
+        roughnessFactor = mix(roughnessFactor, 0.22, kinG);
+        metalnessFactor = mix(metalnessFactor, 1.0, kinG);`,
+        fragment: /* glsl */ `
+        if (kinG > 0.001 || kinHot > 0.001) {
+          vec3 pos = vKinView;
+          vec3 sx = dFdx(pos), sy = dFdy(pos);
+          vec3 nv = normalize(cross(sx, sy));
+          #if defined( STANDARD ) || defined( PHONG ) || defined( LAMBERT ) || defined( TOON )
+            vec3 n = normalize(normal);
+          #else
+            vec3 n = nv;
+          #endif
+          // bump from the seam profile (height in world units): the ridge bends the reflection
+          float hs = 0.5 * kinW * uKinExtent / max(uKinDensity, 1e-3);
+          vec2 dh = vec2(dFdx(kinH), dFdy(kinH)) * hs;
+          vec3 r1 = cross(sy, n), r2 = cross(n, sx);
+          float det = dot(sx, r1);
+          n = normalize(abs(det) * n - sign(det) * (dh.x * r1 + dh.y * r2));
+          vec3 v = normalize(pos);
+          vec3 rw = normalize((vec4(reflect(v, n), 0.0) * viewMatrix).xyz);
+          float up = rw.y;
+          vec3 env = mix(vec3(0.14, 0.11, 0.08), vec3(0.95, 0.92, 0.88), smoothstep(-0.2, 0.65, up));
+          env += vec3(1.5) * exp(-abs(up - 0.03) * 36.0);
+          env += vec3(2.4) * smoothstep(0.9, 0.99, dot(rw, normalize(vec3(0.6, 0.55, 0.6))));
+          env += vec3(1.1) * smoothstep(0.88, 0.98, dot(rw, normalize(vec3(-0.7, 0.35, -0.3))));
+          float ndv = abs(dot(n, -v));
+          vec3 metal = uKinGold * env * (0.72 + 0.28 * pow(1.0 - ndv, 4.0));
+          // fine glitter in the lacquer, drifting slowly while it holds
+          float gl = pow(fxNoise(vKinR / uKinExtent * 110.0 + vec3(0.0, uKinTime * 0.35, uKinTime * 0.2)), 18.0);
+          metal += uKinGold * gl * 3.0 * kinH;
+          outgoingLight = mix(outgoingLight, metal, kinG);
+          // the molten tip: white-gold at the very front, cooling to amber behind
+          vec3 hot = mix(vec3(1.0, 0.42, 0.1), vec3(1.0, 0.92, 0.72), kinHot);
+          outgoingLight += hot * kinHot * 2.6;
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'kintsugi',
+    label: 'Kintsugi',
+    description: 'Crack the targets and mend them with flowing gold seams — reverting draws the gold back and closes the cracks',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        direction: { type: 'select', label: 'Flow', default: 'down', options: DIRECTION_OPTIONS },
+        gold: { type: 'color', label: 'Gold', default: '#f2c060' },
+        density: { type: 'number', label: 'Cracks', default: 4.5, min: 1, max: 16, step: 0.1, hint: 'Fragments across the object' },
+        width: { type: 'number', label: 'Seam width', default: 1, min: 0.3, max: 3, step: 0.05, unit: '×' },
+        branches: { type: 'boolean', label: 'Hairline branches', default: true },
+        scale: { type: 'number', label: 'Front pattern', default: 2, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 3.4, min: 0.3, max: 12, step: 0.1, unit: 's' },
+    },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.06;
+            st = { field, gold: { value: new Color() }, density: { value: 4.5 }, width: { value: 1 }, branch: { value: 1 }, mats: new Set() };
+            const own = st;
+            const layer = layerFor(own);
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.gold.value.set(String(p.gold));
+        s.density.value = Number(p.density);
+        s.width.value = Number(p.width);
+        s.branch.value = p.branches === false ? 0 : 1;
+        return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'power1.inOut', hold: true });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.inOut',
+            onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },
+        });
+    },
+});

package/dist/operations/catalogue/lidarScan.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=lidarScan.d.ts.map

package/dist/operations/catalogue/lidarScan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lidarScan.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/lidarScan.ts"],"names":[],"mappings":";AAuGA,wBAqJG"}

package/dist/operations/catalogue/lidarScan.js

@@ -0,0 +1,240 @@
+// LiDAR scan — the object is read by a laser. A thin laser sheet sweeps across
+// it (a faint plane of light, and a bright line where it cuts the surface).
+// Behind the sheet the solid is replaced by what a scanner would make of it:
+// first the reconstructed mesh (a triangulated lattice, projected on the surface
+// in the object's own space), then only the raw point cloud (surface samples that
+// fall on the sheet's scan lines, coloured by depth, by the laser, or with the
+// surface's own colours), which finally drops out.
+// Reverting plays it as a capture: points appear under the sheet, the mesh
+// triangulates between them, and the solid object resolves.
+// With Disappear off (always, as an object effect) the laser sweeps the whole
+// object and leaves all of it in scanned mode — the reconstructed mesh plus the
+// point cloud, nothing dissolving. While it holds the points twinkle and a faint
+// re-scan line drifts across now and then. Reverting sweeps the solid back.
+import { AdditiveBlending, Color, DoubleSide, Mesh, PlaneGeometry, Quaternion, ShaderMaterial, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { SWEEP_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, localBounds, runProgress, setFieldParams, sweepVector, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
+import { hideUntilWarm } from './warmup.js';
+const P = 'Ldr';
+const KEY = 'lidarScan';
+const STATE = '__opLidarScan';
+/** The mesh stage trails the laser by MESH; the points stay until POINTS behind it. */
+const MESH = 0.35;
+const POINTS = 0.75;
+const END = 1 + POINTS;
+const PALETTES = [{ value: 'depth', label: 'Depth' }, { value: 'laser', label: 'Laser' }, { value: 'surface', label: 'Surface colours' }];
+/** Where the three stages stand along the sweep (GLSL). The front is a straight plane. */
+const STAGES = /* glsl */ `
+float ldrFront(float lag) {
+  if (uLdrKeep > 0.5 && lag > 0.0) return -10.0;              // scanned mode: nothing behind the laser goes
+  return (uLdrProgress - lag) * 1.1 - 0.05;
+}
+// scanned mode, holding: a faint re-scan line drifting across now and then (-10 = none)
+float ldrRescan() {
+  if (uLdrKeep < 0.5 || uLdrProgress < 0.999) return -10.0;
+  return fract(uLdrTime * 0.08) * 1.8 - 0.4;
+}
+`;
+/** A triangulated lattice projected on the surface (triplanar), anti-aliased. */
+const LATTICE = /* glsl */ `
+float ldrTri(vec2 u) {
+  vec3 k = vec3(u.x, u.x * 0.5 + u.y * 0.8660254, -u.x * 0.5 + u.y * 0.8660254);
+  vec3 d = abs(fract(k + 0.5) - 0.5) / max(fwidth(k), vec3(1e-4));
+  return 1.0 - clamp(min(d.x, min(d.y, d.z)) - 0.1, 0.0, 1.0);
+}
+float ldrMesh(vec3 r, vec3 n) {
+  vec3 w = pow(abs(n), vec3(4.0)); w /= max(w.x + w.y + w.z, 1e-4);
+  return ldrTri(r.yz) * w.x + ldrTri(r.zx) * w.y + ldrTri(r.xy) * w.z;
+}
+`;
+function sheetMaterial(laser, alpha) {
+    return new ShaderMaterial({
+        uniforms: { uLdrSheetColor: laser, uLdrSheetA: alpha },
+        vertexShader: /* glsl */ `
+        varying vec2 vUv;
+        void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`,
+        fragmentShader: /* glsl */ `
+        uniform vec3 uLdrSheetColor; uniform float uLdrSheetA;
+        varying vec2 vUv;
+        void main() {
+          vec2 e = smoothstep(vec2(0.0), vec2(0.28), vUv) * smoothstep(vec2(0.0), vec2(0.28), 1.0 - vUv);
+          float a = e.x * e.y * uLdrSheetA;
+          // fine scan rays across the sheet
+          float rays = 0.55 + 0.45 * pow(abs(sin(vUv.y * 180.0)), 6.0);
+          gl_FragColor = vec4(uLdrSheetColor * a * rays, a);
+          #include <tonemapping_fragment>
+          #include <colorspace_fragment>
+        }`,
+        transparent: true, depthWrite: false, blending: AdditiveBlending, side: DoubleSide,
+    });
+}
+function placeSheet(target, st, on) {
+    const b = localBounds(target);
+    const size = b.getSize(new Vector3()), c = b.getCenter(new Vector3());
+    const d = sweepVector(st.field);
+    const h = Math.max((Math.abs(d.x) * size.x + Math.abs(d.y) * size.y + Math.abs(d.z) * size.z) * 0.5, 1e-3);
+    const s1 = st.field.progress.value * 1.1 - 0.05;
+    st.sheet.position.copy(c).addScaledVector(d, (s1 - 0.5) * 2 * h);
+    st.sheet.quaternion.copy(new Quaternion().setFromUnitVectors(new Vector3(0, 0, 1), d));
+    const span = Math.max(size.x, size.y, size.z) * 1.5;
+    st.sheet.scale.set(span, span, 1);
+    // the sheet shows only while it crosses the object
+    // (the mesh stays "visible" — hidden objects are skipped by the background compile)
+    st.sheetA.value = on ? 0.16 * Math.min(1, Math.max(0, Math.min((s1 + 0.05) / 0.1, (1.05 - s1) / 0.1))) : 0;
+}
+export default defineOperation({
+    value: 'lidarScan',
+    label: 'LiDAR scan',
+    description: 'Sweep a laser across the targets, leaving a scanned mesh and point cloud that dissolve (or, Disappear off, stay) — reverting captures them back',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        direction: { type: 'select', label: 'Sweep', default: 'left', options: SWEEP_OPTIONS },
+        laser: { type: 'color', label: 'Laser', default: '#5ef2ff' },
+        palette: { type: 'select', label: 'Point colours', default: 'depth', options: PALETTES },
+        density: { type: 'number', label: 'Mesh density', default: 16, min: 4, max: 60, step: 1, hint: 'Triangles across the object' },
+        points: { type: 'number', label: 'Points', default: 60000, min: 10000, max: 200000, step: 5000 },
+        sheet: { type: 'boolean', label: 'Laser sheet', default: true },
+        duration: { type: 'number', label: 'Duration', default: 4.2, min: 0.3, max: 14, step: 0.1, unit: 's' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays in scanned mode — mesh and point cloud' },
+    },
+    objectParams: { disappear: false },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.02;
+            const own = {
+                field, laser: { value: new Color() }, density: { value: 16 }, palette: { value: 0 }, sheetA: { value: 0 }, mats: new Set(), keep: { value: 0 },
+            };
+            const sample = sampleSurfaceCached(target, Math.round(Number(p.points)), 53);
+            own.points = createFxPoints(target, sample, {
+                additive: true,
+                uniforms: { ...fieldUniforms(P, field), uLdrLaser: own.laser, uLdrPalette: own.palette, uLdrKeep: own.keep },
+                vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE + STAGES,
+                vertexMain: /* glsl */ `
+                  float a = LdrAlong(LdrNorm(aP));
+                  float s1 = ldrFront(0.0), s3 = ldrFront(${POINTS.toFixed(2)});
+                  // points fall on the sheet's scan lines (plus a sparse fill between them)
+                  float lines = abs(fract(a * 90.0 + 0.5) - 0.5);
+                  float keep = max(step(lines, 0.12), step(0.9, aR.x));
+                  float since = s1 - a;                               // how long ago the laser passed
+                  if (keep < 0.5 || since < 0.0 || a < s3) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; vColor = vec3(0.0); vAlpha = 0.0; return; }
+                  float E = uLdrExtent;
+                  // dropping out: a small drift along the normal as the point fades
+                  float out_ = clamp((s3 + 0.12 - a) / 0.12, 0.0, 1.0);
+                  vec3 local = aP + aN * (E * 0.03 * out_ * (0.5 + aR.y));
+                  vec4 mv = modelViewMatrix * vec4(local, 1.0);
+                  gl_Position = projectionMatrix * mv;
+                  vec3 col;
+                  if (uLdrPalette < 0.5) {
+                    // depth from the camera, over the object's own depth range
+                    float cz = -(modelViewMatrix * vec4(uLdrMin + 0.5 * uLdrSize, 1.0)).z;
+                    float dz = clamp((-mv.z - cz) / (0.6 * E) + 0.5, 0.0, 1.0);
+                    col = mix(mix(vec3(1.0, 0.93, 0.74), vec3(0.3, 0.95, 1.0), smoothstep(0.0, 0.5, dz)), vec3(0.16, 0.24, 1.0), smoothstep(0.5, 1.0, dz));
+                  } else if (uLdrPalette < 1.5) {
+                    col = uLdrLaser * (0.6 + 0.6 * aR.z);
+                  } else {
+                    col = aC * 1.4;
+                  }
+                  // a flash as the laser reads the point
+                  float flash = exp(-since / 0.02) + exp(-abs(a - ldrRescan()) / 0.015) * 0.6;
+                  vColor = mix(col, vec3(1.0), flash * 0.7) * (1.0 + 2.0 * flash);
+                  vAlpha = (1.0 - out_) * (0.55 + 0.45 * aR.w) * (0.78 + 0.22 * sin(uLdrTime * (2.0 + 3.0 * aR.y) + aR.x * 40.0));
+                  gl_PointSize = clamp(fxPointPx(E * 0.0028, mv) * (1.0 + flash), 1.2, 4.0);`,
+            });
+            own.sheet = new Mesh(new PlaneGeometry(1, 1), sheetMaterial(own.laser, own.sheetA));
+            own.sheet.userData.__opFxHelper = true;
+            own.sheet.raycast = () => { };
+            own.sheet.renderOrder = 11;
+            target.add(own.sheet);
+            hideUntilWarm(own.sheet);
+            const layer = {
+                uniforms: { ...fieldUniforms(P, field), uLdrLaser: own.laser, uLdrDensity: own.density, uLdrKeep: own.keep },
+                common: `varying vec3 vLdrQ;\nvarying vec3 vLdrR;\nvarying vec3 vLdrN;\n${fieldGlsl(P)}\n${STAGES}`,
+                fragmentPars: LATTICE,
+                vertex: /* glsl */ `
+                vLdrR = (uLdrRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+                vLdrQ = LdrNorm(vLdrR);
+                vLdrN = (uLdrRootInv * modelMatrix * vec4(normal, 0.0)).xyz;`,
+                fragment: /* glsl */ `
+                {
+                  float a = LdrAlong(vLdrQ);
+                  float s1 = ldrFront(0.0), s2 = ldrFront(${MESH.toFixed(2)});
+                  if (a < s2) discard;                                  // only the point cloud is left
+                  float on = step(0.0001, uLdrProgress) * step(uLdrProgress, ${(END - 0.0001).toFixed(4)});
+                  if (a < s1) {
+                    // the reconstructed mesh: lattice lines only, dimming as it goes
+                    float m = ldrMesh(vLdrR / uLdrExtent * uLdrDensity, normalize(vLdrN));
+                    if (m < 0.05) discard;
+                    float age = uLdrKeep > 0.5 ? clamp((s1 - a) / 0.35, 0.0, 1.0) * 0.55 : clamp((s1 - a) / max(s1 - s2, 1e-3), 0.0, 1.0);
+                    float rs = exp(-abs(a - ldrRescan()) / 0.05);
+                    outgoingLight = uLdrLaser * m * (0.95 - 0.7 * age + 0.6 * rs) + vec3(1.0) * m * exp(-(s1 - a) / 0.015);
+                  }
+                  // the laser line where the sheet cuts the surface
+                  float dl = abs(a - s1);
+                  float line = 1.0 - smoothstep(0.0, fwidth(a) * 1.5 + 0.002, dl);
+                  float halo = exp(-dl / 0.02) * 0.6;
+                  outgoingLight += (uLdrLaser * halo + mix(uLdrLaser, vec3(1.0), 0.6) * line * 2.5) * on * (0.88 + 0.12 * sin(uLdrTime * 11.0));
+                  // the re-scan line (holding in scanned mode)
+                  float dr = abs(a - ldrRescan());
+                  outgoingLight += mix(uLdrLaser, vec3(1.0), 0.4) * (1.0 - smoothstep(0.0, fwidth(a) * 1.5 + 0.002, dr)) * 0.9;
+                }`,
+            };
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            st = own;
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.laser.value.set(String(p.laser));
+        s.density.value = Number(p.density);
+        s.palette.value = Math.max(0, PALETTES.findIndex(o => o.value === p.palette));
+        const sheetOn = p.sheet !== false;
+        s.points.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        if (s.keep.value) {
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration), ease: 'none', hold: true,
+                onUpdate: () => placeSheet(target, s, sheetOn),
+                onComplete: () => placeSheet(target, s, sheetOn),
+            });
+        }
+        return runProgress(target, s.field, END, {
+            duration: Number(p.duration), ease: 'none',
+            onUpdate: () => placeSheet(target, s, sheetOn),
+            onComplete: () => { hideMeshes(target, KEY, true); s.points.visible = false; s.sheetA.value = 0; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.points.visible = true;
+        const sheetOn = p.sheet !== false;
+        // from a hold it only has part of the way to go: keep the same speed
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / (s.keep.value ? 1 : END))), ease: 'none',
+            onUpdate: () => placeSheet(target, s, sheetOn),
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                disposeFxPoints(s.points);
+                s.sheet.removeFromParent();
+                s.sheet.geometry.dispose();
+                s.sheet.material.dispose();
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

package/dist/operations/catalogue/liquidMetal.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=liquidMetal.d.ts.map

package/dist/operations/catalogue/liquidMetal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liquidMetal.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/liquidMetal.ts"],"names":[],"mappings":";AA6EA,wBA8CG"}

package/dist/operations/catalogue/liquidMetal.js

@@ -0,0 +1,122 @@
+// Liquid metal — the object first turns to polished chrome, then melts: it sags
+// from the top down and flows out into a puddle on the ground (higher parts
+// travel further), with slow ripples running across the pool while it lies
+// there. Reverting pulls it back up into shape and the chrome fades off.
+//
+// The chrome is a procedural studio environment (sky gradient, horizon band,
+// two soft boxes) reflected about the surface normal, so it reads as metal in
+// any scene, with or without an environment map. While the mesh deforms, normals
+// come from screen-space derivatives of the displaced surface.
+import { gsap } from 'gsap';
+import { Color } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { createFieldState, fieldGlsl, fieldUniforms, runProgress, syncRoot } from './transitionField.js';
+const P = 'Liq';
+const KEY = 'liquidMetal';
+const STATE = '__opLiquid';
+function layerFor(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uLiqTint: st.tint, uLiqSpread: st.spread },
+        common: `varying float vLiqM;\nvarying vec3 vLiqView;\n${fieldGlsl(P)}`,
+        vertex: /* glsl */ `
+        {
+          mat4 toRoot = uLiqRootInv * modelMatrix;
+          vec3 rl = (toRoot * vec4(transformed, 1.0)).xyz;
+          vec3 q = LiqNorm(rl);
+          float E = uLiqExtent;
+          // melt runs after the chrome has come in; the top gives way first
+          float mp = clamp((uLiqProgress - 0.18) / 0.82, 0.0, 1.0);
+          float wob = 0.12 * (fxNoise(q * 4.0) - 0.5);
+          float m = clamp(mp * 1.3 - (1.0 - q.y) * 0.3 + wob, 0.0, 1.0);
+          m = m * m;   // slow start: it sags before it runs
+          m = m * m * (3.0 - 2.0 * m);
+          vLiqM = m;
+          vec3 C = uLiqMin + uLiqSize * 0.5;
+          float ground = uLiqMin.y;
+          vec2 rel = rl.xz - C.xz;
+          // flow outward: higher material travels further
+          vec2 xz = C.xz + rel * (1.0 + m * (0.35 + 0.75 * q.y) * uLiqSpread);
+          float r = length(xz - C.xz);
+          // the pool: a thin sheet with slow ripples
+          float thick = 0.012 * E * (1.0 + 0.8 * fxNoise(vec3(xz / E * 6.0, 0.0)));
+          float ripple = 0.004 * E * sin(r / E * 38.0 - uLiqTime * 2.4) * smoothstep(0.7, 1.0, m);
+          float y = mix(rl.y, ground + thick + ripple, m) - sin(3.14159 * m) * 0.05 * E;
+          vec3 outR = vec3(xz.x, max(y, ground + 0.001 * E), xz.y);
+          transformed = (inverse(toRoot) * vec4(outR, 1.0)).xyz;
+          vLiqView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;
+        }`,
+        fragment: /* glsl */ `
+        {
+          float chrome = smoothstep(0.0, 0.2, uLiqProgress);
+          vec3 nv = normalize(cross(dFdx(vLiqView), dFdy(vLiqView)));
+          #if defined( STANDARD ) || defined( PHONG ) || defined( LAMBERT ) || defined( TOON )
+            vec3 n = normalize(mix(normal, nv, smoothstep(0.05, 0.5, vLiqM)));
+          #else
+            vec3 n = nv;
+          #endif
+          vec3 v = normalize(vLiqView);
+          vec3 rv = reflect(v, n);
+          vec3 rw = normalize((vec4(rv, 0.0) * viewMatrix).xyz);   // view → world direction
+          // studio: dark floor, bright sky, a crisp horizon band and two soft boxes
+          float up = rw.y;
+          vec3 env = mix(vec3(0.05), vec3(0.85, 0.9, 1.0), smoothstep(-0.15, 0.6, up));
+          env += vec3(1.4) * exp(-abs(up - 0.02) * 40.0);
+          env += vec3(2.2) * smoothstep(0.92, 0.99, dot(rw, normalize(vec3(0.6, 0.55, 0.6))));
+          env += vec3(1.2) * smoothstep(0.9, 0.98, dot(rw, normalize(vec3(-0.7, 0.35, -0.3))));
+          float fres = 0.65 + 0.35 * pow(1.0 - abs(dot(n, -v)), 3.0);
+          vec3 metal = uLiqTint * env * fres;
+          outgoingLight = mix(outgoingLight, metal, chrome);
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'liquidMetal',
+    label: 'Liquid metal',
+    description: 'Turn the targets to chrome and melt them into a rippling pool — reverting pulls them back into shape',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        tint: { type: 'color', label: 'Metal', default: '#dfe7ee' },
+        spread: { type: 'number', label: 'Pool size', default: 1, min: 0.2, max: 3, step: 0.05, unit: '×' },
+        duration: { type: 'number', label: 'Duration', default: 3.4, min: 0.3, max: 12, step: 0.1, unit: 's' },
+    },
+    apply(target, p) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            const own = { field, tint: { value: new Color() }, spread: { value: 1 }, mats: new Set() };
+            // ripples keep moving while it lies melted
+            own.tick = () => { own.field.time.value += gsap.ticker.deltaRatio() / 60; syncRoot(target, own.field); };
+            const layer = layerFor(own);
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            gsap.ticker.add(own.tick);
+            st = own;
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        s.tint.value.set(String(p.tint));
+        s.spread.value = Number(p.spread);
+        return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'power1.inOut', clock: false });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.inOut', clock: false,
+            onComplete: () => {
+                gsap.ticker.remove(s.tick);
+                s.mats.forEach(m => removeLayer(m, KEY));
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

package/dist/operations/catalogue/metalize.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=metalize.d.ts.map

package/dist/operations/catalogue/metalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metalize.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/metalize.ts"],"names":[],"mappings":";AA8EA,wBA4DG"}