@3driseai/3drise-viewer 0.1.26 → 0.1.28

package/dist/operations/catalogue/metalize.js

@@ -0,0 +1,135 @@
+// Metalize — the object turns to metal, the way a pour of molten metal would
+// coat it: a bright molten front sweeps over the surface (white-hot at the lip,
+// cooling to orange), a liquid ripple settles just behind it, and what it leaves
+// is polished metal. Presets for gold, silver, chrome, copper, bronze, rose gold,
+// anodised titanium (thin-film iridescence) and gunmetal, or a custom tint;
+// polish blurs the reflection from mirror to brushed.
+//
+// The reflection is the same procedural studio environment as Liquid metal, so
+// the metal reads in any scene, with or without an environment map.
+// A state, not an exit: it stays metal while on; reverting melts it back off.
+import { Color } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+const P = 'Mtl';
+const KEY = 'metalize';
+const STATE = '__opMetalize';
+/** Metal base colours (linear-ish F0 tints). Titanium is special-cased (iridescent). */
+const METALS = {
+    gold: '#ffc766', silver: '#e8ecf0', chrome: '#dfe6ee', copper: '#f0936a', bronze: '#c8955a',
+    roseGold: '#f2b0a0', titanium: '#b8bfc8', gunmetal: '#5c6068',
+};
+const DEFAULT_CUSTOM = '#9fd0ff';
+function layerFor(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uMtlTint: st.tint, uMtlRough: st.rough, uMtlIrid: st.irid, uMtlLip: st.lip, uMtlCool: st.cool },
+        common: `varying vec3 vMtlQ;\nvarying vec3 vMtlR;\nvarying vec3 vMtlView;\n${fieldGlsl(P)}`,
+        vertex: /* glsl */ `
+        vMtlR = (uMtlRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vMtlQ = MtlNorm(vMtlR);
+        vMtlView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
+        fragment: /* glsl */ `
+        {
+          float d = MtlThreshold() - MtlField(vMtlQ);          // > 0 behind the front
+          float m = smoothstep(0.0, uMtlEdgeWidth, d);
+          if (m > 0.0 || d > -0.05) {
+            vec3 nv = normalize(cross(dFdx(vMtlView), dFdy(vMtlView)));
+            #if defined( STANDARD ) || defined( PHONG ) || defined( LAMBERT ) || defined( TOON )
+              vec3 n = normalize(normal);
+            #else
+              vec3 n = nv;
+            #endif
+            // liquid settling just behind the front: a fading ripple in the normal
+            float wet = 1.0 - smoothstep(0.0, 0.18, d);
+            vec3 rp = vMtlR / uMtlExtent * 40.0;
+            n = normalize(n + wet * m * 0.25 * vec3(sin(rp.x + d * 60.0), 0.0, cos(rp.z + d * 60.0)));
+            vec3 v = normalize(vMtlView);
+            vec3 rw = normalize((vec4(reflect(v, n), 0.0) * viewMatrix).xyz);
+            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))));
+            // polish: rough metal sees a blurred, flatter studio
+            env = mix(env, vec3(0.55, 0.57, 0.6), uMtlRough * 0.85);
+            float ndv = abs(dot(n, -v));
+            vec3 tint = uMtlTint;
+            // anodised titanium: thin-film interference, hue shifts with the viewing angle
+            vec3 film = 0.5 + 0.5 * cos(6.2832 * (ndv * 1.4 + vec3(0.0, 0.33, 0.67) + 0.15));
+            tint = mix(tint, film * 0.9 + 0.1, uMtlIrid);
+            float fres = 0.7 + 0.3 * pow(1.0 - ndv, 4.0);
+            vec3 metal = tint * env * fres;
+            outgoingLight = mix(outgoingLight, metal, m);
+            // the molten lip: white-hot at the edge, cooling to orange just behind
+            float lip = exp(-abs(d) / 0.012) * step(0.0001, uMtlProgress) * step(uMtlProgress, 0.9999);
+            float cooling = exp(-max(d, 0.0) / 0.05) * m * step(uMtlProgress, 0.9999);
+            outgoingLight += uMtlLip * lip * 2.2 + uMtlCool * cooling * 0.9;
+          }
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'metalize',
+    label: 'Metalize',
+    description: 'Pour molten metal over the targets and leave them polished gold, chrome, copper… — reverting melts it off',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    stack: 'surface',
+    params: {
+        metal: {
+            type: 'select', label: 'Metal', default: 'gold',
+            options: [
+                { value: 'gold', label: 'Gold' }, { value: 'silver', label: 'Silver' }, { value: 'chrome', label: 'Chrome' },
+                { value: 'copper', label: 'Copper' }, { value: 'bronze', label: 'Bronze' }, { value: 'roseGold', label: 'Rose gold' },
+                { value: 'titanium', label: 'Anodised titanium' }, { value: 'gunmetal', label: 'Gunmetal' }, { value: 'custom', label: 'Custom colour' },
+            ],
+        },
+        color: { type: 'color', label: 'Custom colour', default: DEFAULT_CUSTOM, hint: 'Pick a colour to tint the metal (overrides the preset)' },
+        lipColor: { type: 'color', label: 'Molten edge', default: '#ffd9a6', hint: 'Colour of the pouring front' },
+        coolColor: { type: 'color', label: 'Cooling glow', default: '#ff6a1a', hint: 'Glow just behind the front as it cools' },
+        polish: { type: 'number', label: 'Polish', default: 0.85, min: 0, max: 1, step: 0.01, hint: '1 = mirror, 0 = brushed' },
+        direction: { type: 'select', label: 'Pour direction', default: 'down', options: DIRECTION_OPTIONS },
+        scale: { type: 'number', label: 'Front pattern', default: 2, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 2.2, 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, tint: { value: new Color() }, rough: { value: 0.15 }, irid: { value: 0 }, lip: { value: new Color() }, cool: { value: new Color() }, 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);
+        // a colour the user picked always wins (choosing "Custom colour" is not required)
+        const metal = String(p.metal);
+        const custom = metal === 'custom' || String(p.color).toLowerCase() !== DEFAULT_CUSTOM;
+        s.tint.value.set(custom ? String(p.color) : (METALS[metal] ?? METALS.gold));
+        s.irid.value = metal === 'titanium' && !custom ? 0.85 : 0;
+        s.lip.value.set(String(p.lipColor));
+        s.cool.value.set(String(p.coolColor));
+        s.rough.value = 1 - Number(p.polish);
+        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/moveToFront.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"moveToFront.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/moveToFront.ts"],"names":[],"mappings":";AAEA,wBAuBG"}
+{"version":3,"file":"moveToFront.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/moveToFront.ts"],"names":[],"mappings":";AAEA,wBAwBG"}

package/dist/operations/catalogue/moveToFront.js

@@ -3,6 +3,7 @@ export default defineOperation({
     value: 'moveToFront',
     label: 'Bring to front',
     description: 'Bring the target in front of the camera',
+    channel: 'transform',
     multi: false,
     toggles: true,
     usableIn: ['interaction', 'action'],

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

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

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

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

package/dist/operations/catalogue/orbit.js

@@ -0,0 +1,29 @@
+// Orbit — the camera circles the target at its current distance and height,
+// turning to face it on the way in. A full circle ends where it started;
+// reverting (actions) flies back to where the camera was.
+import { Box3, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+export default defineOperation({
+    value: 'orbit',
+    label: 'Orbit',
+    description: 'Circle the camera around the target, keeping its distance and height',
+    channel: 'camera',
+    multi: false,
+    toggles: false,
+    usableIn: ['interaction', 'action'],
+    exclusive: { group: 'camera', release: 'handover' },
+    params: {
+        angle: { type: 'number', label: 'Angle', default: 360, min: 15, max: 720, step: 15, unit: '°', hint: '360 ends where it started' },
+        reverse: { type: 'boolean', label: 'Clockwise', default: false },
+        duration: { type: 'number', label: 'Duration', default: 6, min: 0.5, max: 60, step: 0.5, unit: 's' },
+    },
+    apply(target, p, ctx) {
+        ctx.saveCameraHome();
+        const c = new Box3().setFromObject(target).getCenter(new Vector3());
+        const deg = Number(p.angle) * (p.reverse ? -1 : 1);
+        void ctx.tools.orbitCamera([c.x, c.y, c.z], deg, Number(p.duration), 'power1.inOut');
+    },
+    revert(_target, p, ctx) {
+        ctx.restoreCameraHome(Math.min(1.5, Number(p.duration)), 'power2.inOut');
+    },
+});

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

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

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

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

package/dist/operations/catalogue/particleSwarm.js

@@ -0,0 +1,138 @@
+// Particle swarm — the target comes apart into its own surface, particle by
+// particle (each carries the colour of the spot it left), and the particles
+// sweep up into a slow vortex around the object's centre with differential
+// rotation (inner rings faster, like a disc). While it is on, the swarm keeps
+// turning. Reverting pulls every particle back to its exact spot and the
+// surface closes behind them.
+import { gsap } from 'gsap';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams, surfaceLayer, syncRoot, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
+const P = 'Swm';
+const KEY = 'particleSwarm';
+const STATE = '__opSwarm';
+/** Flight length in progress units: the tween runs 0 → 1 + FLIGHT. */
+const FLIGHT = 0.5;
+export default defineOperation({
+    value: 'particleSwarm',
+    label: 'Particle swarm',
+    description: 'Break the targets into their own coloured particles that swirl around them — reverting reassembles',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        particles: { type: 'number', label: 'Particles', default: 30000, min: 2000, max: 120000, step: 1000 },
+        particleSize: { type: 'number', label: 'Particle size', default: 1, min: 0.2, max: 4, step: 0.1, unit: '×' },
+        spread: { type: 'number', label: 'Spread', default: 1, min: 0.3, max: 3, step: 0.05, unit: '×', hint: 'Radius of the vortex' },
+        speed: { type: 'number', label: 'Swirl speed', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        edgeColor: { type: 'color', label: 'Edge colour', default: '#9fe8ff' },
+        glow: { type: 'boolean', label: 'Glow', default: true, hint: 'Additive light — off keeps the true surface colours' },
+        duration: { type: 'number', label: 'Duration', default: 2.8, 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;
+            field.scale.value = 2.5;
+            const flight = { value: FLIGHT }, spread = { value: 1 }, speed = { value: 1 }, size = { value: 1 };
+            const sample = sampleSurfaceCached(target, Math.round(Number(p.particles)), 11);
+            const points = createFxPoints(target, sample, {
+                additive: !!p.glow,
+                uniforms: { ...fieldUniforms(P, field), uSwmFlight: flight, uSwmSpread: spread, uSwmSpeed: speed, uSwmPtSize: size },
+                vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE,
+                vertexMain: /* glsl */ `
+                  float birth = ${P}BirthOf(${P}Field(${P}Norm(aP)));
+                  float a = clamp((uSwmProgress - birth) / uSwmFlight, 0.0, 1.0);
+                  if (a <= 0.0) { 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 = uSwmExtent;
+                  vec3 C = u${P}Min + u${P}Size * 0.5;
+                  // destination: a tilted two-arm spiral galaxy around the object's centre.
+                  // The arm pattern turns as one (so it never winds up); each particle adds a small
+                  // differential drift, and the disc is lens-shaped: thick at the core, thin at the rim.
+                  float R = 0.5 * max(u${P}Size.x, u${P}Size.z) * uSwmSpread + 0.15 * E;
+                  float rn = 0.18 + 0.9 * pow(aR.x, 0.75);
+                  float r = R * rn;
+                  float arm = step(0.5, aR.z) * 3.14159;
+                  float scatter = (aR.y + aR.w - 1.0) * (0.35 + 0.5 * rn);
+                  float th = arm + 2.2 * log(rn + 0.15) + scatter
+                           + uSwmSpeed * (0.35 * u${P}Time + 0.12 * u${P}Time / (0.3 + rn));
+                  float h = (aR.y + fract(aR.w * 7.13) - 1.0) * 0.16 * E * (1.0 - 0.7 * rn);
+                  vec3 disc = vec3(cos(th) * r, h, sin(th) * r);
+                  // ~20° tilt so the spiral reads from a side view
+                  float ct = 0.94, stl = 0.34;
+                  disc = vec3(disc.x, disc.y * ct - disc.z * stl, disc.y * stl + disc.z * ct);
+                  vec3 D = C + disc;
+                  // quadratic Bézier: lift off along the normal, then into the slot
+                  vec3 ctrl = aP + aN * (0.25 * E) + vec3(0.0, 0.12 * E, 0.0);
+                  float k = a * a * (3.0 - 2.0 * a);
+                  vec3 local = mix(mix(aP, ctrl, k), mix(ctrl, D, k), k);
+                  vec4 mv = modelViewMatrix * vec4(local, 1.0);
+                  gl_Position = projectionMatrix * mv;
+                  // the colour of the spot it left, brighter in flight, a slow shimmer in the vortex
+                  float flightGlow = sin(3.14159 * a);
+                  float shimmer = 0.85 + 0.15 * sin(u${P}Time * (1.0 + 2.0 * aR.w) + aR.z * 6.2832);
+                  vColor = aC * (1.0 + 0.4 * flightGlow) * shimmer + u${P}EdgeColor * 0.25 * flightGlow * flightGlow;
+                  vAlpha = smoothstep(0.0, 0.08, a);
+                  gl_PointSize = clamp(fxPointPx(E * 0.0045 * uSwmPtSize * (0.6 + 0.8 * aR.w), mv), 0.0, 20.0);`,
+            });
+            const own = {};
+            // while the swarm exists it keeps turning, even after the transition finished
+            const tick = () => { own.field.time.value += gsap.ticker.deltaRatio() / 60; syncRoot(target, own.field); };
+            Object.assign(own, { field, flight, spread, speed, size, points, mats: new Set(), tick });
+            st = own;
+            const layer = surfaceLayer(P, field, 'tint');
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            gsap.ticker.add(tick);
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.spread.value = Number(p.spread);
+        s.speed.value = Number(p.speed);
+        s.size.value = Number(p.particleSize);
+        return runProgress(target, s.field, 1 + FLIGHT, {
+            duration: Number(p.duration), ease: 'power1.inOut', clock: false,
+            onComplete: () => 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', clock: false,
+            onComplete: () => {
+                gsap.ticker.remove(s.tick);
+                s.mats.forEach(m => removeLayer(m, KEY));
+                disposeFxPoints(s.points);
+                delete target.userData[STATE];
+            },
+        });
+    },
+});
+function setMeshesHidden(target, hidden) {
+    target.traverse((c) => {
+        if (!c.isMesh || c.userData?.__opFxHelper)
+            return;
+        if (hidden) {
+            if (c.userData.__opSwmVis === undefined)
+                c.userData.__opSwmVis = c.visible;
+            c.visible = false;
+        }
+        else if (c.userData.__opSwmVis !== undefined) {
+            c.visible = c.userData.__opSwmVis;
+            delete c.userData.__opSwmVis;
+        }
+    });
+}

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

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

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

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

package/dist/operations/catalogue/petalPeel.js

@@ -0,0 +1,137 @@
+// Petal peel — the surface lifts off in thin flakes, each carrying the colour of
+// the spot it came from: a flake first hinges up off the surface, then flutters
+// down the way a leaf does — slow terminal-velocity fall, side-to-side sway and
+// rocking tumble — and settles flat on the ground around the base. The flakes
+// are real lit, double-sided instances (one instanced mesh, casting shadows).
+// Reverting lifts them back into place and the surface closes.
+import { CircleGeometry } from 'three';
+import { defineOperation } from '../types.js';
+import { GLSL_ROT, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, surfaceLayer, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { createFxInstances, disposeFxInstances } from './fxInstances.js';
+const P = 'Pdl';
+const KEY = 'petalPeel';
+const STATE = '__opPetal';
+const LIFE = 0.8;
+export default defineOperation({
+    value: 'petalPeel',
+    label: 'Petal peel',
+    description: 'Peel the targets into flakes that flutter down like leaves — reverting lifts them back',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'down', options: DIRECTION_OPTIONS },
+        petals: { type: 'number', label: 'Petals', default: 2600, min: 300, max: 20000, step: 100 },
+        petalSize: { type: 'number', label: 'Petal size', default: 1, min: 0.3, max: 4, step: 0.05, unit: '×' },
+        drift: { type: 'number', label: 'Drift', default: 1, min: 0, max: 4, step: 0.05, unit: '×', hint: 'How far they sway and scatter' },
+        edgeColor: { type: 'color', label: 'Edge colour', default: '#fff1d6' },
+        scale: { type: 'number', label: 'Pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 4, min: 0.3, max: 14, 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;
+            const life = { value: LIFE }, drift = { value: 1 };
+            const count = Math.round(Number(p.petals));
+            const sample = sampleSurfaceCached(target, count, 47);
+            // petal size from the surface area each one has to cover
+            const E = field.extent.value;
+            const size = E * 0.034 * Number(p.petalSize) * Math.sqrt(2600 / Math.max(300, count));
+            const geo = new CircleGeometry(0.5, 10);
+            geo.scale(size, size * 0.62, size);
+            const mesh = createFxInstances(target, {
+                geometry: geo,
+                count: sample.count, positions: sample.position.slice(0, sample.count * 3), colors: sample.color.slice(0, sample.count * 3),
+                attributes: {
+                    aPdlP: [sample.position.slice(0, sample.count * 3), 3],
+                    aPdlN: [sample.normal.slice(0, sample.count * 3), 3],
+                    aPdlR: [sample.random.slice(0, sample.count * 4), 4],
+                },
+                layerKey: 'petalInstances', roughness: 0.7, metalness: 0, doubleSided: true,
+                layer: {
+                    uniforms: { ...fieldUniforms(P, field), uPdlLife: life, uPdlDrift: drift },
+                    common: fieldGlsl(P) + GLSL_ROT,
+                    vertexPars: /* glsl */ `
+                    attribute vec3 aPdlP; attribute vec3 aPdlN; attribute vec4 aPdlR;
+                    // frame that lays the flake (XY plane) on the surface, facing out
+                    mat3 pdlFrame() {
+                      vec3 n = normalize(aPdlN + vec3(1e-4));
+                      vec3 t = normalize(cross(abs(n.y) < 0.95 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0), n));
+                      vec3 b = cross(n, t);
+                      return mat3(t, b, n);
+                    }
+                    float pdlAge() { return (uPdlProgress - PdlBirthOf(PdlField(PdlNorm(aPdlP)))) / uPdlLife; }
+                    // landing time (in age units) for a flake falling from its height at a steady speed
+                    float pdlLand() { return 0.14 + 0.8 * clamp((aPdlP.y - uPdlMin.y) / max(uPdlSize.y, 1e-4), 0.0, 1.0); }
+                    mat3 pdlRot(float a) {
+                      float land = pdlLand();
+                      float af = min(a, land);
+                      float hinge = smoothstep(0.0, 0.14, a) * 1.1;               // peel up off the surface
+                      float tumble = max(af - 0.14, 0.0) * (4.0 + 5.0 * aPdlR.w) + sin(af * 14.0 + aPdlR.x * 6.28) * 0.6;
+                      mat3 inAir = pdlFrame() * fxRot(vec3(1.0, 0.0, 0.0), hinge) * fxRot(normalize(aPdlR.xyz - 0.5 + vec3(1e-3)), tumble);
+                      // after landing: lie flat, turned at random
+                      mat3 lying = fxRot(vec3(0.0, 1.0, 0.0), aPdlR.y * 6.28) * mat3(1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0);
+                      float settle = smoothstep(land, land + 0.06, a);
+                      return mat3(mix(inAir[0], lying[0], settle), mix(inAir[1], lying[1], settle), mix(inAir[2], lying[2], settle));
+                    }`,
+                    normal: `{ objectNormal = pdlRot(pdlAge()) * objectNormal; }`,
+                    vertex: /* glsl */ `
+                    {
+                      float a = pdlAge();
+                      if (a <= 0.0) { transformed *= 0.0; }
+                      else {
+                        a = min(a, 1.0);
+                        float E = uPdlExtent;
+                        float land = pdlLand();
+                        float af = min(a, land);
+                        float fall = max(af - 0.14, 0.0) / max(land - 0.14, 1e-3);    // 0 → 1 while airborne
+                        vec3 C = uPdlMin + uPdlSize * 0.5;
+                        vec2 away = normalize(aPdlP.xz - C.xz + (aPdlR.xy - 0.5) * 0.3 + vec2(1e-4));
+                        float sway = sin(af * 11.0 + aPdlR.z * 6.28) * 0.07 * E * uPdlDrift * fall;
+                        vec3 off = aPdlN * (0.03 * E) * smoothstep(0.0, 0.14, a);
+                        off.xz += away * (0.06 + 0.14 * aPdlR.x) * E * uPdlDrift * fall + vec2(sway, sway * 0.6);
+                        off.y += (uPdlMin.y + 0.002 * E * (1.0 + aPdlR.w) - aPdlP.y) * fall;
+                        transformed = pdlRot(a) * transformed + off;
+                      }
+                    }`,
+                },
+            });
+            st = { field, life, drift, mesh, mats: new Set() };
+            const own = st;
+            const layer = surfaceLayer(P, field, 'tint');
+            forEachMeshMaterial(target, (mat, m) => {
+                if (m.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.drift.value = Number(p.drift);
+        return runProgress(target, s.field, 1 + LIFE, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => hideMeshes(target, KEY, true),
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                disposeFxInstances(s.mesh);
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

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

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

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

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

package/dist/operations/catalogue/petrify.js

@@ -0,0 +1,94 @@
+// Petrify — the object turns to weathered stone along the front, like a statue:
+// the base colour becomes granite (grain, speckle, darker crevices from low-
+// frequency noise, a trace of the original colour's value kept so the texture
+// still reads), and roughness goes to stone — all BEFORE lighting, so the scene
+// lights it as stone. A fine grey line marks the spreading front. A state, not
+// an exit: it stays stone while on; reverting brings it back to life.
+import { Color } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+const P = 'Stn';
+const KEY = 'petrify';
+const STATE = '__opPetrify';
+function layerFor(st) {
+    const amount = /* glsl */ `
+      float stnD = StnThreshold() - StnField(vStnQ);
+      float st = smoothstep(0.0, uStnEdgeWidth, stnD);`;
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uStnStone: st.stone },
+        common: `varying vec3 vStnQ;\nvarying vec3 vStnR;\n${fieldGlsl(P)}`,
+        vertex: /* glsl */ `
+        vStnR = (uStnRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vStnQ = StnNorm(vStnR);`,
+        diffuse: /* glsl */ `
+        {
+          ${amount}
+          vec3 p = vStnR / uStnExtent;
+          float grain = fxFbm(p * 26.0);
+          float speck = step(0.83, fxNoise(p * 140.0)) * 0.35 - step(0.9, fxNoise(p * 90.0 + 7.0)) * 0.25;
+          float crevice = smoothstep(0.25, 0.75, fxFbm(p * 5.0));
+          float luma = dot(diffuseColor.rgb, vec3(0.299, 0.587, 0.114));
+          vec3 stone = uStnStone * (0.62 + 0.55 * grain + speck) * mix(0.6, 1.1, crevice) * (0.75 + 0.5 * luma);
+          diffuseColor.rgb = mix(diffuseColor.rgb, stone, st);
+        }`,
+        material: /* glsl */ `
+        {
+          ${amount}
+          roughnessFactor = mix(roughnessFactor, 0.93, st);
+          metalnessFactor = mix(metalnessFactor, 0.0, st);
+        }`,
+        fragment: /* glsl */ `
+        {
+          ${amount}
+          float line = exp(-abs(stnD) / 0.01) * step(0.0001, uStnProgress) * step(uStnProgress, 0.9999);
+          outgoingLight = mix(outgoingLight, outgoingLight * 0.35, line * 0.8);
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'petrify',
+    label: 'Petrify',
+    description: 'Turn the targets to weathered stone, like a statue — reverting brings them back',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    stack: 'surface',
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        stone: { type: 'color', label: 'Stone', default: '#9a948c' },
+        scale: { type: 'number', label: 'Front pattern', default: 3, 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.035;
+            st = { field, stone: { value: new Color() }, 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.stone.value.set(String(p.stone));
+        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/portal.d.ts

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

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

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