@3driseai/3drise-viewer 0.1.28 → 0.1.30

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

@@ -0,0 +1,45 @@
+import { Quaternion, Vector3 } from 'three';
+import type { Object3D } from 'three';
+/** One effect's contribution. Mutate it in place (in a tween's onUpdate, or in `sample`). */
+export interface MixPart {
+    /** Turn about the pivot, in the object's own axes. */
+    q: Quaternion;
+    /** Scale about the pivot. */
+    s: Vector3;
+    /** The point that stays put under q / s, in the object's local space. */
+    pivot: Vector3;
+    /** Offset in world units. */
+    off: Vector3;
+    /** Called each frame before composing: time and delta in seconds. */
+    sample?: (part: MixPart, time: number, dt: number) => void;
+}
+/** What an effect needs to know about the object it moves (measured when its first part joined). */
+export interface MixBody {
+    /** Bounds centre and bottom-centre, in the object's local space. */
+    centerLocal: Vector3;
+    bottomLocal: Vector3;
+    /** World-space size. */
+    size: Vector3;
+}
+/**
+ * Compose now — one object's mix, or all of them. Call it after something else
+ * wrote the object's transform in this frame (the object's frame hook does).
+ */
+export declare function tickMix(target?: Object3D | null): void;
+/** Add (or get) this effect's part on the object. `key` is the effect's own. */
+export declare function joinMix(target: Object3D, key: string, sample?: MixPart['sample']): {
+    part: MixPart;
+    body: MixBody;
+};
+/** Take this effect's part off. With the last part gone the object is back on its base. */
+export declare function leaveMix(target: Object3D, key: string): void;
+/** Compose this object now (after changing a part outside the ticker). */
+export declare function composeMix(target: Object3D): void;
+/** The object's base transform while effects move it (its own transform otherwise). */
+export declare function mixBase(target: Object3D): {
+    position: Vector3;
+    quaternion: Quaternion;
+    scale: Vector3;
+};
+export declare const isMixed: (target: Object3D) => boolean;
+//# sourceMappingURL=physicalMix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"physicalMix.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/physicalMix.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAQ,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,6FAA6F;AAC7F,MAAM,WAAW,OAAO;IACpB,sDAAsD;IACtD,CAAC,EAAE,UAAU,CAAC;IACd,6BAA6B;IAC7B,CAAC,EAAE,OAAO,CAAC;IACX,yEAAyE;IACzE,KAAK,EAAE,OAAO,CAAC;IACf,6BAA6B;IAC7B,GAAG,EAAE,OAAO,CAAC;IACb,qEAAqE;IACrE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;CAC9D;AAED,oGAAoG;AACpG,MAAM,WAAW,OAAO;IACpB,oEAAoE;IACpE,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,wBAAwB;IACxB,IAAI,EAAE,OAAO,CAAC;CACjB;AA+DD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,IAAI,QAK/C;AAED,gFAAgF;AAChF,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAmBnH;AAED,2FAA2F;AAC3F,wBAAgB,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,QAOrD;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,MAAM,EAAE,QAAQ,QAAqD;AAEhG,uFAAuF;AACvF,wBAAgB,OAAO,CAAC,MAAM,EAAE,QAAQ,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAGvG;AAED,eAAO,MAAM,OAAO,GAAI,QAAQ,QAAQ,YAAsB,CAAC"}

package/dist/operations/catalogue/physicalMix.js

@@ -0,0 +1,144 @@
+// Physical mix — how effects move an object without owning its transform.
+//
+// A physical effect never writes position / rotation / scale itself. It adds a
+// *part* to the object's mix: a turn and a scale about a pivot, plus a world
+// offset. Each frame the mix lays every part over the object's BASE transform —
+// the one the scene authored or animates — and writes the result. So:
+//
+//   - effects stack: float + sway + a jelly all show at once, in the order they joined;
+//   - the base stays free: move the object in the studio, keyframe it, play a clip —
+//     the effects ride on top. The mix notices any transform it did not write itself
+//     and takes it as the new base;
+//   - when the last part leaves, the object is back on its base exactly.
+//
+// The mix is composed from the gsap ticker and, for objects in the React tree,
+// again from the object's own frame hook (after its property animations wrote,
+// before the render) — see tickMix. Composing twice in a frame is harmless.
+import { gsap } from 'gsap';
+import { Box3, Quaternion, Vector3 } from 'three';
+const mixes = new Map();
+let ticking = false;
+const _a = new Vector3(), _b = new Vector3(), _P = new Vector3(), _S = new Vector3(), _W = new Vector3();
+const _Q = new Quaternion();
+function measure(target) {
+    target.updateWorldMatrix(true, true);
+    const box = new Box3().setFromObject(target);
+    if (box.isEmpty())
+        return { centerLocal: new Vector3(), bottomLocal: new Vector3(), size: new Vector3(1, 1, 1) };
+    const c = box.getCenter(new Vector3());
+    const bottom = new Vector3(c.x, box.min.y, c.z);
+    return { centerLocal: target.worldToLocal(c.clone()), bottomLocal: target.worldToLocal(bottom), size: box.getSize(new Vector3()) };
+}
+/** Lay the parts over the base and write the transform. */
+function compose(m) {
+    const t = m.target;
+    // a transform we did not write = the scene moved the object: that is the new base
+    if (!t.position.equals(m.lastP))
+        m.baseP.copy(t.position);
+    if (!t.quaternion.equals(m.lastQ))
+        m.baseQ.copy(t.quaternion);
+    if (!t.scale.equals(m.lastS))
+        m.baseS.copy(t.scale);
+    _P.copy(m.baseP);
+    _Q.copy(m.baseQ);
+    _S.copy(m.baseS);
+    _W.set(0, 0, 0);
+    for (const part of m.parts.values()) {
+        // the pivot keeps its place in the parent's space under this part's turn and scale
+        _a.copy(part.pivot).multiply(_S).applyQuaternion(_Q);
+        _Q.multiply(part.q);
+        _S.multiply(part.s);
+        _b.copy(part.pivot).multiply(_S).applyQuaternion(_Q);
+        _P.add(_a).sub(_b);
+        _W.add(part.off);
+    }
+    if (_W.lengthSq() > 0) {
+        if (t.parent) {
+            t.parent.localToWorld(_P).add(_W);
+            t.parent.worldToLocal(_P);
+        }
+        else
+            _P.add(_W);
+    }
+    t.position.copy(_P);
+    t.quaternion.copy(_Q);
+    t.scale.copy(_S);
+    m.lastP.copy(t.position);
+    m.lastQ.copy(t.quaternion);
+    m.lastS.copy(t.scale);
+}
+function step(m, now) {
+    // time moves once per frame, however often the mix is composed in it
+    const dt = m.stamp ? Math.min(0.1, (now - m.stamp) / 1000) : 0;
+    if (dt > 0 || !m.stamp) {
+        m.stamp = now;
+        m.time += dt;
+        for (const part of m.parts.values())
+            part.sample?.(part, m.time, dt);
+    }
+    compose(m);
+}
+const tickAll = () => { const now = performance.now(); mixes.forEach(m => step(m, now)); };
+/**
+ * Compose now — one object's mix, or all of them. Call it after something else
+ * wrote the object's transform in this frame (the object's frame hook does).
+ */
+export function tickMix(target) {
+    if (!mixes.size)
+        return;
+    if (!target) {
+        tickAll();
+        return;
+    }
+    const m = mixes.get(target);
+    if (m)
+        step(m, performance.now());
+}
+/** Add (or get) this effect's part on the object. `key` is the effect's own. */
+export function joinMix(target, key, sample) {
+    let m = mixes.get(target);
+    if (!m) {
+        m = {
+            target, ...measure(target),
+            baseP: target.position.clone(), baseQ: target.quaternion.clone(), baseS: target.scale.clone(),
+            lastP: target.position.clone(), lastQ: target.quaternion.clone(), lastS: target.scale.clone(),
+            parts: new Map(), time: 0, stamp: 0,
+        };
+        mixes.set(target, m);
+        if (!ticking) {
+            ticking = true;
+            gsap.ticker.add(tickAll);
+        }
+    }
+    let part = m.parts.get(key);
+    if (!part) {
+        part = { q: new Quaternion(), s: new Vector3(1, 1, 1), pivot: m.centerLocal.clone(), off: new Vector3() };
+        m.parts.set(key, part);
+    }
+    if (sample)
+        part.sample = sample;
+    return { part, body: m };
+}
+/** Take this effect's part off. With the last part gone the object is back on its base. */
+export function leaveMix(target, key) {
+    const m = mixes.get(target);
+    if (!m || !m.parts.delete(key))
+        return;
+    compose(m);
+    if (m.parts.size)
+        return;
+    mixes.delete(target);
+    if (!mixes.size && ticking) {
+        ticking = false;
+        gsap.ticker.remove(tickAll);
+    }
+}
+/** Compose this object now (after changing a part outside the ticker). */
+export function composeMix(target) { const m = mixes.get(target); if (m)
+    compose(m); }
+/** The object's base transform while effects move it (its own transform otherwise). */
+export function mixBase(target) {
+    const m = mixes.get(target);
+    return m ? { position: m.baseP, quaternion: m.baseQ, scale: m.baseS } : target;
+}
+export const isMixed = (target) => mixes.has(target);

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

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

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

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

package/dist/operations/catalogue/pop.js

@@ -0,0 +1,44 @@
+// Pop — pressure builds inside the object: it inflates while its first shape
+// modes ring faster and faster (it bulges unevenly, one way then the other —
+// an underdamped spring being driven), then it bursts to nothing in a few frames.
+// The way back: it pops out of nothing, overshoots and rings down like jelly
+// until it is exactly at rest.
+import { physicalExit, ring, smooth } from './physicalExit.js';
+const INFLATE_END = 0.84;
+export default physicalExit({
+    value: 'pop',
+    label: 'Pop',
+    description: 'Inflates and wobbles under rising pressure, then bursts to nothing — it pops back out of nothing and rings down',
+    params: {
+        inflate: { type: 'number', label: 'Inflate', default: 0.28, min: 0, max: 1, step: 0.01, hint: 'How much bigger it gets before it bursts' },
+        wobble: { type: 'number', label: 'Wobble', default: 0.09, min: 0, max: 0.3, step: 0.005, hint: 'How unevenly it bulges' },
+        rings: { type: 'number', label: 'Rings', default: 3, min: 1, max: 7, step: 0.5, hint: 'Wobbles as it settles on the way back' },
+        duration: { type: 'number', label: 'Duration', default: 1.1, min: 0.3, max: 5, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const p = a.p;
+        const t = Math.min(1, u / INFLATE_END);
+        const k = 1 + Number(p.inflate) * Math.pow(smooth(0, 1, t), 1.4);
+        // the two shape modes, driven faster as the pressure rises (phase ∝ t + t²)
+        const amp = Number(p.wobble) * smooth(0.12, 0.9, t);
+        const ph = 2 * Math.PI * (2.2 * t + 5.5 * t * t);
+        const m1 = amp * Math.sin(ph), m2 = amp * Math.sin(1.37 * ph + 2.1);
+        // the burst: a last swell, gone within ~15% of the duration
+        const b = smooth(INFLATE_END, 1, u);
+        const burst = (1 + 0.22 * Math.sin(Math.PI * Math.min(1, b * 1.6))) * Math.pow(1 - b, 2);
+        const g = k * burst;
+        out.s.set(g * (1 + m1 - 0.5 * m2), g * (1 - m1), g * (1 + m2 - 0.5 * m1));
+    },
+    enter(v, out, a) {
+        const p = a.p;
+        // out of nothing: a quick spring past full size
+        const grow = 1 - Math.pow(1 - smooth(0, 0.22, v), 3);
+        const sg = Math.max(0, (v - 0.12) / 0.88);
+        const n = Number(p.rings);
+        const r = 0.22 * ring(sg, n / 2, 3.4); // overshoots first, rings down to exactly 1
+        // the ring alternates which way it bulges (the same shape modes as the exit)
+        const w = Number(p.wobble) * 1.8 * ring(sg, n / 2 + 0.25, 3.4);
+        const g = grow * (1 + r);
+        out.s.set(g * (1 + w), g * (1 - w), g * (1 + 0.6 * w));
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/portal.ts"],"names":[],"mappings":";AAoIA,wBAsFG"}
+{"version":3,"file":"portal.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/portal.ts"],"names":[],"mappings":";AA6IA,wBAiGG"}

package/dist/operations/catalogue/portal.js

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

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

@@ -1 +1 @@
-{"version":3,"file":"print3d.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/print3d.ts"],"names":[],"mappings":";AA8MA,wBAgFG"}
+{"version":3,"file":"print3d.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/print3d.ts"],"names":[],"mappings":";AA+MA,wBAmFG"}

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

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