@3driseai/3drise-viewer 0.1.28 → 0.1.30

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/flyBy.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"flyBy.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/flyBy.ts"],"names":[],"mappings":";AA+CA,wBAkCG"}

package/dist/operations/catalogue/flyBy.js

@@ -0,0 +1,79 @@
+// Fly-by — the object takes off and flies past the camera. It lifts, banks into
+// a turn and sweeps towards the viewer on a cubic Bézier, rolling into the curve
+// (bank follows the path's sideways acceleration) and yawing to its heading, and
+// passes just beside the lens. The way back: it comes in from behind the camera
+// on the other side, banks round and sets down in place, the roll easing out.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth } from './physicalExit.js';
+const _p0 = new Vector3(), _p1 = new Vector3(), _p2 = new Vector3(), _p3 = new Vector3();
+const _a = new Vector3(), _vel = new Vector3(), _acc = new Vector3(), _side = new Vector3();
+const _r = new Quaternion(), _y = new Quaternion();
+/** The flight path from the object (0) to just beside the camera (1), on `side` (±1 along screen right). */
+function path(a, side) {
+    const f = a.frame, H = a.size.y, span = a.span;
+    const cam = f.camera ?? _a.copy(f.toward).multiplyScalar(14 * span).addScaledVector(f.up, 1.5 * H);
+    const lift = Number(a.p.lift) * H;
+    _p0.set(0, 0, 0);
+    _p1.copy(f.up).multiplyScalar(lift * 1.4); // straight up off the ground
+    _p2.copy(cam).multiplyScalar(0.45).addScaledVector(f.right, side * 2.2 * span).addScaledVector(f.up, lift);
+    _p3.copy(cam).multiplyScalar(1.12).addScaledVector(f.right, side * 1.4 * span); // just past the lens, to the side
+}
+function bez(t, out, d = 0) {
+    const m = 1 - t;
+    if (d === 0)
+        return out.set(0, 0, 0).addScaledVector(_p0, m * m * m).addScaledVector(_p1, 3 * m * m * t).addScaledVector(_p2, 3 * m * t * t).addScaledVector(_p3, t * t * t);
+    if (d === 1)
+        return out.set(0, 0, 0).addScaledVector(_p1.clone().sub(_p0), 3 * m * m).addScaledVector(_p2.clone().sub(_p1), 6 * m * t).addScaledVector(_p3.clone().sub(_p2), 3 * t * t);
+    return out.set(0, 0, 0).addScaledVector(_p2.clone().sub(_p1.clone().multiplyScalar(2)).add(_p0), 6 * m).addScaledVector(_p3.clone().sub(_p2.clone().multiplyScalar(2)).add(_p1), 6 * t);
+}
+/** Bank into the curve: roll about the heading by the sideways acceleration, yaw towards the heading. */
+function attitude(a, t, amount, yawAmount) {
+    const f = a.frame;
+    bez(t, _vel, 1);
+    bez(t, _acc, 2);
+    const flat = _vel.clone().addScaledVector(f.up, -_vel.dot(f.up));
+    const heading = flat.lengthSq() > 1e-8 ? flat.normalize() : f.toward.clone();
+    _side.crossVectors(f.up, heading);
+    const lateral = _acc.dot(_side) / Math.max(1e-6, _vel.lengthSq());
+    const bank = (Number(a.p.bank) * Math.PI / 180) * Math.max(-1, Math.min(1, lateral * a.span * 1.2)) * amount;
+    const yaw = Math.atan2(heading.dot(f.right), heading.dot(f.toward)) * yawAmount;
+    _r.setFromAxisAngle(heading, -bank);
+    _y.setFromAxisAngle(f.up, yaw);
+    return a.local(_r.multiply(_y));
+}
+const sideOf = (a) => (a.p.side === 'left' ? -1 : 1);
+export default physicalExit({
+    value: 'flyBy',
+    label: 'Fly-by',
+    description: 'Takes off, banks and flies past the camera — it comes back from behind the camera on the other side and sets down in place',
+    params: {
+        side: {
+            type: 'select', label: 'Passes on the', default: 'right', options: [{ value: 'right', label: 'Right' }, { value: 'left', label: 'Left' }],
+            hint: 'The camera side it flies past',
+        },
+        bank: { type: 'number', label: 'Bank', default: 35, min: 0, max: 80, step: 1, unit: '°', hint: 'How hard it rolls into the turn' },
+        lift: { type: 'number', label: 'Climb', default: 0.8, min: 0, max: 4, step: 0.05, hint: 'How high it climbs first, × its height' },
+        duration: { type: 'number', label: 'Duration', default: 2.2, min: 0.5, max: 8, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        path(a, sideOf(a));
+        // takes off slowly, then accelerates along the path
+        const t = u * u * (0.4 + 0.6 * u);
+        bez(t, out.off);
+        const e = smooth(0, 0.2, u);
+        out.q.copy(attitude(a, Math.max(t, 0.02), e, e * 0.6));
+        out.s.setScalar(1 - smooth(0.9, 1, u)); // behind the lens: gone
+    },
+    enter(v, out, a) {
+        path(a, -sideOf(a));
+        // the same kind of path flown backwards: in from beside the lens, slowing down to set down
+        const left = 1 - v;
+        const t = Math.pow(left, 1.8);
+        bez(t, out.off);
+        // a soft touchdown bob in the last bit
+        out.off.addScaledVector(a.frame.up, -0.03 * a.size.y * ring(clamp01((v - 0.8) / 0.2), 1, 2.5));
+        const e = 1 - smooth(0.7, 1, v);
+        out.q.copy(attitude(a, Math.max(t, 0.02), e, e * 0.6));
+        out.s.setScalar(smooth(0, 0.08, v));
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"frost.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/frost.ts"],"names":[],"mappings":";AAoEA,wBA4CG"}
+{"version":3,"file":"frost.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/frost.ts"],"names":[],"mappings":";AAwEA,wBA+CG"}

package/dist/operations/catalogue/frost.js

@@ -7,7 +7,7 @@
 import { Color } from 'three';
 import { defineOperation } from '../types.js';
 import { GLSL_WORLEY, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
-import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, goneGlsl, runProgress, setFieldParams, setReveal } from './transitionField.js';
 const P = 'Frs';
 const KEY = 'frost';
 const STATE = '__opFrost';
@@ -23,7 +23,7 @@ function layerFor(st) {
     `;
     return {
         uniforms: { ...fieldUniforms(P, st.field), uFrsIce: st.ice, uFrsDensity: st.density },
-        common: `varying vec3 vFrsQ;\nvarying vec3 vFrsR;\nvarying vec3 vFrsView;\n${fieldGlsl(P)}\n${GLSL_WORLEY}`,
+        common: `varying vec3 vFrsQ;\nvarying vec3 vFrsR;\nvarying vec3 vFrsView;\n${fieldGlsl(P)}\n${goneGlsl(P)}\n${GLSL_WORLEY}`,
         fragmentPars: 'float frsFr = 0.0; vec3 frsCell = vec3(1.0); float frsSeam = 0.0;',
         vertex: /* glsl */ `
         vFrsR = (uFrsRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
@@ -31,7 +31,11 @@ function layerFor(st) {
         vFrsView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
         diffuse: /* glsl */ `
         {
-          frsFr = smoothstep(0.0, uFrsEdgeWidth, FrsThreshold() - FrsField(vFrsQ));
+          float frsD = FrsThreshold() - FrsField(vFrsQ);
+          frsFr = smoothstep(0.0, uFrsEdgeWidth, frsD);
+          // revealed by the ice: nothing ahead of the front, solid ice right behind it
+          if (uFrsReveal > 0.5) { if (frsD < 0.0) discard; frsFr = 1.0; }
+          frsFr *= 1.0 - FrsGone(vFrsQ);                     // wiped by the look that replaces it
           frsCell = fxWorley(vFrsR * (uFrsDensity / uFrsExtent));
           frsSeam = 1.0 - smoothstep(0.0, 0.09, frsCell.y - frsCell.x);
           ${frozen}
@@ -70,6 +74,8 @@ export default defineOperation({
     toggles: true,
     usableIn: ['interaction', 'action', 'object'],
     stack: 'surface',
+    presence: 'paint',
+    field: (target) => target.userData[STATE]?.field,
     params: {
         direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
         ice: { type: 'color', label: 'Ice', default: '#bfe4ff' },
@@ -103,6 +109,7 @@ export default defineOperation({
         const s = target.userData[STATE];
         if (!s)
             return;
+        setReveal(s.field, p);
         return runProgress(target, s.field, 0, {
             duration: Number(p.duration), ease: 'power1.in',
             onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },

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

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

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

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

package/dist/operations/catalogue/grow.js

@@ -0,0 +1,19 @@
+// Grow — the object scales up (or down) and stays there, with a small overshoot
+// as it arrives. From its base (it stays on the ground) or from its centre.
+import { DURATION, heldPhysical } from './physicalHeld.js';
+export default heldPhysical({
+    value: 'grow', label: 'Grow',
+    description: 'Scale up (or down) and stay — settles with a small overshoot; switching off brings it back',
+    ease: 'back.out(1.5)',
+    periodic: false,
+    params: {
+        scale: { type: 'number', label: 'Size', default: 1.25, min: 0.05, max: 5, step: 0.05, unit: '×' },
+        from: { type: 'select', label: 'From', default: 'base', options: [{ value: 'base', label: 'Its base' }, { value: 'center', label: 'Its centre' }] },
+        duration: { ...DURATION, default: 0.6, max: 6, hint: 'How long it takes to arrive, and to go back' },
+    },
+    memory: () => null,
+    move(part, st) {
+        part.s.setScalar(Math.max(0.001, 1 + (Number(st.p.scale) - 1) * st.amp.v));
+        part.pivot.copy(st.p.from === 'center' ? st.body.centerLocal : st.body.bottomLocal);
+    },
+});

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

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

package/dist/operations/catalogue/hologram.js

@@ -5,7 +5,7 @@
 // Reverting scans it back in: hologram first, then solid.
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
-import { SWEEP_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+import { SWEEP_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, goneGlsl, runProgress, setFieldParams, setReveal } from './transitionField.js';
 import { Color } from 'three';
 const P = 'Holo';
 const KEY = 'hologram';
@@ -19,6 +19,8 @@ export default defineOperation({
     toggles: true,
     usableIn: ['interaction', 'action', 'object'],
     objectParams: { disappear: false },
+    presence: 'paint',
+    field: (target) => target.userData[STATE]?.field,
     params: {
         direction: { type: 'select', label: 'Scan', default: 'down', options: SWEEP_OPTIONS },
         color: { type: 'color', label: 'Colour', default: '#3fd4ff' },
@@ -35,7 +37,7 @@ export default defineOperation({
             const own = st;
             const layer = {
                 uniforms: { ...fieldUniforms(P, field), uHoloColor: st.color, uHoloDensity: st.density, uHoloGap: st.gap, uHoloKeep: st.keep },
-                common: `varying vec3 vHoloR;\nvarying vec3 vHoloView;\n${fieldGlsl(P)}`,
+                common: `varying vec3 vHoloR;\nvarying vec3 vHoloView;\n${fieldGlsl(P)}\n${goneGlsl(P)}`,
                 vertex: /* glsl */ `
                 vHoloR = (uHoloRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
                 vHoloView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
@@ -48,8 +50,10 @@ export default defineOperation({
                   float fa = mix(-band, 1.0 + uHoloGap + band, clamp(uHoloProgress, 0.0, 1.0)); // solid → hologram
                   // hologram → gone (never, when the object should stay as a hologram)
                   float fb = uHoloKeep > 0.5 ? -1.0 : fa - uHoloGap;
-                  if (s < fb) discard;
-                  if (s < fa) {
+                  float gone = HoloGone(q);                   // wiped by the look that replaces it
+                  if (gone < 0.5 && s < fb) discard;
+                  if (gone > 0.5) {
+                  } else if (s < fa) {
                     // grid in root-local units, square cells, anti-aliased
                     vec3 cell = vHoloR * (uHoloDensity / uHoloExtent);
                     vec3 g = abs(fract(cell - 0.5) - 0.5) / max(fwidth(cell), vec3(1e-4));
@@ -64,6 +68,7 @@ export default defineOperation({
                     if (I < 0.32) discard;
                     outgoingLight = uHoloColor * I * 1.6;
                   } else {
+                    if (uHoloReveal > 0.5) discard;           // revealed by the scan: nothing ahead of the plane
                     // the solid side gets a faint pre-glow just ahead of the plane
                     outgoingLight += uHoloColor * exp(-(s - fa) / 0.03) * 0.6;
                   }
@@ -78,7 +83,7 @@ export default defineOperation({
             target.userData[STATE] = st;
         }
         const s = st;
-        setFieldParams(s.field, { direction: p.direction }, target, ctx);
+        setFieldParams(s.field, { direction: p.direction, __reveal: p.__reveal }, target, ctx);
         s.color.value.set(String(p.color));
         s.density.value = Number(p.density);
         s.gap.value = Number(p.hold);
@@ -95,6 +100,7 @@ export default defineOperation({
         if (!s)
             return;
         setMeshesHidden(target, false);
+        setReveal(s.field, p);
         return runProgress(target, s.field, 0, {
             duration: Number(p.duration), ease: 'power1.inOut',
             onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },

package/dist/operations/catalogue/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/jelly.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jelly.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/jelly.ts"],"names":[],"mappings":";AAWA,wBAqCG"}
+{"version":3,"file":"jelly.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/jelly.ts"],"names":[],"mappings":";AAWA,wBA8CG"}

package/dist/operations/catalogue/jelly.js

@@ -14,7 +14,7 @@ export default defineOperation({
     channel: 'transform',
     multi: true,
     toggles: false,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
     params: {
         strength: { type: 'number', label: 'Squash', default: 0.28, min: 0.02, max: 0.7, step: 0.01 },
         wobbles: { type: 'number', label: 'Wobbles', default: 3, min: 1, max: 8, step: 0.5 },
@@ -24,27 +24,37 @@ export default defineOperation({
         const running = target.userData[KEY];
         if (running) {
             gsap.killTweensOf(running.proxy);
-            releaseRest(target);
+            releaseRest(target, KEY);
         }
-        const rest = acquireRest(target);
-        const proxy = { t: 0 };
-        target.userData[KEY] = { proxy };
+        const rest = acquireRest(target, KEY);
         const A = Number(p.strength);
         const D = Number(p.duration);
+        // p.__backward (playback: reverse / yoyo) plays the same move backwards in time.
+        const back = p.__backward === true;
+        const proxy = { t: back ? D : 0 };
+        target.userData[KEY] = { proxy };
         const w = 2 * Math.PI * (Number(p.wobbles) / D); // rad/s
         const k = 4.6 / D; // decays to 1% by the end
         const s = new Vector3();
         gsap.to(proxy, {
-            t: D, duration: D, ease: 'none',
+            t: back ? 0 : D, duration: D, ease: 'none',
             onUpdate: () => {
                 const t = proxy.t;
                 // damped spring, squash first
                 const sy = 1 - A * Math.exp(-k * t) * Math.sin(w * t);
                 const sxz = 1 / Math.sqrt(Math.max(sy, 0.05)); // keep the volume
                 s.set(sxz, sy, sxz);
-                poseAbout(target, rest, rest.bottomLocal, NO_TURN, s);
+                poseAbout(target, rest, rest.bottomLocal, NO_TURN, s, undefined, KEY);
             },
-            onComplete: () => { delete target.userData[KEY]; releaseRest(target); },
+            onComplete: () => { delete target.userData[KEY]; releaseRest(target, KEY); },
         });
     },
+    cancel(target) {
+        const running = target.userData[KEY];
+        if (!running)
+            return;
+        gsap.killTweensOf(running.proxy);
+        delete target.userData[KEY];
+        releaseRest(target, KEY);
+    },
 });

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

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

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

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

package/dist/operations/catalogue/knockAway.js

@@ -0,0 +1,74 @@
+// Knock away — the object is struck from the side at a point above or below its
+// centre. The impulse gives it linear AND angular velocity, the spin set by the
+// arm of the hit over its inertia (a box from its own bounds: I ∝ h² + w²), so a
+// tall thing struck high tips and tumbles while a flat one mostly skims. It
+// compresses at the impact, flies off on a ballistic arc, slowed by drag, tumbling
+// at a constant rate, and is gone. The way back: it is thrown in from the other
+// side with back-spin, lands upright and settles with two small hops and a rock.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth, stretchAxis } from './physicalExit.js';
+const LAND = 0.62;
+const _d = new Vector3(), _n = new Vector3(), _q = new Quaternion(), _y = new Quaternion();
+function axes(a) {
+    const f = a.frame;
+    _d.copy(f.right).multiplyScalar(a.p.side === 'right' ? -1 : 1); // struck from the left = flies right
+    _n.crossVectors(f.up, _d).normalize(); // + about it tips the top towards _d
+}
+/** Turns of tumble over the flight: the hit's arm over the inertia (box), scaled by the strength. */
+function tumbleTurns(a) {
+    const H = a.size.y, W = Math.max(a.size.x, a.size.z);
+    const arm = (Number(a.p.hit) - 0.5) * 2; // −1 (bottom) … 1 (top)
+    return 1.3 * arm * (Number(a.p.strength) / 6) * (H * H) / (H * H + W * W) * 2;
+}
+export default physicalExit({
+    value: 'knockAway',
+    label: 'Knock away',
+    description: 'Struck from the side: it flies off on an arc, tumbling by where it was hit — tall things tip, flat ones skim; it is thrown back in and lands with a hop',
+    params: {
+        side: {
+            type: 'select', label: 'Struck from', default: 'left', options: [{ value: 'left', label: 'The left' }, { value: 'right', label: 'The right' }],
+            hint: 'Screen-relative when it starts',
+        },
+        strength: { type: 'number', label: 'Strength', default: 6, min: 2, max: 30, step: 0.5, hint: 'How far it flies, × its size' },
+        lift: { type: 'number', label: 'Arc', default: 1.6, min: 0, max: 5, step: 0.05, hint: 'Height of the arc, × its height' },
+        hit: { type: 'number', label: 'Hit height', default: 0.75, min: 0, max: 1, step: 0.01, hint: '0 = struck at its base, 1 = at its top' },
+        duration: { type: 'number', label: 'Duration', default: 1.6, min: 0.3, max: 6, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const p = a.p, H = a.size.y;
+        axes(a);
+        const dist = Number(p.strength) * a.span;
+        const x = dist * (1 - Math.pow(1 - u, 1.25)); // drag slows it
+        const y = 4 * Number(p.lift) * H * u * (1 - u);
+        out.off.copy(_d).multiplyScalar(x).addScaledVector(a.frame.up, y);
+        const th = 2 * Math.PI * tumbleTurns(a) * u;
+        _q.setFromAxisAngle(_n, th).multiply(_y.setFromAxisAngle(a.frame.up, 0.35 * u));
+        out.q.copy(a.local(_q));
+        // compressed by the blow for an instant
+        const squash = 0.18 * Math.sin(Math.PI * Math.min(1, u / 0.12));
+        stretchAxis(out.s, a.axis(_d), 1 - squash, 1 - smooth(0.7, 1, u));
+    },
+    enter(v, out, a) {
+        const p = a.p, H = a.size.y;
+        axes(a);
+        const dist = Number(p.strength) * a.span * 0.7;
+        if (v < LAND) {
+            const tau = v / LAND;
+            const x = -0.15 * a.span - dist * Math.pow(1 - tau, 1.15);
+            const y = 4 * Number(p.lift) * 0.8 * H * tau * (1 - tau);
+            out.off.copy(_d).multiplyScalar(x).addScaledVector(a.frame.up, y);
+            // back-spin that runs out exactly as it lands upright
+            const th = -2 * Math.PI * 0.75 * Math.sign(tumbleTurns(a) || 1) * Math.pow(1 - tau, 1.3);
+            out.q.copy(a.local(_q.setFromAxisAngle(_n, th)));
+            out.s.setScalar(smooth(0, 0.25, tau));
+            return;
+        }
+        // two shrinking hops over the last bit, rocking
+        const sg = clamp01((v - LAND) / (1 - LAND));
+        const x = -0.15 * a.span * Math.pow(1 - sg, 1.5);
+        const y = 0.22 * H * Math.abs(Math.sin(2 * Math.PI * sg)) * (1 - sg) * (1 - sg);
+        out.off.copy(_d).multiplyScalar(x).addScaledVector(a.frame.up, y);
+        out.q.copy(a.local(_q.setFromAxisAngle(_n, 0.12 * ring(sg, 1.5, 3))));
+        out.pivot = 'bottom';
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"leafFall.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/leafFall.ts"],"names":[],"mappings":";AA2BA,wBA+CG"}