@3driseai/3drise-viewer 0.1.28 → 0.1.30

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

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

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

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

package/dist/operations/catalogue/shake.js

@@ -0,0 +1,31 @@
+// Shake — a tremble made of smooth noise (not a new random spot every frame, which
+// reads as flicker): position and a little roll, each on its own noise track.
+import { Vector3 } from 'three';
+import { DURATION, heldPhysical } from './physicalHeld.js';
+const Z = new Vector3(0, 0, 1);
+const hash = (i, seed) => { const x = Math.sin(i * 127.1 + seed * 311.7) * 43758.5453; return (x - Math.floor(x)) * 2 - 1; };
+/** Smooth 1D noise, −1..1. */
+function noise(x, seed) {
+    const i = Math.floor(x), f = x - i;
+    const u = f * f * (3 - 2 * f);
+    return hash(i, seed) * (1 - u) + hash(i + 1, seed) * u;
+}
+export default heldPhysical({
+    value: 'shake', label: 'Shake',
+    description: 'Tremble on the spot — smooth, nervous noise in position and roll',
+    params: {
+        strength: { type: 'number', label: 'Strength', default: 0.02, min: 0.002, max: 0.3, step: 0.002, hint: 'As a fraction of the object’s height' },
+        frequency: { type: 'number', label: 'Rate', default: 14, min: 1, max: 40, step: 0.5, unit: '/s' },
+        roll: { type: 'number', label: 'Roll', default: 1.5, min: 0, max: 15, step: 0.25, unit: '°' },
+        duration: { ...DURATION, default: 1.2 },
+    },
+    memory: () => null,
+    move(part, st, time) {
+        const p = st.p, a = st.amp.v;
+        const x = time * Number(p.frequency);
+        const A = st.body.size.y * Number(p.strength) * a;
+        part.off.set(noise(x, 1) * A, noise(x, 2) * A, noise(x, 3) * A * 0.5);
+        part.q.setFromAxisAngle(Z, noise(x * 0.8, 4) * (Number(p.roll) * Math.PI / 180) * a);
+        part.pivot.copy(st.body.centerLocal);
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shatter.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/shatter.ts"],"names":[],"mappings":";AAqKA,wBA4FG"}
+{"version":3,"file":"shatter.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/shatter.ts"],"names":[],"mappings":";AAqKA,wBA+FG"}

package/dist/operations/catalogue/shatter.js

@@ -162,7 +162,8 @@ export default defineOperation({
     channel: 'visual',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    presence: 'vanish',
     params: {
         direction: { type: 'select', label: 'Direction', default: 'outward', options: DIRECTION_OPTIONS },
         edgeColor: { type: 'color', label: 'Crack colour', default: '#8fe3ff' },
@@ -210,8 +211,10 @@ export default defineOperation({
                 retainPrograms(stage);
                 if (target.userData[STATE] !== own)
                     return; // reverted meanwhile
+                // (__opFxOwnMaterial: the mesh's real material, so the swap is not taken for a replaced surface — see surfaceSignature)
                 for (const sw of own.swaps)
                     if (sw.split) {
+                        sw.mesh.userData.__opFxOwnMaterial = sw.material;
                         sw.mesh.geometry = sw.splitGeo;
                         sw.mesh.material = sw.splitMat;
                     }
@@ -253,6 +256,7 @@ export default defineOperation({
                     }
                     sw.mesh.geometry = sw.geometry;
                     sw.mesh.material = sw.material;
+                    delete sw.mesh.userData.__opFxOwnMaterial;
                     (Array.isArray(sw.splitMat) ? sw.splitMat : [sw.splitMat]).forEach(m => m.dispose());
                 }
                 delete target.userData[STATE];

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

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

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

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

package/dist/operations/catalogue/slam.js

@@ -0,0 +1,89 @@
+// Slam — weight and impact. Coming in, the object hangs above its spot, winds up
+// (rises a little, slowing to a stop), then slams down, accelerating hard
+// (height ∝ (1−t)³ … the speed is greatest at the floor), stretched by the speed.
+// The impact squashes it flat at its base, it rebounds in a small hop and rattles
+// (a fast, damped shake) until it is exactly at rest. Leaving: it lifts and winds
+// up, slams down into the floor and is driven through it, rattling, and is gone.
+import { Quaternion } from 'three';
+import { clamp01, physicalExit, ring, smooth } from './physicalExit.js';
+const _a = new Quaternion(), _b = new Quaternion();
+const HANG = 0.32, HIT = 0.5; // entrance: hang + wind-up, then the drop, then the impact
+/** A fast damped rattle about two screen axes, `amount` 0…1. */
+function rattle(out, a, amount, secs) {
+    const rad = (Number(a.p.rattle) * Math.PI / 180) * amount;
+    const w = 2 * Math.PI * secs;
+    _a.setFromAxisAngle(a.frame.right, rad * Math.sin(19 * w));
+    _b.setFromAxisAngle(a.frame.toward, rad * 0.8 * Math.sin(23 * w + 1.3));
+    out.q.copy(a.local(_a.multiply(_b)));
+}
+/** Volume-keeping vertical scale about the base. */
+function vert(out, sy, size = 1) {
+    const sxz = 1 / Math.sqrt(Math.max(sy, 0.05));
+    out.s.set(sxz * size, sy * size, sxz * size);
+    out.pivot = 'bottom';
+}
+export default physicalExit({
+    value: 'slam',
+    label: 'Slam',
+    description: 'Hangs above its spot, winds up and slams down — squash, hop and rattle; it leaves by slamming down through the floor',
+    params: {
+        height: { type: 'number', label: 'Height', default: 1.6, min: 0.5, max: 12, step: 0.1, hint: 'How high it hangs before the slam, × its height' },
+        squash: { type: 'number', label: 'Squash', default: 0.38, min: 0, max: 0.7, step: 0.01, hint: 'How flat the impact squashes it' },
+        rattle: { type: 'number', label: 'Rattle', default: 2.5, min: 0, max: 10, step: 0.25, unit: '°' },
+        duration: { type: 'number', label: 'Duration', default: 1.5, min: 0.4, max: 6, step: 0.05, unit: 's' },
+    },
+    enter(v, out, a) {
+        const p = a.p, H = a.size.y, D = Number(p.duration), up = a.frame.up;
+        const top = Number(p.height) * H;
+        const sq = Number(p.squash);
+        if (v < HANG) {
+            // appears and winds up: rises a little higher, slowing to a stop
+            const t = v / HANG;
+            const y = top + 0.12 * top * (1 - Math.pow(1 - t, 2));
+            out.off.copy(up).multiplyScalar(y);
+            vert(out, 1 - 0.08 * smooth(0.6, 1, t), smooth(0, 0.3, t)); // gathers itself
+            return;
+        }
+        if (v < HIT) {
+            // the slam: accelerating all the way to the floor
+            const t = (v - HANG) / (HIT - HANG);
+            const y = 1.12 * top * (1 - t * t * t);
+            out.off.copy(up).multiplyScalar(y);
+            vert(out, 0.92 + (0.08 + 0.35 * sq) * smooth(0, 0.7, t));
+            return;
+        }
+        // impact: flat at once, then a hop and a rattle that die out exactly at rest
+        const sg = clamp01((v - HIT) / (1 - HIT));
+        const r = ring(sg, 2.2, 4.2);
+        const flat = sq * Math.exp(-14 * sg) * (1 - smooth(0, 0.5, sg)); // the hit itself
+        vert(out, 1 - flat - 0.35 * sq * r);
+        const hop = 0.1 * H * Math.max(0, Math.sin(Math.PI * clamp01((sg - 0.06) / 0.3))) * (1 - sg);
+        out.off.copy(up).multiplyScalar(hop);
+        rattle(out, a, Math.exp(-5 * sg) * (1 - sg) * smooth(0, 0.04, sg), v * D);
+    },
+    exit(u, out, a) {
+        const p = a.p, H = a.size.y, D = Number(p.duration), up = a.frame.up;
+        const sq = Number(p.squash);
+        const W = 0.35, HITX = 0.47;
+        if (u < W) {
+            // lifts and winds up
+            const t = u / W;
+            out.off.copy(up).multiplyScalar(0.45 * H * (1 - Math.pow(1 - t, 2)));
+            vert(out, 1 + 0.06 * smooth(0, 1, t));
+            return;
+        }
+        if (u < HITX) {
+            const t = (u - W) / (HITX - W);
+            out.off.copy(up).multiplyScalar(0.45 * H * (1 - t * t * t));
+            vert(out, 1.06 + 0.25 * sq * t);
+            return;
+        }
+        // into the floor: flattened by the hit, then driven down through it, rattling
+        const sg = (u - HITX) / (1 - HITX);
+        const flat = sq * Math.exp(-10 * sg) * smooth(0, 0.03, sg);
+        const sink = 1.15 * H * Math.pow(smooth(0.08, 1, sg), 1.3);
+        out.off.copy(up).multiplyScalar(-sink);
+        vert(out, 1 - flat, 1 - smooth(0.6, 1, sg));
+        rattle(out, a, smooth(0, 0.05, sg) * (1 - 0.4 * sg), u * D);
+    },
+});

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

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

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

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

package/dist/operations/catalogue/slingshot.js

@@ -0,0 +1,88 @@
+// Slingshot — the object is pulled back on an elastic, stretching against the
+// pull (Hooke tension builds, the band quivers at full draw), then released:
+// it snaps forward through rest and flies off still stretched, gone in the
+// distance. Launched upwards the draw is a crouch into the ground instead.
+// The way back: it flies in from where it went, fast, and is caught by a damped
+// spring — overshooting past rest and ringing in until it is exactly there.
+import { Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth, stretchAxis } from './physicalExit.js';
+const DRAW_END = 0.42;
+const CATCH = 0.45;
+const _d = new Vector3(), _n = new Vector3();
+function dirOf(f, d) {
+    if (d === 'left')
+        return _d.copy(f.right).negate();
+    if (d === 'up')
+        return _d.copy(f.up);
+    if (d === 'away')
+        return _d.copy(f.toward).negate();
+    return _d.copy(f.right);
+}
+export default physicalExit({
+    value: 'slingshot',
+    label: 'Slingshot',
+    description: 'Pulled back on an elastic, then let go — it snaps forward and flies off stretched; it flies back in and is caught by a spring',
+    params: {
+        direction: {
+            type: 'select', label: 'Direction', default: 'right', options: [
+                { value: 'right', label: 'Right' }, { value: 'left', label: 'Left' }, { value: 'up', label: 'Up' }, { value: 'away', label: 'Away' },
+            ], hint: 'Screen-relative when it starts',
+        },
+        pull: { type: 'number', label: 'Draw', default: 0.6, min: 0, max: 2, step: 0.05, hint: 'How far it is pulled back, × its size' },
+        stretch: { type: 'number', label: 'Stretch', default: 0.35, min: 0, max: 1.2, step: 0.01 },
+        distance: { type: 'number', label: 'Distance', default: 10, min: 3, max: 40, step: 0.5, hint: 'How far it flies before it is gone, × its size' },
+        duration: { type: 'number', label: 'Duration', default: 1.5, min: 0.3, max: 6, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const p = a.p, f = a.frame, D = Number(p.duration);
+        const d = dirOf(f, p.direction);
+        const up = p.direction === 'up';
+        const axis = a.axis(d), st = Number(p.stretch);
+        const P = Number(p.pull) * a.span * (up ? 0 : 1);
+        const F = Number(p.distance) * a.span;
+        if (u < DRAW_END) {
+            const t = u / DRAW_END;
+            const draw = 1 - Math.pow(1 - t, 3);
+            // quivers at full draw, across the pull
+            _n.crossVectors(d, f.up);
+            if (_n.lengthSq() < 1e-6)
+                _n.copy(f.right);
+            _n.normalize();
+            const quiver = 0.012 * a.span * smooth(0.6, 1, t) * Math.sin(2 * Math.PI * 13 * u * D);
+            out.off.copy(d).multiplyScalar(-P * draw).addScaledVector(_n, quiver);
+            if (up) {
+                out.pivot = 'bottom';
+                stretchAxis(out.s, axis, 1 - 0.5 * st * draw);
+            }
+            else
+                stretchAxis(out.s, axis, 1 + st * draw);
+            return;
+        }
+        const tau = (u - DRAW_END) / (1 - DRAW_END);
+        out.off.copy(d).multiplyScalar(-P + (P + F) * (1 - Math.pow(1 - tau, 2.2)));
+        // the band lets go: the stretch peaks just after release and relaxes in flight
+        const k = up
+            ? 1 - 0.5 * st * (1 - smooth(0, 0.06, tau)) + 1.4 * st * smooth(0, 0.06, tau) * Math.pow(1 - tau, 1.2)
+            : 1 + st * (1 + 0.8 * smooth(0, 0.08, tau)) * Math.pow(1 - tau, 1.2);
+        if (up)
+            out.pivot = 'bottom';
+        stretchAxis(out.s, axis, k, 1 - smooth(0.55, 1, tau));
+    },
+    enter(v, out, a) {
+        const p = a.p, f = a.frame;
+        const d = dirOf(f, p.direction);
+        const axis = a.axis(d), st = Number(p.stretch);
+        const F = Number(p.distance) * a.span;
+        if (v < CATCH) {
+            const tau = v / CATCH;
+            out.off.copy(d).multiplyScalar(F * Math.pow(1 - tau, 1.6));
+            stretchAxis(out.s, axis, 1 + st * (1 - tau), smooth(0, 0.3, tau));
+            return;
+        }
+        // caught: past rest the other way, then rings in
+        const sg = clamp01((v - CATCH) / (1 - CATCH));
+        const r = ring(sg, 1.25, 3.2);
+        out.off.copy(d).multiplyScalar(-0.22 * a.span * r);
+        stretchAxis(out.s, axis, 1 - 0.55 * st * Math.abs(r));
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"spin.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/spin.ts"],"names":[],"mappings":";AAWA,wBAkCG"}
+{"version":3,"file":"spin.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/spin.ts"],"names":[],"mappings":";AAYA,wBA0CG"}

package/dist/operations/catalogue/spin.js

@@ -1,8 +1,9 @@
 // Spin — the target turns a whole number of times about one of its own local
 // axes and lands exactly where it started. One-shot: triggering again spins again.
 import { gsap } from 'gsap';
-import { Quaternion, Vector3 } from 'three';
+import { Vector3 } from 'three';
 import { defineOperation } from '../types.js';
+import { composeMix, joinMix, leaveMix } from './physicalMix.js';
 const KEY = '__opSpin';
 const AXES = { x: new Vector3(1, 0, 0), y: new Vector3(0, 1, 0), z: new Vector3(0, 0, 1) };
 export default defineOperation({
@@ -12,7 +13,7 @@ export default defineOperation({
     channel: 'transform',
     multi: true,
     toggles: false,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
     params: {
         axis: { type: 'select', label: 'Axis', default: 'y', options: [{ value: 'y', label: 'Up (Y)' }, { value: 'x', label: 'Side (X)' }, { value: 'z', label: 'Front (Z)' }] },
         turns: { type: 'number', label: 'Turns', default: 1, min: 1, max: 10, step: 1 },
@@ -20,23 +21,33 @@ export default defineOperation({
         duration: { type: 'number', label: 'Duration', default: 1.2, min: 0.1, max: 20, step: 0.05, unit: 's' },
     },
     apply(target, p) {
-        // A spin already running is finished first, so the rest pose is never lost.
+        // A spin already running is replaced (its part is reset below), so the rest pose is never lost.
         const running = target.userData[KEY];
-        if (running) {
+        if (running)
             gsap.killTweensOf(running.proxy);
-            target.quaternion.copy(running.rest);
-        }
         const axis = AXES[String(p.axis)] ?? AXES.y;
-        const st = { rest: target.quaternion.clone(), proxy: { angle: 0 } };
-        target.userData[KEY] = st;
-        const turn = new Quaternion();
         const turns = Math.max(1, Math.round(Number(p.turns)));
+        const full = (p.reverse ? -1 : 1) * turns * Math.PI * 2;
+        // p.__backward (playback: reverse / yoyo) plays the same move backwards in time.
+        const back = p.__backward === true;
+        const st = { proxy: { angle: back ? full : 0 } };
+        target.userData[KEY] = st;
+        // a turn about the object's own axis and origin, laid over its transform by the physical mix
+        const { part } = joinMix(target, KEY);
+        part.pivot.set(0, 0, 0);
         gsap.to(st.proxy, {
-            angle: (p.reverse ? -1 : 1) * turns * Math.PI * 2,
+            angle: back ? 0 : full,
             duration: Number(p.duration), ease: 'power2.inOut',
-            // rest · turn(axis, a) = a turn about the object's own axis
-            onUpdate: () => { target.quaternion.copy(st.rest).multiply(turn.setFromAxisAngle(axis, st.proxy.angle)); },
-            onComplete: () => { target.quaternion.copy(st.rest); delete target.userData[KEY]; },
+            onUpdate: () => { part.q.setFromAxisAngle(axis, st.proxy.angle); composeMix(target); },
+            onComplete: () => { leaveMix(target, KEY); delete target.userData[KEY]; },
         });
     },
+    cancel(target) {
+        const running = target.userData[KEY];
+        if (!running)
+            return;
+        gsap.killTweensOf(running.proxy);
+        delete target.userData[KEY];
+        leaveMix(target, KEY);
+    },
 });

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

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

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

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

package/dist/operations/catalogue/sway.js

@@ -0,0 +1,23 @@
+// Sway — the object rocks about its base like something tall in a light wind:
+// a pendulum swing with a touch of second harmonic, so it lingers at the ends.
+import { Vector3 } from 'three';
+import { DURATION, heldPhysical } from './physicalHeld.js';
+const AXES = { side: new Vector3(0, 0, 1), front: new Vector3(1, 0, 0) };
+export default heldPhysical({
+    value: 'sway', label: 'Sway',
+    description: 'Rock gently about its base, like something tall in a light wind',
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'side', options: [{ value: 'side', label: 'Side to side' }, { value: 'front', label: 'Front to back' }] },
+        angle: { type: 'number', label: 'Angle', default: 7, min: 0.5, max: 45, step: 0.5, unit: '°' },
+        speed: { type: 'number', label: 'Speed', default: 1, min: 0.1, max: 5, step: 0.05, unit: '×' },
+        duration: { ...DURATION, default: 3 },
+    },
+    memory: () => null,
+    move(part, st, time) {
+        const p = st.p;
+        const w = 2 * Math.PI * 0.4 * Number(p.speed) * time;
+        const swing = (Math.sin(w) + 0.14 * Math.sin(3 * w)) / 0.86; // flatter at the ends
+        part.q.setFromAxisAngle(AXES[String(p.direction)] ?? AXES.side, swing * (Number(p.angle) * Math.PI / 180) * st.amp.v);
+        part.pivot.copy(st.body.bottomLocal);
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"swirl.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/swirl.ts"],"names":[],"mappings":";AAgCA,wBAwCG"}
+{"version":3,"file":"swirl.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/swirl.ts"],"names":[],"mappings":";AAgCA,wBAyCG"}

package/dist/operations/catalogue/swirl.js

@@ -22,7 +22,7 @@ function pose(target, st, p) {
     const q = new Quaternion().setFromAxisAngle(UP, dir * turns * 2 * Math.PI * 1.6 * t * t);
     const k = 1 - smoothstep(0.3, 1, t);
     const s = new Vector3(1, 1, 1).multiplyScalar(Math.max(k, 1e-4));
-    poseAbout(target, r, r.centerLocal, q, s, off);
+    poseAbout(target, r, r.centerLocal, q, s, off, KEY);
 }
 const smoothstep = (a, b, x) => { const v = Math.min(1, Math.max(0, (x - a) / (b - a))); return v * v * (3 - 2 * v); };
 export default defineOperation({
@@ -32,7 +32,8 @@ export default defineOperation({
     channel: 'transform',
     multi: true,
     toggles: true,
-    usableIn: ['interaction', 'action'],
+    usableIn: ['interaction', 'action', 'object'],
+    presence: 'vanish',
     params: {
         turns: { type: 'number', label: 'Turns', default: 1.5, min: 0.5, max: 6, step: 0.25 },
         radius: { type: 'number', label: 'Radius', default: 0.6, min: 0, max: 3, step: 0.05, hint: 'A fraction of the object’s width' },
@@ -43,7 +44,7 @@ export default defineOperation({
     apply(target, p) {
         let st = target.userData[KEY];
         if (!st) {
-            st = { rest: acquireRest(target), proxy: { t: 0 }, visible: target.visible };
+            st = { rest: acquireRest(target, KEY), proxy: { t: 0 }, visible: target.visible };
             target.userData[KEY] = st;
         }
         const s = st;
@@ -58,12 +59,12 @@ export default defineOperation({
         const s = target.userData[KEY];
         if (!s)
             return;
-        target.visible = s.visible;
+        target.visible = true; // it comes back shown (it may have been made while the object was hidden)
         gsap.killTweensOf(s.proxy);
         gsap.to(s.proxy, {
             t: 0, duration: Number(p.duration), ease: 'power2.out',
             onUpdate: () => pose(target, s, p),
-            onComplete: () => { delete target.userData[KEY]; releaseRest(target); },
+            onComplete: () => { delete target.userData[KEY]; releaseRest(target, KEY); },
         });
     },
 });

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