@3driseai/3drise-viewer 0.1.26 → 0.1.27

package/dist/operations/catalogue/shaderLayers.js

@@ -0,0 +1,322 @@
+// =============================================================================
+// Shader layers — GLSL injected into whatever material an object already has.
+// =============================================================================
+//
+// Visual operations that need a shader (rim light, dissolve…) never replace the
+// material: glass stays glass, a textured model keeps its maps. A layer is a few
+// uniforms plus GLSL chunks spliced into the built-in shader through
+// `onBeforeCompile`. Several layers can sit on one material. With no layers the
+// wrapper adds no GLSL and returns the material's own cache key, so a material
+// at rest compiles to (and shares) its pristine program — it costs nothing.
+//
+// Anchors (three r170 built-in materials):
+//   vertex    after  `#include <begin_vertex>`  (`transformed` = local position)
+//   fragment  before `#include <opaque_fragment>` (`outgoingLight`, `diffuseColor`)
+// A material without the anchors (custom ShaderMaterial) is left untouched —
+// `addLayer` returns false and the operation skips it.
+//
+// Materials are changed in place, like glow / fade: a material shared by two
+// objects gets the layer on both.
+//
+// Uniform binding (why the proxies): three keeps compiled programs per material,
+// keyed by customProgramCacheKey, and calls onBeforeCompile only the FIRST time a
+// key is compiled. Re-applying the same effect later (same key) reuses that
+// program together with the uniform objects captured the first time — the new
+// run's uniforms would never reach the GPU (effect frozen, then the object
+// "vanishes" when the run ends). So the program is always given a stable proxy
+// per material and uniform name, whose `value` reads through to the uniform
+// object of the layer currently applied.
+// Second half of the same trap: three keeps ONE uniform table per material — the
+// one from its last compile — and uses it for every cached program of that
+// material. Switching dissolve → hologram → dissolve reuses dissolve's program
+// with hologram's table, so dissolve's uniforms would never upload. Every compile
+// therefore registers ALL proxies the material has ever had, so whichever table
+// three keeps covers every cached program.
+//
+import { Color, Group, InstancedMesh, Material as ThreeMaterial, Mesh, SkinnedMesh } from 'three';
+import { compileInBackground, warmContext } from './warmup.js';
+/** material → uniform name → the live uniform object of the current layer */
+const liveUniforms = new WeakMap();
+/** material → uniform name → the stable proxy handed to the compiled program */
+const boundUniforms = new WeakMap();
+function proxyFor(mat, name) {
+    let bound = boundUniforms.get(mat);
+    if (!bound) {
+        bound = new Map();
+        boundUniforms.set(mat, bound);
+    }
+    let proxy = bound.get(name);
+    if (!proxy) {
+        proxy = {
+            get value() { return liveUniforms.get(mat)?.get(name)?.value; },
+            set value(v) { const u = liveUniforms.get(mat)?.get(name); if (u)
+                u.value = v; },
+        };
+        bound.set(name, proxy);
+    }
+    return proxy;
+}
+const STATE = '__opShaderLayers';
+const V_ANCHOR = '#include <begin_vertex>';
+const N_ANCHOR = '#include <beginnormal_vertex>';
+const D_ANCHOR = '#include <color_fragment>';
+const M_ANCHOR = '#include <metalnessmap_fragment>';
+const E_ANCHOR = '#include <emissivemap_fragment>';
+const F_ANCHOR = '#include <opaque_fragment>';
+/** Can this material take a layer? Built-in shaders only (checked by type, before compile). */
+export const canLayer = (mat) => !mat.isShaderMaterial && !mat.isRawShaderMaterial && !mat.isPointsMaterial
+    && !mat.isLineBasicMaterial && !mat.isSpriteMaterial && !mat.isShadowMaterial;
+// ---------------------------------------------------------------- staging (no freeze)
+/** Layers waiting for their program to be compiled in the background, per live material. */
+const pending = new Map();
+/**
+ * Add a layer to a material. On a live scene the layer is STAGED: nothing changes
+ * on screen until commitPendingLayers() has compiled the new program in the
+ * background (runProgress does that before an effect starts). Pass
+ * `{ immediate: true }` for materials that are not on screen yet (an effect's own
+ * helpers), or when there is no renderer.
+ */
+export function addLayer(mat, key, layer, opts) {
+    if (!canLayer(mat))
+        return false;
+    if (opts?.immediate || !warmContext())
+        return commitLayer(mat, key, layer);
+    let p = pending.get(mat);
+    if (!p) {
+        p = new Map();
+        pending.set(mat, p);
+    }
+    p.set(key, layer);
+    return true;
+}
+/** A clone for compiling in the background: same parameters and hooks → the same program cache key. */
+function warmClone(mat) {
+    const c = mat.clone();
+    const hooks = ownHooks(mat);
+    c.onBeforeCompile = hooks.onBeforeCompile;
+    c.customProgramCacheKey = hooks.customProgramCacheKey;
+    c.userData = {};
+    c.visible = true;
+    return c;
+}
+/** A stand-in object of the same kind (instancing / skinning change the program). */
+function standIn(mesh, mat) {
+    if (mesh.isBatchedMesh)
+        return null;
+    if (mesh.isInstancedMesh) {
+        const m = new InstancedMesh(mesh.geometry, mat, 1);
+        if (mesh.instanceColor)
+            m.setColorAt(0, new Color(1, 1, 1)); // instance colours change the program too
+        return m;
+    }
+    if (mesh.isSkinnedMesh) {
+        const m = new SkinnedMesh(mesh.geometry, mat);
+        if (mesh.skeleton)
+            m.bind(mesh.skeleton, mesh.bindMatrix);
+        return m;
+    }
+    return new Mesh(mesh.geometry, mat);
+}
+/**
+ * Compile, in the background, the programs that the staged layers of `root`'s
+ * materials will need, then commit the layers. three keys programs by their
+ * cache key, so when the live material switches to the layered code it finds the
+ * finished program and uses it straight away — no compile, no freeze.
+ */
+export async function commitPendingLayers(root) {
+    const entries = [];
+    const seen = new Set();
+    root.traverse((c) => {
+        if (!c.isMesh || c.userData?.__opFxHelper)
+            return;
+        for (const m of (Array.isArray(c.material) ? c.material : [c.material])) {
+            if (m && pending.has(m) && !seen.has(m)) {
+                seen.add(m);
+                entries.push({ mesh: c, mat: m });
+            }
+        }
+    });
+    if (!entries.length)
+        return;
+    const ctx = warmContext();
+    const clones = [];
+    if (ctx) {
+        const group = new Group();
+        for (const { mesh, mat } of entries) {
+            const c = warmClone(mat);
+            // the clone carries the layers the live material will have: current + staged
+            const state = mat.userData[STATE];
+            for (const [k, l] of state?.layers ?? [])
+                commitLayer(c, k, l);
+            for (const [k, l] of pending.get(mat))
+                commitLayer(c, k, l);
+            const o = standIn(mesh, c);
+            if (o) {
+                group.add(o);
+                clones.push(c);
+            }
+            else
+                c.dispose();
+        }
+        await compileInBackground(group);
+    }
+    // commit (layers staged meanwhile by the same call are included; ones removed are gone)
+    for (const { mat } of entries) {
+        const p = pending.get(mat);
+        pending.delete(mat);
+        for (const [k, l] of p ?? [])
+            commitLayer(mat, k, l);
+    }
+    if (ctx) {
+        // let the live materials take the cached programs before the clones let go of them
+        try {
+            ctx.gl.compile(root, ctx.cam, ctx.scene);
+        }
+        catch { /* next frame will */ }
+        setTimeout(() => clones.forEach(c => c.dispose()), 1500);
+    }
+}
+function commitLayer(mat, key, layer) {
+    if (!canLayer(mat))
+        return false;
+    let state = mat.userData[STATE];
+    if (!state) {
+        state = { layers: new Map(), onBeforeCompile: mat.onBeforeCompile, customProgramCacheKey: mat.customProgramCacheKey };
+        mat.userData[STATE] = state;
+        const own = state;
+        mat.onBeforeCompile = function (shader, renderer) {
+            own.onBeforeCompile?.call(this, shader, renderer);
+            if (!shader.vertexShader.includes(V_ANCHOR) || !shader.fragmentShader.includes(F_ANCHOR))
+                return;
+            for (const l of own.layers.values())
+                for (const n of Object.keys(l.uniforms))
+                    proxyFor(mat, n);
+            for (const [n, proxy] of boundUniforms.get(mat) ?? [])
+                shader.uniforms[n] = proxy;
+            for (const l of own.layers.values()) {
+                const decl = Object.keys(l.uniforms).map(n => uniformDecl(n, l.uniforms[n].value)).join('\n');
+                shader.vertexShader = shader.vertexShader
+                    .replace('#include <common>', `#include <common>\n${decl}\n${l.common ?? ''}\n${l.vertexPars ?? ''}`)
+                    .replace(N_ANCHOR, `${N_ANCHOR}\n${l.normal ?? ''}`)
+                    .replace(V_ANCHOR, `${V_ANCHOR}\n${l.vertex ?? ''}`);
+                shader.fragmentShader = shader.fragmentShader
+                    .replace('#include <common>', `#include <common>\n${decl}\n${l.common ?? ''}\n${l.fragmentPars ?? ''}`)
+                    .replace(D_ANCHOR, `${D_ANCHOR}\n${l.diffuse ?? ''}`)
+                    .replace(M_ANCHOR, `${M_ANCHOR}\n${l.material ?? ''}`)
+                    .replace(E_ANCHOR, `${E_ANCHOR}\n${l.emissive ?? ''}`)
+                    .replace(F_ANCHOR, `${l.fragment ?? ''}\n${F_ANCHOR}`);
+            }
+        };
+        mat.customProgramCacheKey = function () {
+            // three's default key is `onBeforeCompile.toString()` — use the ORIGINAL hook's, not this wrapper's
+            const base = own.customProgramCacheKey === ThreeMaterial.prototype.customProgramCacheKey
+                ? String(own.onBeforeCompile)
+                : own.customProgramCacheKey.call(this);
+            // no layers → the material's own key and GLSL, so at rest it shares its pristine program
+            return own.layers.size ? `${base}|fx:${[...own.layers.keys()].sort().join(',')}` : base;
+        };
+    }
+    state.layers.set(key, layer);
+    // point this material's proxies at this run's uniform objects (see "Uniform binding")
+    let live = liveUniforms.get(mat);
+    if (!live) {
+        live = new Map();
+        liveUniforms.set(mat, live);
+    }
+    for (const [n, u] of Object.entries(layer.uniforms))
+        live.set(n, u);
+    mat.needsUpdate = true;
+    return true;
+}
+/** The material's own shader hooks, before any layer (for cloning a layered material). */
+export function ownHooks(mat) {
+    const state = mat.userData[STATE];
+    return state
+        ? { onBeforeCompile: state.onBeforeCompile, customProgramCacheKey: state.customProgramCacheKey }
+        : { onBeforeCompile: mat.onBeforeCompile, customProgramCacheKey: mat.customProgramCacheKey };
+}
+/**
+ * Take a layer off. The wrapper hooks stay installed (with no layers they add no
+ * GLSL and return the material's own cache key): any later recompile — new
+ * lights, a new effect — must still register every proxy, see "Uniform binding".
+ */
+export function removeLayer(mat, key) {
+    const p = pending.get(mat);
+    if (p?.delete(key) && p.size === 0)
+        pending.delete(mat);
+    const state = mat.userData[STATE];
+    if (!state || !state.layers.delete(key))
+        return;
+    mat.needsUpdate = true;
+}
+/** Does the material carry any layer right now? */
+export const hasLayers = (mat) => (mat.userData[STATE]?.layers.size ?? 0) > 0;
+export const hasLayer = (mat, key) => !!mat.userData[STATE]?.layers.has(key);
+/** Every mesh material under a root (points, lines and sprites have no surface to layer). */
+export function forEachMeshMaterial(root, fn) {
+    root.traverse((child) => {
+        if (!child.isMesh)
+            return;
+        const mats = Array.isArray(child.material) ? child.material : [child.material];
+        mats.forEach((m) => m && fn(m, child));
+    });
+}
+/** `uniform <type> <name>;` from a uniform's current value. */
+export function uniformDecl(name, v) {
+    const type = typeof v === 'number' ? 'float'
+        : v?.isColor ? 'vec3'
+            : v?.isVector3 ? 'vec3'
+                : v?.isVector2 ? 'vec2'
+                    : v?.isVector4 ? 'vec4'
+                        : v?.isMatrix4 ? 'mat4'
+                            : v?.isTexture ? 'sampler2D'
+                                : 'float';
+    return `uniform ${type} ${name};`;
+}
+/** Calm 3D value noise + 3-octave fBm (GLSL). */
+export const GLSL_NOISE = /* glsl */ `
+#ifndef FX_NOISE
+#define FX_NOISE
+float fxHash(vec3 p) { p = fract(p * 0.3183099 + 0.1); p *= 17.0; return fract(p.x * p.y * p.z * (p.x + p.y + p.z)); }
+float fxNoise(vec3 x) {
+  vec3 i = floor(x); vec3 f = fract(x); f = f * f * (3.0 - 2.0 * f);
+  return mix(mix(mix(fxHash(i), fxHash(i + vec3(1,0,0)), f.x), mix(fxHash(i + vec3(0,1,0)), fxHash(i + vec3(1,1,0)), f.x), f.y),
+             mix(mix(fxHash(i + vec3(0,0,1)), fxHash(i + vec3(1,0,1)), f.x), mix(fxHash(i + vec3(0,1,1)), fxHash(i + vec3(1,1,1)), f.x), f.y), f.z);
+}
+float fxFbm(vec3 p) { float a = 0.5, s = 0.0; for (int i = 0; i < 3; i++) { s += a * fxNoise(p); p = p * 2.03 + 11.7; a *= 0.5; } return s / 0.875; }
+#endif
+`;
+/** Rotation about a unit axis (GLSL), include-guarded. */
+export const GLSL_ROT = /* glsl */ `
+#ifndef FX_ROT
+#define FX_ROT
+mat3 fxRot(vec3 ax, float an) {
+  float s = sin(an), c = cos(an), oc = 1.0 - c;
+  return mat3(oc*ax.x*ax.x + c,      oc*ax.x*ax.y + ax.z*s, oc*ax.z*ax.x - ax.y*s,
+              oc*ax.x*ax.y - ax.z*s, oc*ax.y*ax.y + c,      oc*ax.y*ax.z + ax.x*s,
+              oc*ax.z*ax.x + ax.y*s, oc*ax.y*ax.z - ax.x*s, oc*ax.z*ax.z + c);
+}
+#endif
+`;
+/** 3D cellular noise (GLSL): returns vec3(F1, F2, cell hash) for p, include-guarded. */
+export const GLSL_WORLEY = /* glsl */ `
+#ifndef FX_WORLEY
+#define FX_WORLEY
+vec3 fxHash3(vec3 p) {
+  p = vec3(dot(p, vec3(127.1, 311.7, 74.7)), dot(p, vec3(269.5, 183.3, 246.1)), dot(p, vec3(113.5, 271.9, 124.6)));
+  return fract(sin(p) * 43758.5453123);
+}
+vec3 fxWorley(vec3 p) {
+  vec3 i = floor(p); vec3 f = fract(p);
+  float f1 = 8.0, f2 = 8.0; float id = 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 h = fxHash3(i + g);
+    vec3 r = g + h - f;
+    float d = dot(r, r);
+    if (d < f1) { f2 = f1; f1 = d; id = h.x; } else if (d < f2) { f2 = d; }
+  }
+  return vec3(sqrt(f1), sqrt(f2), id);
+}
+#endif
+`;

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

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

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

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

package/dist/operations/catalogue/shatter.js

@@ -0,0 +1,267 @@
+// Shatter — the target cracks along the transition front (the cracks glow just
+// before a piece lets go), then every triangle breaks off as a shard: it spins
+// about its own centroid on a random axis, is thrown outward from the object's
+// centre, falls under gravity and shrinks away. Reverting runs it backwards —
+// the shards fly back and the surface seals.
+//
+// How: for the length of the effect each mesh gets a non-indexed copy of its
+// geometry with a per-triangle centroid + random attribute, and its own clone of
+// each material (so the shard attributes never touch another object sharing it).
+// Both are swapped back when the object is whole again (materials disposed; the
+// split geometry is cached for the next play and disposed with its source).
+// Triangles are grouped into Voronoi cells around seeds sampled on the surface, so
+// the object breaks into rigid chunks, not dust. Meshes over MAX_TRIS triangles are not split; they just hide when the front
+// has passed half-way.
+import { BufferAttribute, Group, Matrix4, Mesh, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, ownHooks } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { compileInBackground, retainPrograms } from './warmup.js';
+const P = 'Sht';
+const KEY = 'shatter';
+const STATE = '__opShatter';
+const LIFE = 0.55;
+const MAX_TRIS = 250_000;
+/**
+ * Non-indexed copy of `geo` where every triangle carries the centroid and random of
+ * its Voronoi cell (nearest seed, in root space), so a cell moves as one rigid chunk.
+ * `m` maps mesh-local → root-local.
+ */
+function splitGeometry(geo, m, seeds, cellRand) {
+    const g = geo.index ? geo.toNonIndexed() : geo.clone();
+    const pos = g.getAttribute('position');
+    const n = pos.count;
+    const nSeeds = seeds.length / 3;
+    const cellOf = new Int32Array(n / 3);
+    const sum = new Float64Array(nSeeds * 3);
+    const cnt = new Uint32Array(nSeeds);
+    const c = new Vector3();
+    for (let t = 0, f = 0; t < n; t += 3, f++) {
+        const cx = (pos.getX(t) + pos.getX(t + 1) + pos.getX(t + 2)) / 3;
+        const cy = (pos.getY(t) + pos.getY(t + 1) + pos.getY(t + 2)) / 3;
+        const cz = (pos.getZ(t) + pos.getZ(t + 1) + pos.getZ(t + 2)) / 3;
+        c.set(cx, cy, cz).applyMatrix4(m);
+        let best = 0, bd = Infinity;
+        for (let k = 0; k < nSeeds; k++) {
+            const dx = c.x - seeds[k * 3], dy = c.y - seeds[k * 3 + 1], dz = c.z - seeds[k * 3 + 2];
+            const d = dx * dx + dy * dy + dz * dz;
+            if (d < bd) {
+                bd = d;
+                best = k;
+            }
+        }
+        cellOf[f] = best;
+        sum[best * 3] += cx;
+        sum[best * 3 + 1] += cy;
+        sum[best * 3 + 2] += cz;
+        cnt[best]++;
+    }
+    const centroid = new Float32Array(n * 3);
+    const rand = new Float32Array(n * 4);
+    for (let t = 0, f = 0; t < n; t += 3, f++) {
+        const k = cellOf[f];
+        const inv = 1 / Math.max(1, cnt[k]);
+        for (let v = t; v < t + 3; v++) {
+            centroid[v * 3] = sum[k * 3] * inv;
+            centroid[v * 3 + 1] = sum[k * 3 + 1] * inv;
+            centroid[v * 3 + 2] = sum[k * 3 + 2] * inv;
+            rand[v * 4] = cellRand[k * 4];
+            rand[v * 4 + 1] = cellRand[k * 4 + 1];
+            rand[v * 4 + 2] = cellRand[k * 4 + 2];
+            rand[v * 4 + 3] = cellRand[k * 4 + 3];
+        }
+    }
+    g.setAttribute('aShtCentroid', new BufferAttribute(centroid, 3));
+    g.setAttribute('aShtRand', new BufferAttribute(rand, 4));
+    return g;
+}
+/**
+ * Split geometries are kept per source geometry (and seed set), so replaying a
+ * shatter reuses them; they are disposed with their source geometry.
+ */
+const splitCache = new WeakMap();
+function splitGeometryCached(geo, m, seeds, cellRand) {
+    const key = `${geo.attributes.position?.version ?? 0}|${seeds.length}|${seeds[0]}|${seeds[seeds.length - 1]}|${m.elements.map(e => e.toFixed(4)).join(',')}`;
+    const hit = splitCache.get(geo);
+    if (hit && hit.key === key)
+        return hit.geo;
+    hit?.geo.dispose();
+    const split = splitGeometry(geo, m, seeds, cellRand);
+    if (!hit)
+        geo.addEventListener('dispose', () => { splitCache.get(geo)?.geo.dispose(); splitCache.delete(geo); });
+    splitCache.set(geo, { key, geo: split });
+    return split;
+}
+function cloneMaterial(m) {
+    const c = m.clone();
+    // keep the material's own shader hooks (clone() does not copy them) — not another
+    // effect's layer wrapper, which is bound to the original material
+    const hooks = ownHooks(m);
+    c.onBeforeCompile = hooks.onBeforeCompile;
+    c.customProgramCacheKey = hooks.customProgramCacheKey;
+    c.userData = {};
+    return c;
+}
+function shardLayer(st) {
+    const shardFn = /* glsl */ `
+attribute vec3 aShtCentroid;
+attribute vec4 aShtRand;
+varying float vShtA;
+mat3 shtRot(vec3 ax, float an) {
+  float s = sin(an), c = cos(an), oc = 1.0 - c;
+  return mat3(oc*ax.x*ax.x + c,      oc*ax.x*ax.y + ax.z*s, oc*ax.z*ax.x - ax.y*s,
+              oc*ax.x*ax.y - ax.z*s, oc*ax.y*ax.y + c,      oc*ax.y*ax.z + ax.x*s,
+              oc*ax.z*ax.x + ax.y*s, oc*ax.y*ax.z - ax.x*s, oc*ax.z*ax.z + c);
+}
+float shtAmount() {
+  vec3 cr = (uShtRootInv * modelMatrix * vec4(aShtCentroid, 1.0)).xyz;
+  float birth = ShtBirthOf(ShtField(ShtNorm(cr)));
+  return clamp((uShtProgress - birth) / uShtLife, 0.0, 1.0);
+}
+vec3 shtAxis() { return normalize(aShtRand.xyz * 2.0 - 1.0 + vec3(1e-3, 2e-3, 3e-3)); }
+float shtAngle(float a) { return a * (1.2 + 2.8 * aShtRand.w) * (aShtRand.x < 0.5 ? -1.0 : 1.0); }
+`;
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uShtLife: st.life, uShtPush: st.push, uShtGravity: st.gravity, uShtCenterW: st.centerW },
+        common: `varying vec3 vShtQ;\n${fieldGlsl(P)}`,
+        vertexPars: shardFn,
+        normal: /* glsl */ `
+        { float a0 = shtAmount(); objectNormal = shtRot(shtAxis(), shtAngle(a0)) * objectNormal; }`,
+        vertex: /* glsl */ `
+        {
+          float a = shtAmount();
+          vShtA = a;
+          vShtQ = ShtNorm((uShtRootInv * modelMatrix * vec4(transformed, 1.0)).xyz);
+          float shrink = 1.0 - smoothstep(0.7, 1.0, a);
+          vec3 local = aShtCentroid + shtRot(shtAxis(), shtAngle(a)) * ((transformed - aShtCentroid) * shrink);
+          // thrown out from the object's centre, then gravity (world space)
+          vec3 cw = (modelMatrix * vec4(aShtCentroid, 1.0)).xyz;
+          vec3 outW = normalize(cw - uShtCenterW + vec3(1e-4));
+          float E = uShtExtent;
+          vec3 dispW = outW * (uShtPush * E * 0.35 * a * (0.5 + aShtRand.y))
+                     + vec3(0.0, -1.0, 0.0) * (uShtGravity * E * 0.6 * a * a);
+          transformed = local + inverse(mat3(modelMatrix)) * dispW;
+        }`,
+        fragmentPars: 'varying float vShtA;',
+        fragment: /* glsl */ `
+        {
+          // cracks glow on the still-attached surface just ahead of the front…
+          float d = ShtField(vShtQ) - ShtThreshold();
+          float crack = (1.0 - smoothstep(0.0, uShtEdgeWidth, abs(d))) * step(0.0001, uShtProgress) * step(vShtA, 0.0001);
+          // …and a fresh shard's broken faces burn for a moment after it lets go
+          float fresh = step(0.0001, vShtA) * (1.0 - smoothstep(0.0, 0.4, vShtA));
+          outgoingLight += uShtEdgeColor * (crack * 2.5 + fresh * 0.7);
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'shatter',
+    label: 'Shatter',
+    description: 'Crack the targets along a glowing front and break them into tumbling shards — reverting reassembles',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'outward', options: DIRECTION_OPTIONS },
+        edgeColor: { type: 'color', label: 'Crack colour', default: '#8fe3ff' },
+        push: { type: 'number', label: 'Force', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        gravity: { type: 'number', label: 'Gravity', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        pieces: { type: 'number', label: 'Pieces', default: 90, min: 8, max: 400, step: 1, hint: 'How many chunks it breaks into' },
+        scale: { type: 'number', label: 'Crack pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 2.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.04;
+            st = { field, life: { value: LIFE }, push: { value: 1 }, gravity: { value: 1 }, centerW: { value: new Vector3() }, swaps: [] };
+            const layer = shardLayer(st);
+            const own = st;
+            // Voronoi seeds on the surface (root space): each cell becomes one chunk
+            const seeds = sampleSurfaceCached(target, Math.max(4, Math.round(Number(p.pieces))), 5);
+            const cellRand = seeds.random;
+            target.updateWorldMatrix(true, true);
+            const rootInv = new Matrix4().copy(target.matrixWorld).invert();
+            target.traverse((c) => {
+                if (!c.isMesh || c.userData?.__opFxHelper || !c.geometry?.getAttribute('position'))
+                    return;
+                const geo = c.geometry;
+                const tris = (geo.index ? geo.index.count : geo.getAttribute('position').count) / 3;
+                const split = tris <= MAX_TRIS;
+                const swap = { mesh: c, geometry: geo, material: c.material, split };
+                if (split) {
+                    // prepared now, swapped in only once their shaders are compiled (no freeze)
+                    swap.splitGeo = splitGeometryCached(geo, new Matrix4().multiplyMatrices(rootInv, c.matrixWorld), seeds.position.subarray(0, seeds.count * 3), cellRand);
+                    const mats = Array.isArray(c.material) ? c.material.map(cloneMaterial) : cloneMaterial(c.material);
+                    (Array.isArray(mats) ? mats : [mats]).forEach(m => addLayer(m, KEY, layer, { immediate: true }));
+                    swap.splitMat = mats;
+                }
+                own.swaps.push(swap);
+            });
+            // compile the shard materials on stand-ins, then swap the pieces in
+            const stage = new Group();
+            for (const sw of own.swaps)
+                if (sw.split)
+                    stage.add(new Mesh(sw.splitGeo, sw.splitMat));
+            own.ready = compileInBackground(stage).then(() => {
+                retainPrograms(stage);
+                if (target.userData[STATE] !== own)
+                    return; // reverted meanwhile
+                for (const sw of own.swaps)
+                    if (sw.split) {
+                        sw.mesh.geometry = sw.splitGeo;
+                        sw.mesh.material = sw.splitMat;
+                    }
+            });
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.push.value = Number(p.push);
+        s.gravity.value = Number(p.gravity);
+        const center = () => {
+            const b = s.field.boundsMin.value.clone().addScaledVector(s.field.boundsSize.value, 0.5);
+            s.centerW.value.copy(b.applyMatrix4(target.matrixWorld));
+        };
+        center();
+        return runProgress(target, s.field, 1 + LIFE, {
+            duration: Number(p.duration), ease: 'power1.in', ready: s.ready,
+            onUpdate: () => { center(); hideUnsplit(s, s.field.progress.value > 0.5); },
+            onComplete: () => { target.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        target.visible = true;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.out',
+            onUpdate: () => {
+                const b = s.field.boundsMin.value.clone().addScaledVector(s.field.boundsSize.value, 0.5);
+                s.centerW.value.copy(b.applyMatrix4(target.matrixWorld));
+                hideUnsplit(s, s.field.progress.value > 0.5);
+            },
+            onComplete: () => {
+                for (const sw of s.swaps) {
+                    if (!sw.split) {
+                        sw.mesh.visible = true;
+                        continue;
+                    }
+                    sw.mesh.geometry = sw.geometry;
+                    sw.mesh.material = sw.material;
+                    (Array.isArray(sw.splitMat) ? sw.splitMat : [sw.splitMat]).forEach(m => m.dispose());
+                }
+                delete target.userData[STATE];
+            },
+        });
+    },
+});
+function hideUnsplit(s, hidden) {
+    for (const sw of s.swaps)
+        if (!sw.split)
+            sw.mesh.visible = !hidden;
+}

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

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

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

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