@3driseai/3drise-viewer 0.1.26 → 0.1.28

package/dist/operations/catalogue/frost.js

@@ -0,0 +1,111 @@
+// Frost — ice spreads over the object along a feathery front: the surface turns
+// to faceted crystal (3D cellular pattern in the object's own space), glossy
+// where the ice is clear and rough and white where frost crusts along the facet
+// seams, with glints that catch the light cell by cell. The base colour and the
+// roughness change BEFORE lighting, so the ice is lit by the scene like a real
+// material. A state, not an exit: it stays frozen while on; reverting thaws.
+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 = 'Frs';
+const KEY = 'frost';
+const STATE = '__opFrost';
+function layerFor(st) {
+    // computed ONCE per fragment, in the first anchor (diffuse), then shared: the
+    // cellular pattern is the costly part to compile and to run
+    const frozen = /* glsl */ `
+      float frsT = FrsThreshold();
+      float frsF = FrsField(vFrsQ);
+      float fr = frsFr;
+      vec3 cell = frsCell;
+      float seam = frsSeam;
+    `;
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uFrsIce: st.ice, uFrsDensity: st.density },
+        common: `varying vec3 vFrsQ;\nvarying vec3 vFrsR;\nvarying vec3 vFrsView;\n${fieldGlsl(P)}\n${GLSL_WORLEY}`,
+        fragmentPars: 'float frsFr = 0.0; vec3 frsCell = vec3(1.0); float frsSeam = 0.0;',
+        vertex: /* glsl */ `
+        vFrsR = (uFrsRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vFrsQ = FrsNorm(vFrsR);
+        vFrsView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
+        diffuse: /* glsl */ `
+        {
+          frsFr = smoothstep(0.0, uFrsEdgeWidth, FrsThreshold() - FrsField(vFrsQ));
+          frsCell = fxWorley(vFrsR * (uFrsDensity / uFrsExtent));
+          frsSeam = 1.0 - smoothstep(0.0, 0.09, frsCell.y - frsCell.x);
+          ${frozen}
+          vec3 clearIce = uFrsIce * (0.55 + 0.25 * cell.z);
+          vec3 crust = vec3(0.93, 0.96, 1.0);
+          vec3 ice = mix(clearIce, crust, clamp(seam * 0.9 + 0.2 * fxFbm(vFrsR / uFrsExtent * 18.0), 0.0, 1.0));
+          diffuseColor.rgb = mix(diffuseColor.rgb, ice, fr * 0.9);
+        }`,
+        material: /* glsl */ `
+        {
+          ${frozen}
+          roughnessFactor = mix(roughnessFactor, mix(0.12, 0.75, seam), fr);
+          metalnessFactor = mix(metalnessFactor, 0.0, fr);
+        }`,
+        fragment: /* glsl */ `
+        {
+          ${frozen}
+          vec3 v = normalize(-vFrsView);
+          // each facet has its own crystal plane: some catch the light, most don't
+          vec3 g = normalize(fxHash3(floor(vFrsR * (uFrsDensity / uFrsExtent)) + 17.0) - 0.5);
+          float glint = pow(max(dot(g, v), 0.0), 90.0) * (1.0 - seam);
+          vec3 nv = normalize(cross(dFdx(vFrsView), dFdy(vFrsView)));
+          float rim = pow(1.0 - abs(dot(nv, v)), 3.0);
+          // the growing front: a thin bright crystalline line
+          float front = exp(-abs(frsT - frsF) / 0.012) * step(0.0001, uFrsProgress) * step(uFrsProgress, 0.9999);
+          outgoingLight += fr * (vec3(1.0) * glint * 4.0 + uFrsIce * rim * 0.45) + vec3(0.85, 0.95, 1.0) * front * 1.2;
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'frost',
+    label: 'Frost',
+    description: 'Spread faceted ice with glinting crystals over the targets — reverting thaws them',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    stack: 'surface',
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        ice: { type: 'color', label: 'Ice', default: '#bfe4ff' },
+        density: { type: 'number', label: 'Crystals', default: 14, min: 3, max: 60, step: 1, hint: 'Facets across the object' },
+        scale: { type: 'number', label: 'Front pattern', default: 3, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 2.6, 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.05;
+            st = { field, ice: { value: new Color() }, density: { value: 14 }, 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.ice.value.set(String(p.ice));
+        s.density.value = Number(p.density);
+        return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'power1.out', 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.in',
+            onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },
+        });
+    },
+});

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

@@ -0,0 +1,21 @@
+import { InstancedMesh } from 'three';
+import type { BufferGeometry, Object3D } from 'three';
+import { type ShaderLayer } from './shaderLayers';
+export interface FxInstancesOptions {
+    geometry: BufferGeometry;
+    count: number;
+    /** xyz root-local centre per instance */
+    positions: Float32Array;
+    /** rgb linear per instance */
+    colors: Float32Array;
+    /** Extra per-instance attributes, e.g. { aVoxBirth: [data, 1] } */
+    attributes: Record<string, [Float32Array, number]>;
+    layerKey: string;
+    layer: ShaderLayer;
+    roughness?: number;
+    metalness?: number;
+    doubleSided?: boolean;
+}
+export declare function createFxInstances(root: Object3D, o: FxInstancesOptions): InstancedMesh;
+export declare function disposeFxInstances(mesh: InstancedMesh | null | undefined): void;
+//# sourceMappingURL=fxInstances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fxInstances.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/fxInstances.ts"],"names":[],"mappings":"AAOA,OAAO,EAA+C,aAAa,EAAiC,MAAM,OAAO,CAAC;AAClH,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,EAAY,KAAK,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAG5D,MAAM,WAAW,kBAAkB;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,SAAS,EAAE,YAAY,CAAC;IACxB,8BAA8B;IAC9B,MAAM,EAAE,YAAY,CAAC;IACrB,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,WAAW,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,kBAAkB,GAAG,aAAa,CA0BtF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,QAMxE"}

package/dist/operations/catalogue/fxInstances.js

@@ -0,0 +1,47 @@
+// =============================================================================
+// Effect instances — an InstancedMesh attached to a target for the length of an
+// effect (voxels, petals…). A real lit MeshStandardMaterial, so the pieces are
+// shaded and cast shadows like the object itself; their motion is a shader layer
+// (per-instance attributes), so nothing is animated on the CPU.
+// Root-local, never raycasts, never counts in bounds, disposed with the effect.
+// =============================================================================
+import { Color, DoubleSide, InstancedBufferAttribute, InstancedMesh, Matrix4, MeshStandardMaterial } from 'three';
+import { addLayer } from './shaderLayers.js';
+import { hideUntilWarm } from './warmup.js';
+export function createFxInstances(root, o) {
+    const geo = o.geometry;
+    for (const [name, [data, size]] of Object.entries(o.attributes))
+        geo.setAttribute(name, new InstancedBufferAttribute(data, size));
+    const mat = new MeshStandardMaterial({
+        roughness: o.roughness ?? 0.6, metalness: o.metalness ?? 0.05,
+        side: o.doubleSided ? DoubleSide : undefined,
+    });
+    addLayer(mat, o.layerKey, o.layer, { immediate: true }); // a new material: compiled as a helper
+    const mesh = new InstancedMesh(geo, mat, o.count);
+    const m = new Matrix4();
+    const c = new Color();
+    for (let i = 0; i < o.count; i++) {
+        m.makeTranslation(o.positions[i * 3], o.positions[i * 3 + 1], o.positions[i * 3 + 2]);
+        mesh.setMatrixAt(i, m);
+        mesh.setColorAt(i, c.setRGB(o.colors[i * 3], o.colors[i * 3 + 1], o.colors[i * 3 + 2]));
+    }
+    mesh.instanceMatrix.needsUpdate = true;
+    if (mesh.instanceColor)
+        mesh.instanceColor.needsUpdate = true;
+    mesh.frustumCulled = false;
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.raycast = () => { };
+    mesh.userData.__opFxHelper = true;
+    root.add(mesh);
+    hideUntilWarm(mesh);
+    return mesh;
+}
+export function disposeFxInstances(mesh) {
+    if (!mesh)
+        return;
+    mesh.removeFromParent();
+    mesh.geometry.dispose();
+    mesh.material.dispose();
+    mesh.dispose();
+}

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

@@ -0,0 +1,22 @@
+import { Points } from 'three';
+import type { Object3D } from 'three';
+import type { SurfaceSample } from './surfaceSample';
+export interface FxPointsOptions {
+    uniforms: Record<string, {
+        value: unknown;
+    }>;
+    /** GLSL before main (after uniform/attribute declarations). */
+    vertexPars: string;
+    /**
+     * main() body. Attributes: aP (root-local position), aN (normal), aC (colour),
+     * aR (vec4 random). Must write gl_Position, gl_PointSize and vColor (rgb) / vAlpha.
+     * `uFxViewH` is the drawing-buffer height, for perspective point sizes.
+     */
+    vertexMain: string;
+    additive: boolean;
+}
+export declare function createFxPoints(root: Object3D, sample: SurfaceSample, o: FxPointsOptions): Points;
+export declare function disposeFxPoints(pts: Points | null | undefined): void;
+/** Perspective point size in pixels for a world-size `s` at view depth `z` (GLSL). */
+export declare const GLSL_POINT_SIZE = "\nfloat fxPointPx(float s, vec4 mv) { return s * uFxViewH * projectionMatrix[1][1] * 0.5 / max(-mv.z, 1e-3); }\n";
+//# sourceMappingURL=fxPoints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fxPoints.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/fxPoints.ts"],"names":[],"mappings":"AAKA,OAAO,EAAqE,MAAM,EAA2B,MAAM,OAAO,CAAC;AAC3H,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IAC7C,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;CACrB;AAiBD,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,CAAC,EAAE,eAAe,GAAG,MAAM,CAoChG;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,QAK7D;AAED,sFAAsF;AACtF,eAAO,MAAM,eAAe,qHAE3B,CAAC"}

package/dist/operations/catalogue/fxPoints.js

@@ -0,0 +1,70 @@
+// =============================================================================
+// Effect particles — a Points cloud attached to a target for the length of a
+// transition. Lives in the target's root-local space (so it moves with it),
+// never raycasts, never counts in bounds, and is disposed with the effect.
+// =============================================================================
+import { AdditiveBlending, BufferAttribute, BufferGeometry, NormalBlending, Points, ShaderMaterial, Vector2 } from 'three';
+import { uniformDecl } from './shaderLayers.js';
+import { hideUntilWarm } from './warmup.js';
+const FRAG = /* glsl */ `
+varying vec3 vColor;
+varying float vAlpha;
+void main() {
+  vec2 d = gl_PointCoord - 0.5;
+  float r2 = dot(d, d) * 4.0;
+  if (r2 > 1.0) discard;
+  // soft core + halo
+  float a = exp(-r2 * 3.2) * vAlpha;
+  if (a < 0.004) discard;
+  gl_FragColor = vec4(vColor * a, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+export function createFxPoints(root, sample, o) {
+    const geo = new BufferGeometry();
+    geo.setAttribute('position', new BufferAttribute(sample.position.slice(0, sample.count * 3), 3));
+    geo.setAttribute('aP', new BufferAttribute(sample.position.slice(0, sample.count * 3), 3));
+    geo.setAttribute('aN', new BufferAttribute(sample.normal.slice(0, sample.count * 3), 3));
+    geo.setAttribute('aC', new BufferAttribute(sample.color.slice(0, sample.count * 3), 3));
+    geo.setAttribute('aR', new BufferAttribute(sample.random.slice(0, sample.count * 4), 4));
+    const viewH = { value: 1000 };
+    const uniforms = { ...o.uniforms, uFxViewH: viewH };
+    const decl = Object.keys(uniforms).map(n => uniformDecl(n, uniforms[n].value)).join('\n');
+    const mat = new ShaderMaterial({
+        uniforms: uniforms,
+        vertexShader: `${decl}
+attribute vec3 aP; attribute vec3 aN; attribute vec3 aC; attribute vec4 aR;
+varying vec3 vColor; varying float vAlpha;
+${o.vertexPars}
+void main() {
+${o.vertexMain}
+}`,
+        fragmentShader: FRAG,
+        transparent: true,
+        depthWrite: false,
+        // premultiplied: additive glow, or normal "over" for solid colour
+        blending: o.additive ? AdditiveBlending : NormalBlending,
+        premultipliedAlpha: true,
+    });
+    const pts = new Points(geo, mat);
+    pts.frustumCulled = false;
+    pts.raycast = () => { };
+    pts.userData.__opFxHelper = true;
+    pts.renderOrder = 10;
+    const size = new Vector2();
+    pts.onBeforeRender = (renderer) => { viewH.value = renderer.getDrawingBufferSize(size).y; };
+    root.add(pts);
+    hideUntilWarm(pts);
+    return pts;
+}
+export function disposeFxPoints(pts) {
+    if (!pts)
+        return;
+    pts.removeFromParent();
+    pts.geometry.dispose();
+    pts.material.dispose();
+}
+/** Perspective point size in pixels for a world-size `s` at view depth `z` (GLSL). */
+export const GLSL_POINT_SIZE = /* glsl */ `
+float fxPointPx(float s, vec4 mv) { return s * uFxViewH * projectionMatrix[1][1] * 0.5 / max(-mv.z, 1e-3); }
+`;

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

@@ -1 +1 @@
-{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/glow.ts"],"names":[],"mappings":";AAMA,wBAyCG"}
+{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/glow.ts"],"names":[],"mappings":";AAMA,wBA0CG"}

package/dist/operations/catalogue/glow.js

@@ -6,9 +6,10 @@ export default defineOperation({
     value: 'glow',
     label: 'Glow',
     description: 'Light the targets up with an emissive glow',
+    channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
     params: {
         color: { type: 'color', label: 'Colour', default: '#3380ff' },
         intensity: { type: 'number', label: 'Intensity', default: 3, min: 0, max: 20, step: 0.1 },

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

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

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

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

package/dist/operations/catalogue/heatCracks.js

@@ -0,0 +1,134 @@
+// Heat cracks — heat takes hold of the object and you see what it does to it:
+// a network of cracks spreads along the front and glows from inside like cooling
+// lava; the cracks sink into the surface (real relief — vertices along the crack
+// seams are pushed in, the plates between them swell slightly), the plates char
+// and darken from their edges inward, and a few plates run hot as a whole. The
+// glow keeps breathing slowly while the effect is on. A state, not an exit —
+// nothing dissolves; reverting cools the object and the cracks close.
+import { gsap } from 'gsap';
+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, syncRoot } from './transitionField.js';
+const P = 'Hot';
+const KEY = 'heatCracks';
+const STATE = '__opHeatCracks';
+const CRACKS = /* glsl */ `
+// how far the cracking has got at a point, and where the seams are
+float hotCracked(vec3 q) { return smoothstep(0.0, uHotEdgeWidth, HotThreshold() - HotField(q)); }
+vec3 hotCells(vec3 r) { return fxWorley(r * (uHotDensity / uHotExtent)); }
+`;
+function layerFor(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uHotHeat: st.heat, uHotDensity: st.density, uHotDepth: st.depth },
+        common: `varying vec3 vHotQ;\nvarying vec3 vHotR;\n${fieldGlsl(P)}\n${GLSL_WORLEY}\n${CRACKS}`,
+        fragmentPars: 'vec3 hotCell = vec3(1.0); float hotCr = 0.0; bool hotDone = false;',
+        vertex: /* glsl */ `
+        {
+          vec3 r = (uHotRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+          vec3 q = HotNorm(r);
+          float cracked = hotCracked(q);
+          vec3 cell = hotCells(r);
+          float e = cell.y - cell.x;
+          // seams sink, plates swell a touch — relief that catches the light
+          float relief = -(1.0 - smoothstep(0.0, 0.12, e)) + 0.25 * smoothstep(0.12, 0.5, e);
+          transformed += normal * (relief * cracked * uHotDepth * 0.012 * uHotExtent);
+          vHotR = r;
+          vHotQ = q;
+        }`,
+        diffuse: /* glsl */ `
+        {
+          // computed once here, shared with the lighting pass below
+          hotCr = hotCracked(vHotQ);
+          hotCell = hotCells(vHotR);
+          hotDone = true;
+          float cracked = hotCr;
+          vec3 cell = hotCell;
+          float e = cell.y - cell.x;
+          // plates char from their edges inward as the heat soaks in
+          float soak = cracked * clamp(uHotProgress * 1.2, 0.0, 1.0);
+          float charEdge = 1.0 - smoothstep(0.0, 0.35 * soak + 0.05, e);
+          vec3 charred = vec3(0.06, 0.05, 0.045);
+          diffuseColor.rgb = mix(diffuseColor.rgb, charred, cracked * (0.35 + 0.6 * charEdge));
+        }`,
+        material: /* glsl */ `
+        {
+          float cracked = hotDone ? hotCr : hotCracked(vHotQ);
+          roughnessFactor = mix(roughnessFactor, 0.9, cracked);
+          metalnessFactor = mix(metalnessFactor, 0.0, cracked);
+        }`,
+        fragment: /* glsl */ `
+        {
+          if (!hotDone) { hotCr = hotCracked(vHotQ); hotCell = hotCells(vHotR); }
+          float cracked = hotCr;
+          vec3 cell = hotCell;
+          float e = cell.y - cell.x;
+          float cw = 0.05 + 0.04 * uHotProgress;                   // cracks widen as it heats
+          float crack = (1.0 - smoothstep(0.0, cw, e)) * cracked;
+          float breathe = 0.72 + 0.28 * sin(uHotTime * 1.1 + cell.z * 6.2832);
+          // a few whole plates run hot
+          float hotPlate = step(0.8, cell.z) * cracked * 0.35 * breathe;
+          float T = clamp(crack * breathe + hotPlate, 0.0, 1.0);
+          vec3 bb = mix(uHotHeat * vec3(0.35, 0.05, 0.0), uHotHeat, smoothstep(0.0, 0.6, T));
+          bb = mix(bb, vec3(1.0, 0.9, 0.65), smoothstep(0.75, 1.0, T));
+          float front = exp(-abs(HotThreshold() - HotField(vHotQ)) / 0.02) * step(0.0001, uHotProgress) * step(uHotProgress, 0.9999);
+          outgoingLight += bb * T * 3.0 + uHotHeat * front * 0.8;
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'heatCracks',
+    label: 'Heat cracks',
+    description: 'Crack the targets with glowing lava seams that sink into the surface and char it — reverting cools them',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        heat: { type: 'color', label: 'Heat', default: '#ff5a14' },
+        density: { type: 'number', label: 'Cracks', default: 9, min: 2, max: 40, step: 1, hint: 'Crack cells across the object' },
+        depth: { type: 'number', label: 'Crack depth', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        scale: { type: 'number', label: 'Front pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 3, 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;
+            const own = { field, heat: { value: new Color() }, density: { value: 9 }, depth: { value: 1 }, mats: new Set() };
+            // the glow keeps breathing while the object stays cracked
+            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;
+        setFieldParams(s.field, p, target, ctx);
+        s.heat.value.set(String(p.heat));
+        s.density.value = Number(p.density);
+        s.depth.value = Number(p.depth);
+        return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'power1.out', 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.in', clock: false,
+            onComplete: () => {
+                gsap.ticker.remove(s.tick);
+                s.mats.forEach(m => removeLayer(m, KEY));
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

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

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

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

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

package/dist/operations/catalogue/hologram.js

@@ -0,0 +1,118 @@
+// Hologram scan — a scan plane sweeps the target and turns the solid surface into
+// a hologram: glowing grid lines in the object's own space, a Fresnel rim and
+// drifting scanlines, everything else cut away (no transparency, so it sorts
+// cleanly). A second plane follows and switches the hologram off.
+// Reverting scans it back in: hologram first, then solid.
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { SWEEP_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+import { Color } from 'three';
+const P = 'Holo';
+const KEY = 'hologram';
+const STATE = '__opHologram';
+export default defineOperation({
+    value: 'hologram',
+    label: 'Hologram scan',
+    description: 'A scan plane turns the targets into a glowing hologram, then switches it off — reverting scans them back in',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
+    params: {
+        direction: { type: 'select', label: 'Scan', default: 'down', options: SWEEP_OPTIONS },
+        color: { type: 'color', label: 'Colour', default: '#3fd4ff' },
+        density: { type: 'number', label: 'Grid', default: 14, min: 2, max: 60, step: 1, hint: 'Grid lines across the object' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays as a hologram after the scan' },
+        hold: { type: 'number', label: 'Hologram band', default: 0.45, min: 0.1, max: 1, step: 0.05, hint: 'How much of the object is hologram at once' },
+        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);
+            st = { field, color: { value: new Color() }, density: { value: 14 }, gap: { value: 0.45 }, keep: { value: 0 }, mats: new Set() };
+            const own = st;
+            const layer = {
+                uniforms: { ...fieldUniforms(P, field), uHoloColor: st.color, uHoloDensity: st.density, uHoloGap: st.gap, uHoloKeep: st.keep },
+                common: `varying vec3 vHoloR;\nvarying vec3 vHoloView;\n${fieldGlsl(P)}`,
+                vertex: /* glsl */ `
+                vHoloR = (uHoloRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+                vHoloView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
+                fragment: /* glsl */ `
+                {
+                  vec3 q = HoloNorm(vHoloR);
+                  // scan coordinate: 0 where the scan starts, 1 where it ends
+                  float s = HoloAlong(q);
+                  float band = 0.02;
+                  float fa = mix(-band, 1.0 + uHoloGap + band, clamp(uHoloProgress, 0.0, 1.0)); // solid → hologram
+                  // hologram → gone (never, when the object should stay as a hologram)
+                  float fb = uHoloKeep > 0.5 ? -1.0 : fa - uHoloGap;
+                  if (s < fb) discard;
+                  if (s < fa) {
+                    // grid in root-local units, square cells, anti-aliased
+                    vec3 cell = vHoloR * (uHoloDensity / uHoloExtent);
+                    vec3 g = abs(fract(cell - 0.5) - 0.5) / max(fwidth(cell), vec3(1e-4));
+                    float line = 1.0 - clamp(min(min(g.x, g.y), g.z), 0.0, 1.0);
+                    // facing ratio from screen-space derivatives: works on lit and unlit materials
+                    vec3 nv = normalize(cross(dFdx(vHoloView), dFdy(vHoloView)));
+                    float fres = pow(1.0 - abs(dot(nv, normalize(-vHoloView))), 2.0);
+                    float scan = 0.5 + 0.5 * sin(vHoloR.y / uHoloExtent * 180.0 - uHoloTime * 5.0);
+                    float I = line * 0.9 + fres * 1.1 + scan * 0.12;
+                    // hot edges at both planes
+                    I += exp(-abs(s - fa) / 0.012) * 2.5 + exp(-abs(s - fb) / 0.01) * 1.5;
+                    if (I < 0.32) discard;
+                    outgoingLight = uHoloColor * I * 1.6;
+                  } else {
+                    // the solid side gets a faint pre-glow just ahead of the plane
+                    outgoingLight += uHoloColor * exp(-(s - fa) / 0.03) * 0.6;
+                  }
+                }`,
+            };
+            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, { direction: p.direction }, target, ctx);
+        s.color.value.set(String(p.color));
+        s.density.value = Number(p.density);
+        s.gap.value = Number(p.hold);
+        const keep = p.disappear === false;
+        s.keep.value = keep ? 1 : 0;
+        return runProgress(target, s.field, 1, {
+            duration: Number(p.duration), ease: 'power1.inOut', hold: keep,
+            onComplete: () => { if (!keep)
+                setMeshesHidden(target, true); },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        setMeshesHidden(target, false);
+        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]; },
+        });
+    },
+});
+function setMeshesHidden(target, hidden) {
+    target.traverse((c) => {
+        if (!c.isMesh || c.userData?.__opFxHelper)
+            return;
+        if (hidden) {
+            if (c.userData.__opHoloVis === undefined)
+                c.userData.__opHoloVis = c.visible;
+            c.visible = false;
+        }
+        else if (c.userData.__opHoloVis !== undefined) {
+            c.visible = c.userData.__opHoloVis;
+            delete c.userData.__opHoloVis;
+        }
+    });
+}

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

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

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

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