@3driseai/3drise-viewer 0.1.28 → 0.1.29

package/dist/operations/catalogue/print3d.js

@@ -16,7 +16,7 @@
 import { BackSide, Color, Mesh, MeshStandardMaterial } from 'three';
 import { defineOperation } from '../types.js';
 import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
-import { createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress } from './transitionField.js';
+import { createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setReveal } from './transitionField.js';
 import { hideUntilWarm } from './warmup.js';
 const P = 'Prt';
 const KEY = 'print3d';
@@ -60,6 +60,7 @@ function mainLayer(st) {
         diffuse: /* glsl */ `
         if (uPrtKeep > 0.5) {
           prtPreview(diffuseColor.rgb);
+          if (uPrtReveal > 0.5 && prtConv < 0.5) discard;     // revealed by the print: nothing above the nozzle
           if (prtConv > 0.5) diffuseColor.rgb = prtCol * mix(0.22, 1.0, prtGap);
         } else {
           if (prtAge(vPrtR, vPrtQ) < 0.0) discard;
@@ -206,6 +207,7 @@ export default defineOperation({
         disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object turns into its slicer preview and stays' },
     },
     objectParams: { disappear: false },
+    presence: 'paint',
     apply(target, p) {
         let st = target.userData[STATE];
         if (!st) {
@@ -247,6 +249,7 @@ export default defineOperation({
         s.lines.value = Number(p.lines);
         s.palette.value = Math.max(0, PALETTES.findIndex(o => o.value === p.preview));
         s.keep.value = p.disappear === false ? 1 : 0;
+        setReveal(s.field, p);
         // the preview never cuts the object open: the inside is only for the un-print
         s.caps.forEach(c => { c.visible = !s.keep.value; });
         if (s.keep.value) {
@@ -262,6 +265,7 @@ export default defineOperation({
         if (!s)
             return;
         hideMeshes(target, KEY, false);
+        setReveal(s.field, p);
         s.caps.forEach(c => { c.visible = !s.keep.value; });
         return runProgress(target, s.field, 0, {
             duration: Number(p.duration), ease: 'none',

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

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

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

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

package/dist/operations/catalogue/pulse.js

@@ -0,0 +1,29 @@
+// Pulse — the object swells and settles about its centre. "Breathe" is a slow
+// rise with a longer fall; "Heartbeat" is the double beat (lub-dub) and a rest.
+import { DURATION, heldPhysical } from './physicalHeld.js';
+const bump = (x, at, width) => Math.exp(-(((x - at) / width) ** 2));
+export default heldPhysical({
+    value: 'pulse', label: 'Pulse',
+    description: 'Swell and settle — a slow breath, or a double heartbeat',
+    params: {
+        style: { type: 'select', label: 'Style', default: 'breathe', options: [{ value: 'breathe', label: 'Breathe' }, { value: 'heartbeat', label: 'Heartbeat' }] },
+        amount: { type: 'number', label: 'Amount', default: 0.06, min: 0.005, max: 0.6, step: 0.005, hint: 'How much bigger it gets' },
+        speed: { type: 'number', label: 'Beats', default: 0.5, min: 0.05, max: 4, step: 0.05, unit: '/s' },
+        duration: { ...DURATION, default: 4 },
+    },
+    memory: () => null,
+    move(part, st, time) {
+        const p = st.p;
+        const ph = (time * Number(p.speed)) % 1;
+        let k;
+        if (p.style === 'heartbeat')
+            k = bump(ph, 0.12, 0.05) + 0.62 * bump(ph, 0.34, 0.065);
+        else {
+            // in over 40% of the breath, out over the rest
+            const u = ph < 0.4 ? ph / 0.4 : 1 - (ph - 0.4) / 0.6;
+            k = u * u * (3 - 2 * u);
+        }
+        part.s.setScalar(1 + Number(p.amount) * k * st.amp.v);
+        part.pivot.copy(st.body.centerLocal);
+    },
+});

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

@@ -1,21 +1,19 @@
 import { Quaternion, Vector3 } from 'three';
 import type { Object3D } from 'three';
 export interface RestPose {
-    position: Vector3;
-    quaternion: Quaternion;
-    scale: Vector3;
     /** Bounds centre and bottom in the object's own local space (unscaled). */
     centerLocal: Vector3;
     bottomLocal: Vector3;
     /** World-space size at rest. */
     size: Vector3;
-    users: number;
 }
-export declare function acquireRest(target: Object3D): RestPose;
-export declare function releaseRest(target: Object3D): void;
+/** Start posing the object. `key`: the operation's own, so two operations stack instead of overwriting. */
+export declare function acquireRest(target: Object3D, key?: string): RestPose;
+/** Stop posing: this operation's part goes, the object returns to rest (or to what the others hold). */
+export declare function releaseRest(target: Object3D, key?: string): void;
 /**
  * Pose the object as rest ∘ (rotation `q` and non-uniform scale `s` about the local
  * `pivot`), then offset by `worldOffset`. The pivot stays where it is at rest.
  */
-export declare function poseAbout(target: Object3D, r: RestPose, pivot: Vector3, q: Quaternion, s: Vector3, worldOffset?: Vector3): void;
+export declare function poseAbout(target: Object3D, _r: RestPose, pivot: Vector3, q: Quaternion, s: Vector3, worldOffset?: Vector3, key?: string): void;
 //# sourceMappingURL=restPose.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"restPose.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/restPose.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,MAAM,WAAW,QAAQ;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,gCAAgC;IAChC,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB;AAID,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAgBtD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,QAQ3C;AAGD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,QAaxH"}
+{"version":3,"file":"restPose.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/restPose.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGtC,MAAM,WAAW,QAAQ;IACrB,2EAA2E;IAC3E,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,gCAAgC;IAChC,IAAI,EAAE,OAAO,CAAC;CACjB;AAID,2GAA2G;AAC3G,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,SAAU,GAAG,QAAQ,CAErE;AAED,wGAAwG;AACxG,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,SAAU,QAE1D;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,OAAO,EAAE,GAAG,SAAU,QAKxI"}

package/dist/operations/catalogue/restPose.js

@@ -1,55 +1,25 @@
-// Rest pose for transform operations: captured once when the first transform
-// effect starts on an object, released when the last one ends, so effects that
-// overlap (a jelly during a flip) always return to the authored pose.
-import { Box3, Vector3 } from 'three';
-const KEY = '__opRestPose';
-export function acquireRest(target) {
-    let r = target.userData[KEY];
-    if (!r) {
-        target.updateWorldMatrix(true, true);
-        const box = new Box3().setFromObject(target);
-        const c = box.getCenter(new Vector3());
-        const bottom = new Vector3(c.x, box.min.y, c.z);
-        r = {
-            position: target.position.clone(), quaternion: target.quaternion.clone(), scale: target.scale.clone(),
-            centerLocal: target.worldToLocal(c.clone()), bottomLocal: target.worldToLocal(bottom),
-            size: box.getSize(new Vector3()), users: 0,
-        };
-        target.userData[KEY] = r;
-    }
-    r.users++;
-    return r;
+import { composeMix, joinMix, leaveMix } from './physicalMix.js';
+const DEFAULT = 'rest';
+/** Start posing the object. `key`: the operation's own, so two operations stack instead of overwriting. */
+export function acquireRest(target, key = DEFAULT) {
+    return joinMix(target, key).body;
 }
-export function releaseRest(target) {
-    const r = target.userData[KEY];
-    if (!r)
-        return;
-    r.users--;
-    if (r.users <= 0) {
-        target.position.copy(r.position);
-        target.quaternion.copy(r.quaternion);
-        target.scale.copy(r.scale);
-        delete target.userData[KEY];
-    }
+/** Stop posing: this operation's part goes, the object returns to rest (or to what the others hold). */
+export function releaseRest(target, key = DEFAULT) {
+    leaveMix(target, key);
 }
-const _v = new Vector3();
 /**
  * Pose the object as rest ∘ (rotation `q` and non-uniform scale `s` about the local
  * `pivot`), then offset by `worldOffset`. The pivot stays where it is at rest.
  */
-export function poseAbout(target, r, pivot, q, s, worldOffset) {
-    // local pivot → parent space at rest, and under the new rotation/scale
-    const restP = _v.copy(pivot).multiply(r.scale).applyQuaternion(r.quaternion);
-    const newQ = r.quaternion.clone().multiply(q);
-    const newS = r.scale.clone().multiply(s);
-    const nowP = pivot.clone().multiply(newS).applyQuaternion(newQ);
-    target.quaternion.copy(newQ);
-    target.scale.copy(newS);
-    target.position.copy(r.position).add(restP).sub(nowP);
-    if (worldOffset && target.parent) {
-        const w = target.parent.localToWorld(target.position.clone()).add(worldOffset);
-        target.position.copy(target.parent.worldToLocal(w));
-    }
-    else if (worldOffset)
-        target.position.add(worldOffset);
+export function poseAbout(target, _r, pivot, q, s, worldOffset, key = DEFAULT) {
+    const { part } = joinMix(target, key);
+    part.pivot.copy(pivot);
+    part.q.copy(q);
+    part.s.copy(s);
+    if (worldOffset)
+        part.off.copy(worldOffset);
+    else
+        part.off.set(0, 0, 0);
+    composeMix(target);
 }

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

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

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

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

package/dist/operations/catalogue/rotate.js

@@ -0,0 +1,49 @@
+// Rotate — the object turns steadily about its own axes, through its centre.
+// One axis is a plain turn; two or three together is a turn about their diagonal
+// (a tumble). Switching on spins it up; switching off lets it coast to the nearest
+// whole turn, so it always stops facing the way it started. The other way round
+// is the playback's Reverse.
+import { Vector3 } from 'three';
+import { multiValues } from '../types.js';
+import { DURATION, heldPhysical, periodicEase } from './physicalHeld.js';
+const AXES = { x: new Vector3(1, 0, 0), y: new Vector3(0, 1, 0), z: new Vector3(0, 0, 1) };
+const TAU = Math.PI * 2;
+const _axis = new Vector3();
+/** The axis to turn about: the chosen ones together (their diagonal). */
+function axisOf(value) {
+    _axis.set(0, 0, 0);
+    for (const k of multiValues(value))
+        if (AXES[k])
+            _axis.add(AXES[k]);
+    return _axis.lengthSq() > 0 ? _axis.normalize() : _axis.copy(AXES.y);
+}
+export default heldPhysical({
+    value: 'rotate', label: 'Rotate',
+    description: 'Turn steadily about its own axes — spins up, and coasts to a stop facing the way it started',
+    ease: 'none',
+    params: {
+        axis: { type: 'multi', label: 'Axes', default: 'y', options: [{ value: 'x', label: 'X' }, { value: 'y', label: 'Y' }, { value: 'z', label: 'Z' }], hint: 'Pick one, or several to tumble about them together' },
+        speed: { type: 'number', label: 'Speed', default: 0.2, min: 0.01, max: 4, step: 0.01, unit: 'turns/s' },
+        duration: { ...DURATION, default: 5 },
+    },
+    memory: () => ({ angle: 0, from: 0, to: 0 }),
+    onOut(st) {
+        // land on a whole turn ahead: at least what the current speed would cover while slowing
+        const m = st.mem, dir = st.p.__backward === true ? -1 : 1;
+        const coast = TAU * Number(st.p.speed) * periodicEase(Number(st.p.duration)) * 0.5 * st.amp.v;
+        m.from = m.angle;
+        m.to = dir * Math.ceil((dir * m.angle + coast - 1e-6) / TAU) * TAU;
+    },
+    move(part, st, _time, dt) {
+        const p = st.p, m = st.mem, a = st.amp.v;
+        if (st.out) {
+            const u = 1 - a; // 0 → 1 over the stop
+            m.angle = m.from + (m.to - m.from) * (1 - (1 - u) * (1 - u));
+        }
+        else {
+            m.angle += TAU * Number(p.speed) * a * a * dt; // spins up (dt is negative when played backwards)
+        }
+        part.q.setFromAxisAngle(axisOf(p.axis), m.angle);
+        part.pivot.copy(st.body.centerLocal);
+    },
+});

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