@3driseai/3drise-viewer 0.1.29 → 0.1.31

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

package/dist/operations/catalogue/unweave.js

@@ -6,7 +6,8 @@
 //        of light beyond the object on that side (left/right: screen, at trigger)
 //   random   every thread segment flies off on its own heading and fades
 //   scale    the whole thread sculpture expands outward, keeping its shape, and fades
-// With dispersing off, the object simply stays as a woven thread sculpture.
+// With Disappear off (an object effect's default) the object stays as a woven thread
+// sculpture and holds: light pulses run along the rings, threads shimmer.
 // Reverting weaves the object back together.
 import { AdditiveBlending, BufferAttribute, BufferGeometry, Color, LineSegments, Matrix4, ShaderMaterial, Vector3 } from 'three';
 import { defineOperation } from '../types.js';
@@ -19,6 +20,8 @@ const KEY = 'unweave';
 const STATE = '__opUnweave';
 const MAX_TRIS = 300_000;
 const MAX_SEGMENTS = 200_000;
+/** The threads run on past the surface (0 → 1) to 1.6 while dispersing. */
+const END = 1.6;
 const MODES = ['up', 'down', 'left', 'right', 'random', 'scale'];
 /** Slice every mesh of the target with `levels` horizontal planes (root space). */
 function contourSegments(target, levels) {
@@ -76,17 +79,19 @@ function contourSegments(target, levels) {
 export default defineOperation({
     value: 'unweave',
     label: 'Unweave',
-    description: 'Re-draw the targets as glowing threads that unravel into a point of light — reverting weaves them back',
+    description: 'Re-draw the targets as glowing threads that unravel into a point of light (or, Disappear off, stay as a thread sculpture) — reverting weaves them back',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
+    // no presence: with Disappear off the look decorates the object (it appears, then is re-drawn); on, it is the entrance / exit
     params: {
         color: { type: 'color', label: 'Thread', default: '#ffcf7a' },
         threads: { type: 'number', label: 'Threads', default: 56, min: 8, max: 200, step: 1, hint: 'Contour lines from bottom to top' },
-        disperse: { type: 'boolean', label: 'Disperse', default: true, hint: 'Off: the object stays as a thread sculpture' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays as a glowing thread sculpture' },
         mode: {
-            type: 'select', label: 'Dispersal', default: 'up',
+            type: 'select', label: 'Dispersal', default: 'up', showWhen: { disappear: ['true'] },
             options: [
                 { value: 'up', label: 'Unravel upward' }, { value: 'down', label: 'Unravel downward' },
                 { value: 'left', label: 'Unravel left → right' }, { value: 'right', label: 'Unravel right → left' },
@@ -114,7 +119,7 @@ export default defineOperation({
                 uniforms: uniforms,
                 vertexShader: `${decl}
 attribute float aUnwLevel; attribute float aUnwAng; attribute float aUnwRand;
-varying float vUnwA; varying float vUnwU;
+varying float vUnwA; varying float vUnwU; varying float vUnwL; varying float vUnwR;
 ${fieldGlsl(P)}
 ${GLSL_ROT}
 void main() {
@@ -136,6 +141,7 @@ void main() {
   float u = clamp((prog - 0.55 - delay * 0.9) / 0.4, 0.0, 1.0) * uUnwDisperse;
   u = u * u * (3.0 - 2.0 * u);
   vUnwU = u;
+  vUnwL = s; vUnwR = aUnwRand;
   vec3 p;
   if (uUnwMode < 3.5) {
     vec3 rel = fxRot(ax, u * (2.5 + aUnwRand)) * rel0;
@@ -152,10 +158,16 @@ void main() {
   gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
 }`,
                 fragmentShader: `
-uniform vec3 uUnwColor; varying float vUnwA; varying float vUnwU;
+uniform vec3 uUnwColor; uniform float uUnwTime; uniform float uUnwDisperse; uniform float uUnwProgress;
+varying float vUnwA; varying float vUnwU; varying float vUnwL; varying float vUnwR;
 void main() {
   float a = vUnwA * (1.0 - smoothstep(0.85, 1.0, vUnwU));
-  vec3 c = uUnwColor * (1.2 + 2.5 * vUnwU);
+  // holding as a sculpture: a pulse of light climbs the rings, threads shimmer
+  float held = (1.0 - uUnwDisperse) * step(0.9999, uUnwProgress);
+  float pulse = 0.5 + 0.5 * sin((vUnwL * 7.0 - uUnwTime * 1.3) * 6.2832);
+  float shimmer = 0.6 + 0.4 * sin(uUnwTime * (2.0 + 3.0 * vUnwR) + vUnwR * 40.0);
+  float glow = mix(1.0, 0.55 + 0.9 * pulse * pulse + 0.35 * shimmer, held);
+  vec3 c = uUnwColor * (1.2 + 2.5 * vUnwU) * glow;
   gl_FragColor = vec4(c * a, a);
   #include <tonemapping_fragment>
   #include <colorspace_fragment>
@@ -186,7 +198,7 @@ void main() {
         s.color.value.set(String(p.color));
         const mode = MODES.includes(String(p.mode)) ? String(p.mode) : 'up';
         s.mode.value = MODES.indexOf(mode);
-        s.disperse.value = p.disperse === false ? 0 : 1;
+        s.disperse.value = p.disappear === false ? 0 : 1;
         if (mode === 'up')
             s.axis.value.set(0, 1, 0);
         else if (mode === 'down')
@@ -205,12 +217,18 @@ void main() {
             s.field.sweep.value.copy(s.axis.value).negate();
         }
         s.lines.visible = true;
-        const keep = s.disperse.value === 0;
-        // 0 → 1: surface goes (field clamps at 1); the threads run on to 1.6
-        return runProgress(target, s.field, 1.6, {
+        if (s.disperse.value === 0) {
+            // keep: the surface goes (0 → 1), the sculpture stays and holds
+            return runProgress(target, s.field, 1, {
+                duration: Number(p.duration) * (1 / END), ease: 'none', hold: true,
+                onComplete: () => hideMeshes(target, KEY, true),
+            });
+        }
+        hideMeshes(target, KEY, false);
+        // 0 → 1: surface goes (field clamps at 1); the threads run on to END
+        return runProgress(target, s.field, END, {
             duration: Number(p.duration), ease: 'none',
-            onComplete: () => { hideMeshes(target, KEY, true); if (!keep)
-                s.lines.visible = false; },
+            onComplete: () => { hideMeshes(target, KEY, true); s.lines.visible = false; },
         });
     },
     revert(target, p) {
@@ -219,8 +237,9 @@ void main() {
             return;
         hideMeshes(target, KEY, false);
         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 / END)), ease: 'none',
             onComplete: () => {
                 s.mats.forEach(m => removeLayer(m, KEY));
                 s.lines.removeFromParent();

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

@@ -1 +1 @@
-{"version":3,"file":"voxelize.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/voxelize.ts"],"names":[],"mappings":";AAsDA,wBAoFG"}
+{"version":3,"file":"voxelize.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/voxelize.ts"],"names":[],"mappings":";AA0DA,wBA2GG"}

package/dist/operations/catalogue/voxelize.js

@@ -4,6 +4,8 @@
 // passes, the surface goes and its voxel pops in with a brief flash; a moment
 // later the voxel lifts off along the surface normal and upward, tumbling and
 // shrinking. Reverting flies every cube back and the surface re-forms.
+// With Disappear off (an object effect's default) the whole object stays digitised:
+// every cube in place, and holds — a scan line climbs the rows, a few cubes flicker.
 import { BoxGeometry } from 'three';
 import { defineOperation } from '../types.js';
 import { GLSL_ROT, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
@@ -14,6 +16,8 @@ const P = 'Vox';
 const KEY = 'voxelize';
 const STATE = '__opVoxelize';
 const LIFE = 0.75;
+/** Keep: the voxel age is clamped here — popped in, flash gone, not yet lifting off. */
+const KEEP_AGE = 0.28;
 /** Quantise surface samples to a grid: one voxel per occupied cell, averaged. */
 function buildVoxels(target, resolution) {
     const sample = sampleSurfaceCached(target, 40000, 37);
@@ -61,15 +65,18 @@ function buildVoxels(target, resolution) {
 export default defineOperation({
     value: 'voxelize',
     label: 'Voxelise',
-    description: 'Digitise the targets into cubes that peel off and float away — reverting clicks them back',
+    description: 'Digitise the targets into cubes that peel off and float away (or, Disappear off, stay as a voxel model) — reverting clicks them back',
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
+    // no presence: with Disappear off the look decorates the object (it appears, then is re-drawn); on, it is the entrance / exit
     params: {
         direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
         resolution: { type: 'number', label: 'Resolution', default: 26, min: 6, max: 70, step: 1, hint: 'Cubes across the object’s largest side' },
-        lift: { type: 'number', label: 'Float', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        lift: { type: 'number', label: 'Float', default: 1, min: 0, max: 4, step: 0.05, unit: '×', showWhen: { disappear: ['true'] } },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays as a model of cubes' },
         edgeColor: { type: 'color', label: 'Scan colour', default: '#7fe3ff' },
         scale: { type: 'number', label: 'Pattern', default: 2, min: 0.5, max: 12, step: 0.1 },
         duration: { type: 'number', label: 'Duration', default: 3, min: 0.3, max: 12, step: 0.1, unit: 's' },
@@ -79,7 +86,7 @@ export default defineOperation({
         if (!st) {
             const field = createFieldState(target);
             field.edgeWidth.value = 0.04;
-            const life = { value: LIFE }, lift = { value: 1 };
+            const life = { value: LIFE }, lift = { value: 1 }, keep = { value: 0 };
             const vox = buildVoxels(target, Math.round(Number(p.resolution)));
             const s = vox.cell * 0.94;
             const mesh = createFxInstances(target, {
@@ -88,11 +95,11 @@ export default defineOperation({
                 attributes: { aVoxP: [vox.positions, 3], aVoxN: [vox.normals, 3], aVoxR: [vox.rand, 4] },
                 layerKey: 'voxelInstances', roughness: 0.55, metalness: 0.05,
                 layer: {
-                    uniforms: { ...fieldUniforms(P, field), uVoxLife: life, uVoxLift: lift },
-                    common: `varying float vVoxFlash;\n${fieldGlsl(P)}\n${GLSL_ROT}`,
+                    uniforms: { ...fieldUniforms(P, field), uVoxLife: life, uVoxLift: lift, uVoxKeep: keep },
+                    common: `varying float vVoxFlash; varying float vVoxHold; varying vec2 vVoxYR;\n${fieldGlsl(P)}\n${GLSL_ROT}`,
                     vertexPars: /* glsl */ `
                     attribute vec3 aVoxP; attribute vec3 aVoxN; attribute vec4 aVoxR;
-                    float voxAge() { return (uVoxProgress - VoxBirthOf(VoxField(VoxNorm(aVoxP)))) / uVoxLife; }
+                    float voxAge() { const float KEEP_AGE = ${KEEP_AGE.toFixed(2)}; float a = (uVoxProgress - VoxBirthOf(VoxField(VoxNorm(aVoxP)))) / uVoxLife; return mix(a, min(a, KEEP_AGE), uVoxKeep); }
                     mat3 voxSpin(float a) { float fly = smoothstep(0.3, 1.0, a); return fxRot(normalize(aVoxR.xyz - 0.5 + vec3(1e-3)), fly * fly * (2.0 + 3.0 * aVoxR.w)); }`,
                     normal: `{ objectNormal = voxSpin(voxAge()) * objectNormal; }`,
                     vertex: /* glsl */ `
@@ -106,11 +113,21 @@ export default defineOperation({
                                + (aVoxR.xyz - 0.5) * E * 0.25 * fly;
                       transformed = voxSpin(a) * (transformed * sc) + off;
                       vVoxFlash = pop * (1.0 - smoothstep(0.1, 0.24, a));
+                      // holding as a voxel model
+                      vVoxHold = uVoxKeep * step(0.9999, uVoxProgress);
+                      vVoxYR = vec2(VoxNorm(aVoxP).y, aVoxR.w);
+                    }`,
+                    emissive: /* glsl */ `
+                    {
+                      // a scan line climbs the rows now and then; a few cubes flicker
+                      float scan = fract(uVoxTime * 0.22);
+                      float line = exp(-pow((vVoxYR.x - scan * 1.2 + 0.1) * 18.0, 2.0));
+                      float flick = step(0.955, vVoxYR.y) * (0.5 + 0.5 * sin(uVoxTime * (7.0 + 9.0 * vVoxYR.y) + vVoxYR.y * 50.0));
+                      totalEmissiveRadiance += uVoxEdgeColor * (vVoxFlash * 0.7 + vVoxHold * (0.35 * line + 0.3 * flick * flick));
                     }`,
-                    emissive: `totalEmissiveRadiance += uVoxEdgeColor * vVoxFlash * 0.7;`,
                 },
             });
-            st = { field, life, lift, mesh, mats: new Set() };
+            st = { field, life, lift, keep, mesh, mats: new Set() };
             const own = st;
             const layer = surfaceLayer(P, field, 'tint');
             forEachMeshMaterial(target, (mat, m) => {
@@ -125,6 +142,15 @@ export default defineOperation({
         setFieldParams(s.field, p, target, ctx);
         s.lift.value = Number(p.lift);
         s.mesh.visible = true;
+        s.keep.value = p.disappear === false ? 1 : 0;
+        if (s.keep.value) {
+            // keep: the surface goes (0 → 1), every cube stays in place 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: 'none',
             onComplete: () => { hideMeshes(target, KEY, true); s.mesh.visible = false; },
@@ -136,8 +162,9 @@ export default defineOperation({
             return;
         hideMeshes(target, KEY, false);
         s.mesh.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));
                 disposeFxInstances(s.mesh);