@3driseai/3drise-viewer 0.1.29 → 0.1.31

package/dist/operations/catalogue/flock.js

@@ -4,6 +4,8 @@
 // streams — out and up, or all toward one side of the screen — accelerating
 // until they are gone. Birds always face the way they fly, so on revert they
 // fly back in (head first) and settle into place as the surface re-forms.
+// With Disappear off (an object effect's default) the birds stay perched on every
+// spot of the surface (the surface itself gone): a flutter now and then, heads turning.
 import { BufferAttribute, BufferGeometry, Vector3 } from 'three';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
@@ -36,17 +38,19 @@ function birdGeometry() {
 export default defineOperation({
     value: 'flock',
     label: 'Flock',
-    description: 'Turn the targets into a flock of birds that takes off and flies away — reverting flies them home',
+    description: 'Turn the targets into a flock of birds that takes off and flies away (or, Disappear off, stays perched) — reverting flies them home',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
     params: {
         direction: { type: 'select', label: 'Take-off order', default: 'down', options: DIRECTION_OPTIONS },
-        exit: { type: 'select', label: 'Fly', default: 'away', options: [{ value: 'away', label: 'Out and up' }, { value: 'left', label: 'To the right' }, { value: 'right', label: 'To the left' }, { value: 'up', label: 'Straight up' }] },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the birds stay perched on the object' },
+        exit: { type: 'select', label: 'Fly', default: 'away', showWhen: { disappear: ['true'] }, options: [{ value: 'away', label: 'Out and up' }, { value: 'left', label: 'To the right' }, { value: 'right', label: 'To the left' }, { value: 'up', label: 'Straight up' }] },
         birds: { type: 'number', label: 'Birds', default: 1400, min: 100, max: 12000, step: 100 },
         birdSize: { type: 'number', label: 'Bird size', default: 1, min: 0.3, max: 4, step: 0.05, unit: '×' },
-        speed: { type: 'number', label: 'Speed', default: 1, min: 0.2, max: 4, step: 0.05, unit: '×' },
+        speed: { type: 'number', label: 'Speed', default: 1, min: 0.2, max: 4, step: 0.05, unit: '×', showWhen: { disappear: ['true'] } },
         edgeColor: { type: 'color', label: 'Edge colour', default: '#ffffff' },
         scale: { type: 'number', label: 'Pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
         duration: { type: 'number', label: 'Duration', default: 3.4, min: 0.3, max: 14, step: 0.1, unit: 's' },
@@ -57,7 +61,7 @@ export default defineOperation({
             const field = createFieldState(target);
             field.edgeWidth.value = 0.04;
             const own = {
-                field, exit: { value: new Vector3(1, 0, 0) }, mode: { value: 0 }, speed: { value: 1 }, dirSign: { value: 1 }, bird: { value: 1 }, mats: new Set(),
+                field, exit: { value: new Vector3(1, 0, 0) }, mode: { value: 0 }, speed: { value: 1 }, dirSign: { value: 1 }, bird: { value: 1 }, keep: { value: 0 }, mats: new Set(),
             };
             const sample = sampleSurfaceCached(target, Math.round(Number(p.birds)), 53);
             const n = sample.count;
@@ -68,7 +72,7 @@ export default defineOperation({
                 attributes: { aFlkP: [pos, 3], aFlkN: [sample.normal.slice(0, n * 3), 3], aFlkR: [sample.random.slice(0, n * 4), 4] },
                 layerKey: 'flockInstances', roughness: 0.65, metalness: 0, doubleSided: true,
                 layer: {
-                    uniforms: { ...fieldUniforms(P, field), uFlkExit: own.exit, uFlkMode: own.mode, uFlkSpeed: own.speed, uFlkDirSign: own.dirSign, uFlkBird: own.bird },
+                    uniforms: { ...fieldUniforms(P, field), uFlkExit: own.exit, uFlkMode: own.mode, uFlkSpeed: own.speed, uFlkDirSign: own.dirSign, uFlkBird: own.bird, uFlkKeep: own.keep },
                     common: fieldGlsl(P),
                     vertexPars: /* glsl */ `
                     attribute float aWing; attribute vec3 aFlkP; attribute vec3 aFlkN; attribute vec4 aFlkR;
@@ -98,12 +102,33 @@ export default defineOperation({
                       vec3 right = normalize(cross(fwd, vec3(0.0, 1.0, 0.0)) + vec3(1e-4));
                       vec3 up = cross(right, fwd);
                       return mat3(right, up, fwd);
-                    }`,
-                    normal: `{ objectNormal = flkFrame(clamp(flkAge(), 0.0, 1.0)) * objectNormal; }`,
+                    }
+                    // perched: sitting on its spot, up along the surface normal, turning its head now and then
+                    mat3 flkPerch() {
+                      vec3 up = normalize(aFlkN + vec3(1e-4));
+                      vec3 any = abs(up.y) < 0.9 ? vec3(0.0, 1.0, 0.0) : vec3(1.0, 0.0, 0.0);
+                      vec3 right0 = normalize(cross(up, any));
+                      float yaw = aFlkR.z * 6.2832 + step(0.6, aFlkR.y) * 0.35 * sin(uFlkTime * (0.4 + 0.5 * aFlkR.w) + aFlkR.x * 30.0);
+                      vec3 right = right0 * cos(yaw) + cross(up, right0) * sin(yaw);
+                      vec3 fwd = cross(right, up);
+                      return mat3(right, up, fwd);
+                    }
+                    float flkHeld() { return uFlkKeep * step(0.9999, uFlkProgress); }`,
+                    normal: `{ objectNormal = (uFlkKeep > 0.5 ? flkPerch() : flkFrame(clamp(flkAge(), 0.0, 1.0))) * objectNormal; }`,
                     vertex: /* glsl */ `
                     {
                       float a = flkAge();
                       if (a <= 0.0) { transformed *= 0.0; }
+                      else if (uFlkKeep > 0.5) {
+                        // perched on its spot; a brief flutter now and then
+                        vec3 v = transformed;
+                        float flutter = smoothstep(0.93, 1.0, sin(uFlkTime * (0.5 + 0.4 * aFlkR.x) + aFlkR.z * 60.0)) * flkHeld();
+                        v.y += abs(aWing) * sin(uFlkTime * 22.0 + aFlkR.y * 6.28) * 0.38 * flutter;
+                        v.y += abs(aWing) * 0.12;                       // wings held slightly up at rest
+                        float size = uFlkExtent * 0.03 * uFlkBird * (0.8 + 0.4 * aFlkR.w);
+                        float sc = smoothstep(0.0, 0.06, a);
+                        transformed = flkPerch() * (v * size * sc) + aFlkN * uFlkExtent * 0.008;
+                      }
                       else {
                         a = min(a, 1.0);
                         vec3 v = transformed;
@@ -139,6 +164,15 @@ export default defineOperation({
             s.exit.value.copy(p.exit === 'left' ? r : r.negate());
         }
         s.mesh.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        if (s.keep.value) {
+            // keep: the surface becomes birds (0 → 1), perched, and holds
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration) / (1 + LIFE), ease: 'none', hold: true,
+                onComplete: () => hideMeshes(target, KEY, true),
+            });
+        }
+        hideMeshes(target, KEY, false);
         return runProgress(target, s.field, 1 + LIFE, {
             duration: Number(p.duration), ease: 'power1.in',
             onComplete: () => { hideMeshes(target, KEY, true); s.mesh.visible = false; },
@@ -151,8 +185,9 @@ export default defineOperation({
         hideMeshes(target, KEY, false);
         s.mesh.visible = true;
         s.dirSign.value = -1;
+        // 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), ease: 'power1.out',
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / (1 + LIFE))), ease: s.keep.value ? 'none' : 'power1.out',
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));
                 disposeFxInstances(s.mesh);

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

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

package/dist/operations/catalogue/inkBloom.js

@@ -4,10 +4,12 @@
 // so the ink reads as clean curling threads that fray, sink and thin out, not
 // as soft blobs. Normal blending (dark on light), so it works on light scenes.
 // Reverting draws the ink back into the object.
+// With Disappear off (an object effect's default) the object stays stained with ink,
+// filaments hanging in the water around it, swaying but never thinning out.
 import { BufferAttribute, BufferGeometry, LineSegments, NormalBlending, ShaderMaterial } from 'three';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer, uniformDecl } from './shaderLayers.js';
-import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, surfaceLayer, } from './transitionField.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, setReveal, surfaceLayer, } from './transitionField.js';
 import { sampleSurfaceCached } from './surfaceSample.js';
 import { hideUntilWarm } from './warmup.js';
 const P = 'Ink';
@@ -16,6 +18,28 @@ const STATE = '__opInk';
 const LIFE = 0.9;
 /** Points per filament (its trail through the water). */
 const TRAIL = 12;
+/** Keep: a wisp hangs this far along its path. */
+const KEEP_AGE = 0.35;
+/** The surface: stained along the front and gone behind it — or, keeping, stained all over and staying. */
+function inkLayer(field, mixC, keep) {
+    const base = surfaceLayer(P, field, 'stain');
+    return {
+        ...base,
+        uniforms: { ...base.uniforms, uInkMix: mixC, uInkKeep: keep },
+        fragment: /* glsl */ `
+        if (uInkKeep > 0.5) {
+          float InkD = InkField(vInkQ) - InkThreshold();
+          float stained = smoothstep(0.0, uInkEdgeWidth, -InkD);
+          // painting the object in: nothing ahead of the front, full ink right behind it
+          if (uInkReveal > 0.5) { if (InkD > 0.0) discard; stained = 1.0; }
+          // ink: a slow swirl of slightly lighter ink moving through it
+          float swirl = 0.8 + 0.4 * fxNoise(vInkQ * 5.0 + vec3(uInkTime * 0.12, -uInkTime * 0.08, 0.0));
+          vec3 ink = mix(uInkEdgeColor, outgoingLight, uInkMix) * swirl;
+          outgoingLight = mix(outgoingLight, ink, stained);
+        } else {${base.fragment}
+        }`,
+    };
+}
 function buildFilaments(target, count) {
     const s = sampleSurfaceCached(target, count, 29);
     const segs = TRAIL - 1;
@@ -45,18 +69,21 @@ function buildFilaments(target, count) {
 export default defineOperation({
     value: 'inkBloom',
     label: 'Ink bloom',
-    description: 'Bleed the targets into fine curling ink filaments, like a drop in water — reverting draws the ink back in',
+    description: 'Bleed the targets into fine curling ink filaments, like a drop in water (or, Disappear off, keep them inked) — reverting draws the ink back in',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
+    presence: 'paint',
     params: {
         direction: { type: 'select', label: 'Direction', default: 'noise', options: DIRECTION_OPTIONS },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays inked, filaments hanging around it' },
         edgeColor: { type: 'color', label: 'Ink colour', default: '#16203a' },
         tint: { type: 'number', label: 'Object colour', default: 0.15, min: 0, max: 1, step: 0.05, hint: 'How much of the object’s own colour the ink keeps' },
         filaments: { type: 'number', label: 'Filaments', default: 9000, min: 1000, max: 40000, step: 500 },
         opacity: { type: 'number', label: 'Density', default: 0.55, min: 0.05, max: 1, step: 0.05 },
-        sink: { type: 'number', label: 'Sink', default: 1, min: -2, max: 3, step: 0.05, unit: '×', hint: 'Negative rises like smoke' },
+        sink: { type: 'number', label: 'Sink', default: 1, min: -2, max: 3, step: 0.05, unit: '×', hint: 'Negative rises like smoke', showWhen: { disappear: ['true'] } },
         scale: { type: 'number', label: 'Pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
         duration: { type: 'number', label: 'Duration', default: 3.6, min: 0.3, max: 14, step: 0.1, unit: 's' },
     },
@@ -65,8 +92,8 @@ export default defineOperation({
         if (!st) {
             const field = createFieldState(target);
             field.edgeWidth.value = 0.12;
-            const mixC = { value: 0.15 }, sink = { value: 1 }, opacity = { value: 0.55 };
-            const uniforms = { ...fieldUniforms(P, field), uInkMix: mixC, uInkSink: sink, uInkOpacity: opacity };
+            const mixC = { value: 0.15 }, sink = { value: 1 }, opacity = { value: 0.55 }, keep = { value: 0 };
+            const uniforms = { ...fieldUniforms(P, field), uInkMix: mixC, uInkSink: sink, uInkOpacity: opacity, uInkKeep: keep };
             const decl = Object.keys(uniforms).map(n => uniformDecl(n, uniforms[n].value)).join('\n');
             const mat = new ShaderMaterial({
                 uniforms: uniforms,
@@ -88,6 +115,8 @@ vec3 inkAt(vec3 p0, vec3 n0, vec4 r, float a) {
 void main() {
   float birth = InkBirthOf(InkField(InkNorm(position)));
   float a = (uInkProgress - birth) / ${LIFE.toFixed(2)};
+  // keep: the wisp hangs part-way along its path, swaying along it
+  a = mix(a, min(a, ${KEEP_AGE} * (0.92 + 0.08 * sin(uInkTime * 0.7 + aR.w * 6.2832))), uInkKeep);
   // the trail: this vertex sits a little back along the wisp's own path
   float trail = 0.22 * (0.6 + 0.8 * aR.w);
   float ak = clamp(a - aK * trail, 0.0, 1.0);
@@ -114,9 +143,9 @@ void main() {
             lines.renderOrder = 10;
             target.add(lines);
             hideUntilWarm(lines);
-            st = { field, mixC, sink, opacity, lines, mats: new Set() };
+            st = { field, mixC, sink, opacity, keep, lines, mats: new Set() };
             const own = st;
-            const layer = surfaceLayer(P, field, 'stain');
+            const layer = inkLayer(field, mixC, keep);
             forEachMeshMaterial(target, (m, mesh) => {
                 if (mesh.userData?.__opFxHelper)
                     return;
@@ -131,6 +160,12 @@ void main() {
         s.sink.value = Number(p.sink);
         s.opacity.value = Number(p.opacity);
         s.lines.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        hideMeshes(target, KEY, false);
+        if (s.keep.value) {
+            // keep: the ink spreads over the whole object (0 → 1) and holds
+            return runProgress(target, s.field, 1, { duration: Number(p.duration) / (1 + LIFE), ease: 'none', hold: true });
+        }
         return runProgress(target, s.field, 1 + LIFE, {
             duration: Number(p.duration), ease: 'none',
             onComplete: () => { hideMeshes(target, KEY, true); s.lines.visible = false; },
@@ -141,9 +176,11 @@ void main() {
         if (!s)
             return;
         hideMeshes(target, KEY, false);
+        setReveal(s.field, p);
         s.lines.visible = true;
+        // 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), ease: 'none',
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / (1 + LIFE))), ease: 'none',
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));
                 s.lines.removeFromParent();

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

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

package/dist/operations/catalogue/liquidMetal.js

@@ -2,6 +2,9 @@
 // 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.
+// With Disappear off (an object effect's default) the object turns to chrome and
+// stays, unmelted: the studio reflection turns slowly, a soft ripple runs over it.
+// The chrome comes in along a front (Direction) so it can paint the object in.
 //
 // 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
@@ -11,22 +14,25 @@ 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';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams, setReveal, syncRoot } from './transitionField.js';
 const P = 'Liq';
 const KEY = 'liquidMetal';
 const STATE = '__opLiquid';
+/** The chrome comes in over this much of the progress; the melt runs after it. */
+const CHROME = 0.2;
 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)}`,
+        uniforms: { ...fieldUniforms(P, st.field), uLiqTint: st.tint, uLiqSpread: st.spread, uLiqKeep: st.keep },
+        common: `varying float vLiqM;\nvarying vec3 vLiqView;\nvarying vec3 vLiqQ;\n${fieldGlsl(P)}`,
         vertex: /* glsl */ `
         {
           mat4 toRoot = uLiqRootInv * modelMatrix;
           vec3 rl = (toRoot * vec4(transformed, 1.0)).xyz;
           vec3 q = LiqNorm(rl);
+          vLiqQ = q;
           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);
+          // melt runs after the chrome has come in; the top gives way first (never in keep)
+          float mp = clamp((uLiqProgress - 0.18) / 0.82, 0.0, 1.0) * (1.0 - uLiqKeep);
           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
@@ -48,7 +54,13 @@ function layerFor(st) {
         }`,
         fragment: /* glsl */ `
         {
-          float chrome = smoothstep(0.0, 0.2, uLiqProgress);
+          // the chrome comes in along a front over the first part of the progress
+          float tc = clamp(uLiqProgress / ${CHROME}, 0.0, 1.0) * (1.0 + 2.0 * uLiqEdgeWidth) - uLiqEdgeWidth;
+          float d = LiqField(vLiqQ) - tc;
+          float chrome = smoothstep(0.0, 0.08, -d);
+          // painting the object in: nothing ahead of the front, full chrome right behind it
+          if (uLiqReveal > 0.5) { if (d > 0.0) discard; chrome = 1.0; }
+          float held = uLiqKeep * step(0.9999, 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)));
@@ -56,8 +68,12 @@ function layerFor(st) {
             vec3 n = nv;
           #endif
           vec3 v = normalize(vLiqView);
+          // holding as chrome: a soft ripple runs over the surface, the studio turns slowly
+          n = normalize(n + held * 0.04 * vec3(sin(vLiqQ.y * 22.0 - uLiqTime * 1.6), 0.0, cos(vLiqQ.x * 19.0 - uLiqTime * 1.3)));
           vec3 rv = reflect(v, n);
           vec3 rw = normalize((vec4(rv, 0.0) * viewMatrix).xyz);   // view → world direction
+          float ra = held * uLiqTime * 0.25;
+          rw = vec3(rw.x * cos(ra) - rw.z * sin(ra), rw.y, rw.x * sin(ra) + rw.z * cos(ra));
           // 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));
@@ -66,6 +82,8 @@ function layerFor(st) {
           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;
+          // a bright lip right at the front
+          metal *= 1.0 + 1.5 * (1.0 - smoothstep(0.0, 0.05, abs(d))) * step(0.0001, uLiqProgress) * step(uLiqProgress, ${CHROME} - 0.0001);
           outgoingLight = mix(outgoingLight, metal, chrome);
         }`,
     };
@@ -73,21 +91,26 @@ function layerFor(st) {
 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',
+    description: 'Turn the targets to chrome and melt them into a rippling pool (or, Disappear off, keep them as chrome) — reverting pulls them back into shape',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
+    presence: 'paint',
     params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS, hint: 'How the chrome comes in' },
         tint: { type: 'color', label: 'Metal', default: '#dfe7ee' },
-        spread: { type: 'number', label: 'Pool size', default: 1, min: 0.2, max: 3, step: 0.05, unit: '×' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object turns to chrome and stays' },
+        spread: { type: 'number', label: 'Pool size', default: 1, min: 0.2, max: 3, step: 0.05, unit: '×', showWhen: { disappear: ['true'] } },
         duration: { type: 'number', label: 'Duration', default: 3.4, min: 0.3, max: 12, step: 0.1, unit: 's' },
     },
-    apply(target, p) {
+    apply(target, p, ctx) {
         let st = target.userData[STATE];
         if (!st) {
             const field = createFieldState(target);
-            const own = { field, tint: { value: new Color() }, spread: { value: 1 }, mats: new Set() };
+            field.edgeWidth.value = 0.04;
+            const own = { field, tint: { value: new Color() }, spread: { value: 1 }, keep: { value: 0 }, 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);
@@ -102,16 +125,22 @@ export default defineOperation({
             target.userData[STATE] = st;
         }
         const s = st;
+        setFieldParams(s.field, p, target, ctx);
         s.tint.value.set(String(p.tint));
         s.spread.value = Number(p.spread);
+        s.keep.value = p.disappear === false ? 1 : 0;
+        // keep: only the chrome comes in (the melt is off), then it holds — its own ticker keeps the time running
+        if (s.keep.value)
+            return runProgress(target, s.field, 1, { duration: Number(p.duration) * CHROME * 1.5, ease: 'none', clock: false });
         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;
+        setReveal(s.field, p);
         return runProgress(target, s.field, 0, {
-            duration: Number(p.duration), ease: 'power1.inOut', clock: false,
+            duration: Number(p.duration) * (s.keep.value ? CHROME * 1.5 : 1) * Math.min(1, Math.max(0.1, s.field.progress.value)), ease: s.keep.value ? 'none' : 'power1.inOut', clock: false,
             onComplete: () => {
                 gsap.ticker.remove(s.tick);
                 s.mats.forEach(m => removeLayer(m, KEY));

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

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

package/dist/operations/catalogue/particleSwarm.js

@@ -4,6 +4,8 @@
 // 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.
+// With Disappear off (an object effect's default) the object stays as a particle
+// cloud in its own shape: every particle on its spot, twinkling and breathing.
 import { gsap } from 'gsap';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
@@ -18,17 +20,19 @@ 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',
+    description: 'Break the targets into their own coloured particles that swirl around them (or, Disappear off, stay as a particle cloud) — reverting reassembles',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
     params: {
         direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays as a cloud of particles in its own shape' },
         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: '×' },
+        spread: { type: 'number', label: 'Spread', default: 1, min: 0.3, max: 3, step: 0.05, unit: '×', hint: 'Radius of the vortex', showWhen: { disappear: ['true'] } },
+        speed: { type: 'number', label: 'Swirl speed', default: 1, min: 0, max: 4, step: 0.05, unit: '×', showWhen: { disappear: ['true'] } },
         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' },
@@ -39,16 +43,19 @@ export default defineOperation({
             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 flight = { value: FLIGHT }, spread = { value: 1 }, speed = { value: 1 }, size = { value: 1 }, keep = { value: 0 };
             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 },
+                uniforms: { ...fieldUniforms(P, field), uSwmFlight: flight, uSwmSpread: spread, uSwmSpeed: speed, uSwmPtSize: size, uSwmKeep: keep },
                 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; }
+                  // keep: the particle appears on its spot and stays there
+                  float held = uSwmKeep * step(0.9999, uSwmProgress);
+                  a = mix(a, min(a, 0.001), uSwmKeep);
                   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.
@@ -71,19 +78,22 @@ export default defineOperation({
                   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);
+                  // holding as a cloud: particles jitter on their spots, the whole cloud breathes
+                  local += held * (aN * E * 0.004 * sin(u${P}Time * (2.0 + 2.0 * aR.w) + aR.z * 40.0));
+                  local = C + (local - C) * (1.0 + held * 0.012 * sin(u${P}Time * 0.9));
                   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);
+                  vAlpha = mix(smoothstep(0.0, 0.08, a), 0.75 + 0.25 * sin(u${P}Time * (3.0 + 4.0 * aR.x) + aR.y * 50.0), uSwmKeep);
                   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 });
+            Object.assign(own, { field, flight, spread, speed, size, keep, points, mats: new Set(), tick });
             st = own;
             const layer = surfaceLayer(P, field, 'tint');
             forEachMeshMaterial(target, (mat, mesh) => {
@@ -100,6 +110,15 @@ export default defineOperation({
         s.spread.value = Number(p.spread);
         s.speed.value = Number(p.speed);
         s.size.value = Number(p.particleSize);
+        s.keep.value = p.disappear === false ? 1 : 0;
+        setMeshesHidden(target, false);
+        if (s.keep.value) {
+            // keep: the surface becomes its particles (0 → 1) and holds — its own ticker keeps the time running
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration) / (1 + FLIGHT), ease: 'none', clock: false,
+                onComplete: () => setMeshesHidden(target, true),
+            });
+        }
         return runProgress(target, s.field, 1 + FLIGHT, {
             duration: Number(p.duration), ease: 'power1.inOut', clock: false,
             onComplete: () => setMeshesHidden(target, true),
@@ -110,8 +129,9 @@ export default defineOperation({
         if (!s)
             return;
         setMeshesHidden(target, 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), ease: 'power1.inOut', clock: false,
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / (1 + FLIGHT))), ease: s.keep.value ? 'none' : 'power1.inOut', clock: false,
             onComplete: () => {
                 gsap.ticker.remove(s.tick);
                 s.mats.forEach(m => removeLayer(m, KEY));

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

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

package/dist/operations/catalogue/petalPeel.js

@@ -4,6 +4,8 @@
 // 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.
+// With Disappear off (an object effect's default) the object stays "lifted": every
+// flake hinged up off the surface like raised scales, breathing in slow waves.
 import { CircleGeometry } from 'three';
 import { defineOperation } from '../types.js';
 import { GLSL_ROT, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
@@ -17,16 +19,18 @@ 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',
+    description: 'Peel the targets into flakes that flutter down like leaves (or, Disappear off, stay lifted like raised scales) — reverting lifts them back',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
     params: {
         direction: { type: 'select', label: 'Direction', default: 'down', options: DIRECTION_OPTIONS },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the flakes stay lifted off the surface, like raised scales' },
         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' },
+        drift: { type: 'number', label: 'Drift', default: 1, min: 0, max: 4, step: 0.05, unit: '×', hint: 'How far they sway and scatter', showWhen: { disappear: ['true'] } },
         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' },
@@ -36,7 +40,7 @@ export default defineOperation({
         if (!st) {
             const field = createFieldState(target);
             field.edgeWidth.value = 0.04;
-            const life = { value: LIFE }, drift = { value: 1 };
+            const life = { value: LIFE }, drift = { value: 1 }, keep = { value: 0 };
             const count = Math.round(Number(p.petals));
             const sample = sampleSurfaceCached(target, count, 47);
             // petal size from the surface area each one has to cover
@@ -54,7 +58,7 @@ export default defineOperation({
                 },
                 layerKey: 'petalInstances', roughness: 0.7, metalness: 0, doubleSided: true,
                 layer: {
-                    uniforms: { ...fieldUniforms(P, field), uPdlLife: life, uPdlDrift: drift },
+                    uniforms: { ...fieldUniforms(P, field), uPdlLife: life, uPdlDrift: drift, uPdlKeep: keep },
                     common: fieldGlsl(P) + GLSL_ROT,
                     vertexPars: /* glsl */ `
                     attribute vec3 aPdlP; attribute vec3 aPdlN; attribute vec4 aPdlR;
@@ -78,12 +82,22 @@ export default defineOperation({
                       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; }`,
+                    }
+                    // lifted (keep): hinged up off the surface, breathing in slow waves across the object
+                    float pdlLift(float a) {
+                      float held = uPdlKeep * step(0.9999, uPdlProgress);
+                      float wave = sin(uPdlTime * 1.1 + dot(aPdlP, vec3(1.0, 0.6, 0.3)) / uPdlExtent * 7.0 + aPdlR.x * 0.8);
+                      return smoothstep(0.0, 0.14, a) * (0.5 + held * 0.14 * wave);
+                    }
+                    mat3 pdlLifted(float a) { return pdlFrame() * fxRot(vec3(1.0, 0.0, 0.0), pdlLift(a)); }`,
+                    normal: `{ objectNormal = (uPdlKeep > 0.5 ? pdlLifted(pdlAge()) : pdlRot(pdlAge())) * objectNormal; }`,
                     vertex: /* glsl */ `
                     {
                       float a = pdlAge();
                       if (a <= 0.0) { transformed *= 0.0; }
+                      else if (uPdlKeep > 0.5) {
+                        transformed = pdlLifted(a) * transformed + aPdlN * (0.012 * uPdlExtent) * smoothstep(0.0, 0.14, a);
+                      }
                       else {
                         a = min(a, 1.0);
                         float E = uPdlExtent;
@@ -101,7 +115,7 @@ export default defineOperation({
                     }`,
                 },
             });
-            st = { field, life, drift, mesh, mats: new Set() };
+            st = { field, life, drift, keep, mesh, mats: new Set() };
             const own = st;
             const layer = surfaceLayer(P, field, 'tint');
             forEachMeshMaterial(target, (mat, m) => {
@@ -115,6 +129,15 @@ export default defineOperation({
         const s = st;
         setFieldParams(s.field, p, target, ctx);
         s.drift.value = Number(p.drift);
+        s.keep.value = p.disappear === false ? 1 : 0;
+        hideMeshes(target, KEY, false);
+        if (s.keep.value) {
+            // keep: the surface lifts into flakes (0 → 1) and holds
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration) / (1 + LIFE), ease: 'none', hold: true,
+                onComplete: () => hideMeshes(target, KEY, true),
+            });
+        }
         return runProgress(target, s.field, 1 + LIFE, {
             duration: Number(p.duration), ease: 'none',
             onComplete: () => hideMeshes(target, KEY, true),
@@ -125,8 +148,9 @@ export default defineOperation({
         if (!s)
             return;
         hideMeshes(target, KEY, 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), ease: 'none',
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / (1 + LIFE))), ease: 'none',
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));
                 disposeFxInstances(s.mesh);

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

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