@3driseai/3drise-viewer 0.1.29 → 0.1.30

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"}

package/dist/operations/catalogue/portal.js

@@ -8,6 +8,9 @@
 //              photon ring and fine, faint spiral filaments inside — see-through
 //   tech       segmented arcs rotating both ways, tick marks and a scanning light
 // Reverting brings the object back out of the portal.
+// With Disappear off (an object effect's default) the ring opens around the object's
+// middle and stays, the object intact inside it with a soft band of light where the
+// ring's plane crosses it.
 import { AdditiveBlending, Color, Mesh, PlaneGeometry, Quaternion, ShaderMaterial, Vector3 } from 'three';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
@@ -21,16 +24,22 @@ const STYLES = ['electric', 'runes', 'horizon', 'tech'];
 const PAD = 1.35;
 function cutLayer(st) {
     return {
-        uniforms: { ...fieldUniforms(P, st.field), uPorColor: st.color },
+        uniforms: { ...fieldUniforms(P, st.field), uPorColor: st.color, uPorKeep: st.keep },
         common: `varying vec3 vPorQ;\n${fieldGlsl(P)}`,
         vertex: `vPorQ = PorNorm((uPorRootInv * modelMatrix * vec4(transformed, 1.0)).xyz);`,
         fragment: /* glsl */ `
         {
           float s = PorAlong(vPorQ);
-          float fs = mix(-0.04, 1.04, clamp(uPorProgress, 0.0, 1.0));
-          if (s < fs) discard;
-          float rim = exp(-(s - fs) / 0.012);
-          outgoingLight = mix(outgoingLight, uPorColor * 3.0, clamp(rim, 0.0, 1.0));
+          if (uPorKeep > 0.5) {
+            // inside the ring: a soft band of light where its plane crosses the object, breathing
+            float band = exp(-abs(s - 0.5) / 0.03) * (0.5 + 0.3 * sin(uPorTime * 1.7)) * smoothstep(0.0, 0.08, uPorProgress);
+            outgoingLight = mix(outgoingLight, uPorColor * 2.5, clamp(band, 0.0, 1.0));
+          } else {
+            float fs = mix(-0.04, 1.04, clamp(uPorProgress, 0.0, 1.0));
+            if (s < fs) discard;
+            float rim = exp(-(s - fs) / 0.012);
+            outgoingLight = mix(outgoingLight, uPorColor * 3.0, clamp(rim, 0.0, 1.0));
+          }
         }`,
     };
 }
@@ -122,12 +131,14 @@ function makeRingMaterial(st, style) {
 export default defineOperation({
     value: 'portal',
     label: 'Portal',
-    description: 'Sweep a ring of light through the targets and send them through it — reverting brings them back',
+    description: 'Sweep a ring of light through the targets and send them through it (or, Disappear off, keep the ring open around them) — reverting brings them back',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
     params: {
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the ring opens around the object and stays' },
         ring: { type: 'select', label: 'Ring', default: 'electric', options: [{ value: 'electric', label: 'Electric arcs' }, { value: 'runes', label: 'Rune ring' }, { value: 'horizon', label: 'Event horizon' }, { value: 'tech', label: 'Tech gate' }] },
         direction: { type: 'select', label: 'Sweep', default: 'down', options: SWEEP_OPTIONS },
         color: { type: 'color', label: 'Light', default: '#7a8cff' },
@@ -142,7 +153,7 @@ export default defineOperation({
         if (!st) {
             const field = createFieldState(target);
             const own = {
-                field, color: { value: new Color() }, style: '', mats: new Set(),
+                field, color: { value: new Color() }, style: '', mats: new Set(), keep: { value: 0 },
                 uni: { uStyle: { value: 0 }, uThick: { value: 1 }, uGlow: { value: 1 }, uSpin: { value: 1 }, uAlpha: { value: 0 } },
             };
             own.ring = new Mesh(new PlaneGeometry(2 * PAD, 2 * PAD), undefined);
@@ -183,7 +194,16 @@ export default defineOperation({
         s.radius = (0.55 * across + 0.04 * s.field.extent.value) * Number(p.size);
         s.ring.quaternion.copy(new Quaternion().setFromUnitVectors(new Vector3(0, 0, 1), d));
         s.ring.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        hideMeshes(target, KEY, false);
         placeRing(s);
+        if (s.keep.value) {
+            // keep: the ring opens around the middle and holds (its spin runs on the hold clock)
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration) * 0.3, ease: 'none', hold: true,
+                onUpdate: () => placeRing(s), onComplete: () => placeRing(s),
+            });
+        }
         return runProgress(target, s.field, 1, {
             duration: Number(p.duration), ease: 'power1.inOut',
             onUpdate: () => placeRing(s),
@@ -197,7 +217,7 @@ export default defineOperation({
         hideMeshes(target, KEY, false);
         s.ring.visible = true;
         return runProgress(target, s.field, 0, {
-            duration: Number(p.duration), ease: 'power1.inOut',
+            duration: Number(p.duration) * (s.keep.value ? 0.3 : 1) * Math.min(1, Math.max(0.1, s.field.progress.value)), ease: s.keep.value ? 'none' : 'power1.inOut',
             onUpdate: () => placeRing(s),
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));
@@ -212,13 +232,15 @@ export default defineOperation({
 /** Put the ring on the moving plane (root-local) and open / close it at the ends. */
 function placeRing(s) {
     const pr = Math.min(1, Math.max(0, s.field.progress.value));
-    const fs = -0.04 + 1.08 * pr;
+    const keep = s.keep.value > 0.5;
+    // keeping: the ring sits on the object's middle plane and never closes
+    const fs = keep ? 0.5 : -0.04 + 1.08 * pr;
     const d = sweepVector(s.field);
     const min = s.field.boundsMin.value, size = s.field.boundsSize.value;
     const c = min.clone().addScaledVector(size, 0.5);
     const half = (Math.abs(d.x) * size.x + Math.abs(d.y) * size.y + Math.abs(d.z) * size.z) / 2;
     s.ring.position.copy(c).addScaledVector(d, (fs - 0.5) * 2 * half);
-    const open = Math.max(0, Math.min(1, pr / 0.08, (1 - pr) / 0.08 + 0.001));
+    const open = Math.max(0, Math.min(1, pr / 0.08, keep ? 1 : (1 - pr) / 0.08 + 0.001));
     s.ring.scale.setScalar(s.radius * (0.2 + 0.8 * Math.sqrt(open)));
     s.uni.uAlpha.value = open;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"sandErosion.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/sandErosion.ts"],"names":[],"mappings":";AAyEA,wBAkGG"}
+{"version":3,"file":"sandErosion.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/sandErosion.ts"],"names":[],"mappings":";AAmFA,wBA8GG"}

package/dist/operations/catalogue/sandErosion.js

@@ -5,10 +5,12 @@
 // a cone-shaped mound around the base; grains that fell earlier lie lower, so the pile
 // really builds up. The pile stays while the effect is on; reverting sends every
 // grain back up to its exact spot and the surface closes.
+// With Disappear off (an object effect's default) the whole object turns to sand and
+// stays: a crust of grains that shimmers, with a faint wind ripple drifting across.
 import { Color } from 'three';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
-import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, } from './transitionField.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, setReveal, } from './transitionField.js';
 import { sampleSurfaceCached } from './surfaceSample.js';
 import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
 const P = 'Snd';
@@ -31,16 +33,19 @@ float fxHash1(vec3 p) { return fract(sin(dot(p, vec3(127.1, 311.7, 74.7))) * 437
  * the crumble front eats it away with a per-grain jitter, so the edge breaks
  * up into grains instead of a smooth line — darker right at the breaking lip.
  */
-function sandLayer(field, sand, tint) {
+function sandLayer(field, sand, tint, keep) {
     const crust = /* glsl */ `
       float f = SndField(vSndQ);
       float crust = smoothstep(0.0, 0.1, SndThreshold() - f);
-      float pc = clamp(uSndProgress - ${LAG}, 0.0, 1.0);
+      // painting the object in: nothing ahead of the front, full crust right behind it
+      if (uSndReveal > 0.5) { if (SndThreshold() - f < 0.0) discard; crust = 1.0; }
+      // keep: the crust never crumbles
+      float pc = clamp(uSndProgress - ${LAG}, 0.0, 1.0) * (1.0 - uSndKeep);
       float tc = pc * (1.0 + 2.0 * uSndEdgeWidth) - uSndEdgeWidth;
       float jit = (fxHash1(floor(vSndR / uSndExtent * ${GRAIN_CELLS.toFixed(1)})) - 0.5) * 0.06;
       float d = f + jit - tc;`;
     return {
-        uniforms: { ...fieldUniforms(P, field), uSndSand: sand, uSndTint: tint },
+        uniforms: { ...fieldUniforms(P, field), uSndSand: sand, uSndTint: tint, uSndKeep: keep },
         common: `varying vec3 vSndQ;\nvarying vec3 vSndR;\n${fieldGlsl(P)}\n${HASH1}`,
         vertex: /* glsl */ `
         vSndR = (uSndRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
@@ -51,6 +56,11 @@ function sandLayer(field, sand, tint) {
           if (d < 0.0) discard;
           float g = fxHash1(floor(vSndR / uSndExtent * ${GRAIN_CELLS.toFixed(1)} * 2.3));
           vec3 sandC = mix(uSndSand, diffuseColor.rgb, uSndTint) * (0.8 + 0.3 * g);
+          // holding as sand: grains shimmer, a faint wind ripple drifts across
+          float held = uSndKeep * step(0.9999, uSndProgress);
+          float shimmer = 0.5 + 0.5 * sin(uSndTime * (1.5 + 4.0 * g) + g * 60.0);
+          float ripple = sin((vSndR.x + vSndR.z * 0.4) / uSndExtent * 26.0 - uSndTime * 2.2 + fxNoise(vSndR / uSndExtent * 6.0) * 3.0);
+          sandC *= 1.0 + held * (0.08 * shimmer * step(0.85, g) + 0.05 * ripple);
           diffuseColor.rgb = mix(diffuseColor.rgb, sandC, crust);
           // the breaking lip is darker, like damp sand under the fall
           diffuseColor.rgb *= 1.0 - 0.45 * (1.0 - smoothstep(0.0, 0.05, d)) * step(0.0001, pc);
@@ -66,17 +76,20 @@ function sandLayer(field, sand, tint) {
 export default defineOperation({
     value: 'sandErosion',
     label: 'Sand erosion',
-    description: 'Crumble the targets into grains that pour down into a mound — reverting pours them back up',
+    description: 'Crumble the targets into grains that pour down into a mound (or, Disappear off, turn them to sand and keep them) — reverting pours them back up',
     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: 'down', options: DIRECTION_OPTIONS },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object turns to sand and stays' },
         grains: { type: 'number', label: 'Grains', default: 45000, min: 5000, max: 150000, step: 1000 },
         grainSize: { type: 'number', label: 'Grain size', default: 1, min: 0.3, max: 4, step: 0.1, unit: '×' },
-        pile: { type: 'number', label: 'Mound height', default: 1, min: 0, max: 3, step: 0.05, unit: '×' },
-        spread: { type: 'number', label: 'Mound width', default: 1, min: 0.3, max: 3, step: 0.05, unit: '×' },
+        pile: { type: 'number', label: 'Mound height', default: 1, min: 0, max: 3, step: 0.05, unit: '×', showWhen: { disappear: ['true'] } },
+        spread: { type: 'number', label: 'Mound width', default: 1, min: 0.3, max: 3, step: 0.05, unit: '×', showWhen: { disappear: ['true'] } },
         sand: { type: 'color', label: 'Sand', default: '#d8b98a' },
         tint: { type: 'number', label: 'Object colour', default: 0.35, min: 0, max: 1, step: 0.05, hint: 'How much of the object’s own colour the sand keeps' },
         scale: { type: 'number', label: 'Grain pattern', default: 3, min: 0.5, max: 12, step: 0.1 },
@@ -87,11 +100,11 @@ export default defineOperation({
         if (!st) {
             const field = createFieldState(target);
             field.edgeWidth.value = 0.05;
-            const life = { value: LIFE }, pile = { value: 1 }, spread = { value: 1 }, grain = { value: 1 }, sand = { value: new Color() }, tint = { value: 0.35 };
+            const life = { value: LIFE }, pile = { value: 1 }, spread = { value: 1 }, grain = { value: 1 }, sand = { value: new Color() }, tint = { value: 0.35 }, keep = { value: 0 };
             const sample = sampleSurfaceCached(target, Math.round(Number(p.grains)), 21);
             const points = createFxPoints(target, sample, {
                 additive: false,
-                uniforms: { ...fieldUniforms(P, field), uSndLife: life, uSndPile: pile, uSndSpread: spread, uSndGrain: grain, uSndSand: sand, uSndTint: tint },
+                uniforms: { ...fieldUniforms(P, field), uSndLife: life, uSndPile: pile, uSndSpread: spread, uSndGrain: grain, uSndSand: sand, uSndTint: tint, uSndKeep: keep },
                 vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE + HASH1,
                 vertexMain: /* glsl */ `
                   float f = ${P}Field(${P}Norm(aP));
@@ -99,7 +112,7 @@ export default defineOperation({
                   float jit = (fxHash1(floor(aP / uSndExtent * ${GRAIN_CELLS.toFixed(1)})) - 0.5) * 0.06;
                   float birth = ${LAG} + ${P}BirthOf(f + jit);
                   float a = (uSndProgress - birth) / uSndLife;
-                  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; }
+                  if (a <= 0.0 || uSndKeep > 0.5) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; vColor = vec3(0.0); vAlpha = 0.0; return; }
                   a = min(a, 1.0);
                   float E = uSndExtent;
                   vec3 C = u${P}Min + u${P}Size * 0.5;
@@ -126,10 +139,10 @@ export default defineOperation({
                   vAlpha = 1.0;
                   gl_PointSize = clamp(fxPointPx(E * 0.0032 * uSndGrain * (0.7 + 0.6 * aR.w), mv), 1.0, 10.0);`,
             });
-            st = { field, life, pile, spread, grain, sand, points, mats: new Set() };
+            st = { field, life, pile, spread, grain, sand, keep, points, mats: new Set() };
             st.tint = tint;
             const own = st;
-            const layer = sandLayer(field, sand, tint);
+            const layer = sandLayer(field, sand, tint, keep);
             forEachMeshMaterial(target, (mat, mesh) => {
                 if (mesh.userData?.__opFxHelper)
                     return;
@@ -145,6 +158,13 @@ export default defineOperation({
         s.grain.value = Number(p.grainSize);
         s.sand.value.set(String(p.sand));
         s.tint.value = Number(p.tint);
+        s.keep.value = p.disappear === false ? 1 : 0;
+        if (s.keep.value) {
+            // keep: the crust spreads over the whole object (0 → 1) and holds
+            hideMeshes(target, KEY, false);
+            return runProgress(target, s.field, 1, { duration: Number(p.duration) / END, ease: 'none', hold: true });
+        }
+        hideMeshes(target, KEY, false);
         return runProgress(target, s.field, END, {
             duration: Number(p.duration), ease: 'none',
             onComplete: () => hideMeshes(target, KEY, true),
@@ -155,8 +175,10 @@ export default defineOperation({
         if (!s)
             return;
         hideMeshes(target, KEY, false);
+        setReveal(s.field, p);
+        // 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 / END)), ease: 'none',
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));
                 disposeFxPoints(s.points);

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

@@ -1 +1 @@
-{"version":3,"file":"teleport.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/teleport.ts"],"names":[],"mappings":";AA2HA,wBAgGG"}
+{"version":3,"file":"teleport.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/teleport.ts"],"names":[],"mappings":";AAyIA,wBAiHG"}

package/dist/operations/catalogue/teleport.js

@@ -5,10 +5,13 @@
 // column of light: a soft core that is brightest face-on, fine streaks flowing
 // upward, and thin rings of light climbing it. Reverting materialises the
 // object back down the beam.
+// With Disappear off (an object effect's default) the object stays "charged": hot
+// white at the top fading to its own colour below, the beam standing over it with
+// particles cycling up it, nothing leaving.
 import { AdditiveBlending, Color, CylinderGeometry, Mesh, ShaderMaterial } 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, } from './transitionField.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, setReveal, } from './transitionField.js';
 import { sampleSurfaceCached } from './surfaceSample.js';
 import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
 import { hideUntilWarm } from './warmup.js';
@@ -21,14 +24,14 @@ const END = 1 + LIFE * 1.6;
 const SING = `(u${P}Min + u${P}Size * vec3(0.5, 1.0, 0.5) + vec3(0.0, 0.18 * u${P}Extent, 0.0))`;
 function surface(st) {
     return {
-        uniforms: { ...fieldUniforms(P, st.field), uTelLife: st.life, uTelGlow: st.glow },
+        uniforms: { ...fieldUniforms(P, st.field), uTelLife: st.life, uTelGlow: st.glow, uTelKeep: st.keep },
         common: `varying float vTelK;\nvarying vec3 vTelQ;\n${fieldGlsl(P)}\n${GLSL_ROT}`,
         vertex: /* glsl */ `
         {
           mat4 toRoot = uTelRootInv * modelMatrix;
           vec3 rl = (toRoot * vec4(transformed, 1.0)).xyz;
           float birth = TelBirthOf(TelField(TelNorm(rl)));
-          float k = clamp((uTelProgress - birth) / uTelLife, 0.0, 1.0);
+          float k = clamp((uTelProgress - birth) / uTelLife, 0.0, 1.0) * (1.0 - uTelKeep);
           k = k * k * (3.0 - 2.0 * k);
           vTelK = k;
           vTelQ = TelNorm(rl);
@@ -41,10 +44,21 @@ function surface(st) {
         }`,
         fragment: /* glsl */ `
         {
-          float cut = 0.1 + 0.35 * fxFbm(vTelQ * 7.0);
-          if (vTelK > cut) discard;
-          float h = smoothstep(0.0, cut, vTelK);
-          outgoingLight = mix(outgoingLight, uTelGlow * (1.5 + 3.5 * h), h);
+          if (uTelKeep > 0.5) {
+            // charged: heat climbs the object — white-hot at the top, its own colour below — and flickers
+            float TelD = TelField(vTelQ) - TelThreshold();
+            float charged = smoothstep(0.0, uTelEdgeWidth, -TelD);
+            // painting the object in: nothing ahead of the front, fully charged right behind it
+            if (uTelReveal > 0.5) { if (TelD > 0.0) discard; charged = 1.0; }
+            float heat = pow(clamp(vTelQ.y, 0.0, 1.0), 2.6) * (0.85 + 0.15 * sin(uTelTime * 5.0 + fxFbm(vTelQ * 6.0 + uTelTime * 0.4) * 12.0));
+            vec3 hot = mix(uTelGlow * 0.9, vec3(2.0), heat) * (0.5 + 1.5 * heat);
+            outgoingLight = mix(outgoingLight, hot, charged * (0.12 + 0.88 * heat));
+          } else {
+            float cut = 0.1 + 0.35 * fxFbm(vTelQ * 7.0);
+            if (vTelK > cut) discard;
+            float h = smoothstep(0.0, cut, vTelK);
+            outgoingLight = mix(outgoingLight, uTelGlow * (1.5 + 3.5 * h), h);
+          }
         }`,
     };
 }
@@ -114,13 +128,16 @@ function updateColumn(s) {
 export default defineOperation({
     value: 'teleport',
     label: 'Teleport',
-    description: 'Draw the targets into a point of light and send them up a beam — reverting brings them back down',
+    description: 'Draw the targets into a point of light and send them up a beam (or, Disappear off, keep them charged under the beam) — reverting brings them back down',
     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: 'down', options: DIRECTION_OPTIONS },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays charged under the beam' },
         color: { type: 'color', label: 'Light', default: '#a8ecff' },
         sparks: { type: 'number', label: 'Particles', default: 9000, min: 1000, max: 60000, step: 1000 },
         beam: { type: 'number', label: 'Beam height', default: 3, min: 0.5, max: 10, step: 0.1, unit: '×' },
@@ -133,15 +150,17 @@ export default defineOperation({
         if (!st) {
             const field = createFieldState(target);
             field.edgeWidth.value = 0.1;
-            const own = { field, life: { value: LIFE }, glow: { value: new Color() }, beam: { value: 3 }, width: { value: 1 }, mats: new Set() };
+            const own = { field, life: { value: LIFE }, glow: { value: new Color() }, beam: { value: 3 }, width: { value: 1 }, keep: { value: 0 }, mats: new Set() };
             const sample = sampleSurfaceCached(target, Math.round(Number(p.sparks)), 23);
             own.points = createFxPoints(target, sample, {
                 additive: true,
-                uniforms: { ...fieldUniforms(P, field), uTelLife: own.life, uTelGlow: own.glow, uTelBeam: own.beam, uTelWidth: own.width },
+                uniforms: { ...fieldUniforms(P, field), uTelLife: own.life, uTelGlow: own.glow, uTelBeam: own.beam, uTelWidth: own.width, uTelKeep: own.keep },
                 vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE + GLSL_ROT,
                 vertexMain: /* glsl */ `
                   float birth = TelBirthOf(TelField(TelNorm(aP)));
                   float a = (uTelProgress - birth) / (uTelLife * 1.6);
+                  // keep: once charged, a particle cycles up the beam over and over
+                  if (uTelKeep > 0.5) a = uTelProgress > birth ? 0.5 + 0.5 * fract(u${P}Time * 0.2 + aR.w) : 0.0;
                   if (a <= 0.0 || a >= 1.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 = uTelExtent;
                   vec3 S = ${SING};
@@ -184,7 +203,17 @@ export default defineOperation({
         s.beam.value = Number(p.beam);
         s.width.value = Number(p.width);
         s.points.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        hideMeshes(target, KEY, false);
         updateColumn(s);
+        if (s.keep.value) {
+            // keep: the charge climbs the object (0 → 1), the beam stands, and it holds
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration) / END, ease: 'none', hold: true,
+                onUpdate: () => updateColumn(s),
+                onComplete: () => updateColumn(s),
+            });
+        }
         return runProgress(target, s.field, END, {
             duration: Number(p.duration), ease: 'power1.in',
             onUpdate: () => updateColumn(s),
@@ -196,9 +225,11 @@ export default defineOperation({
         if (!s)
             return;
         hideMeshes(target, KEY, false);
+        setReveal(s.field, p);
         s.points.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: 'power1.out',
+            duration: Number(p.duration) * Math.min(1, Math.max(0.1, s.field.progress.value / END)), ease: s.keep.value ? 'none' : 'power1.out',
             onUpdate: () => updateColumn(s),
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));

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

@@ -1 +1 @@
-{"version":3,"file":"unweave.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/unweave.ts"],"names":[],"mappings":";AA2EA,wBA+IG"}
+{"version":3,"file":"unweave.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/unweave.ts"],"names":[],"mappings":";AA+EA,wBAgKG"}