@3driseai/3drise-viewer 0.1.28 → 0.1.30

package/dist/operations/catalogue/turnAway.js

@@ -0,0 +1,54 @@
+// Turn away — the object turns like a card and leaves edge-on. It spins up about
+// a vertical (or horizontal) axis and, as it comes round to face the camera with
+// its edge, the side that would face you thins away — it vanishes at the moment
+// it is edge-on. The way back: it turns into view from a sliver, slowing, and
+// settles with a small overshoot.
+import { Quaternion, Vector3 } from 'three';
+import { physicalExit, ring, smooth } from './physicalExit.js';
+const _q = new Quaternion(), _q2 = new Quaternion(), _e = new Vector3();
+/** Total turn: whole turns, then the quarter that brings it edge-on. */
+const angleOf = (a) => (Number(a.p.turns) + 0.25) * 2 * Math.PI * (a.p.reverse ? -1 : 1);
+/**
+ * Turn by `th` about the chosen screen axis and thin `thin` (0…1) the side that ends up
+ * across the view when the full turn `end` is reached.
+ */
+function pose(out, a, th, end, thin) {
+    const f = a.frame;
+    const vertical = a.p.axis !== 'horizontal';
+    const turnAxis = vertical ? f.up : f.right;
+    _q.setFromAxisAngle(turnAxis, th);
+    out.q.copy(a.local(_q));
+    // the rest-pose direction that the end turn carries onto the collapsing screen axis
+    _e.copy(vertical ? f.right : f.up).applyQuaternion(_q2.setFromAxisAngle(turnAxis, -end));
+    const k = 1 - thin;
+    out.s.set(1, 1, 1).setComponent(a.axis(_e), Math.max(k, 0));
+}
+export default physicalExit({
+    value: 'turnAway',
+    label: 'Turn away',
+    description: 'Turns like a card and vanishes edge-on — it turns back into view from a sliver',
+    params: {
+        axis: {
+            type: 'select', label: 'Turns about', default: 'vertical', options: [{ value: 'vertical', label: 'Its upright axis' }, { value: 'horizontal', label: 'A level axis (flips over)' }],
+        },
+        turns: { type: 'number', label: 'Turns', default: 1, min: 0, max: 5, step: 0.25, hint: 'Whole turns before it goes edge-on' },
+        reverse: { type: 'boolean', label: 'Other way', default: false },
+        duration: { type: 'number', label: 'Duration', default: 1.2, min: 0.3, max: 6, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const end = angleOf(a);
+        // spins up (turn ∝ u²); the side across the view thins over the last quarter turn
+        const th = end * u * u;
+        const last = 1 - 0.25 / (Number(a.p.turns) + 0.25); // where the last quarter starts, in turn share
+        const thin = smooth(Math.sqrt(Math.max(0, last)) * 0.98, 1, u);
+        pose(out, a, th, end, thin);
+    },
+    enter(v, out, a) {
+        const end = angleOf(a);
+        // from edge-on (−end) back to facing, slowing; a small overshoot at the end
+        const left = 1 - v;
+        const th = -end * Math.pow(left, 2.2) + 0.12 * Math.sign(end) * ring(smooth(0.55, 1, v), 1, 3);
+        const thin = 1 - smooth(0, 0.3, v);
+        pose(out, a, th, -end, thin);
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"unweave.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/unweave.ts"],"names":[],"mappings":";AA2EA,wBA+IG"}
+{"version":3,"file":"unweave.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/unweave.ts"],"names":[],"mappings":";AA+EA,wBAgKG"}

package/dist/operations/catalogue/unweave.js

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

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

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

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

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

package/dist/operations/catalogue/vortexDrain.js

@@ -0,0 +1,68 @@
+// Vortex drain — the object is caught by a whirlpool under it and drained away.
+// It is drawn out onto an orbit, then spirals in and down the funnel, keeping
+// its angular momentum: ω ∝ L / r², so it whirls faster and faster as the orbit
+// tightens, spins up about its own axis, leans into the funnel and shrinks into
+// the point below its base. The way back is the drain run backwards, a fountain:
+// it is flung up out of the point, slows as the orbit widens and is set down.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, smooth } from './physicalExit.js';
+const N = 512;
+const _q = new Quaternion(), _t = new Quaternion(), _axis = new Vector3();
+/** Orbit radius (fraction of the widest): opens to its widest a third of the way in, closes to 0. */
+const radiusAt = (u) => Math.sin(Math.PI * Math.pow(clamp01(u), 0.6));
+/** Angle along the drain at u, read from the integrated table. */
+function thetaAt(tab, u) {
+    const x = clamp01(u) * (N - 1), i = Math.floor(x), f = x - i;
+    return i >= N - 1 ? tab.theta[N - 1] : tab.theta[i] * (1 - f) + tab.theta[i + 1] * f;
+}
+export default physicalExit({
+    value: 'vortexDrain',
+    label: 'Vortex drain',
+    description: 'Caught by a whirlpool: it spirals in and down, spinning faster as the orbit tightens, and drains away — reverting flings it back up out of the funnel',
+    params: {
+        turns: { type: 'number', label: 'Turns', default: 3, min: 0.5, max: 10, step: 0.25, hint: 'Times round the funnel' },
+        radius: { type: 'number', label: 'Orbit', default: 0.7, min: 0, max: 3, step: 0.05, hint: 'Widest orbit, × its width' },
+        depth: { type: 'number', label: 'Depth', default: 0.9, min: 0, max: 4, step: 0.05, hint: 'How far it sinks, × its height' },
+        lean: { type: 'number', label: 'Lean', default: 22, min: 0, max: 60, step: 1, unit: '°', hint: 'How much it leans into the funnel' },
+        reverse: { type: 'boolean', label: 'Clockwise', default: false },
+        duration: { type: 'number', label: 'Duration', default: 2.4, min: 0.4, max: 10, step: 0.05, unit: 's' },
+    },
+    prepare({ p }) {
+        // integrate θ' = L(u) / (r² + ε²): angular momentum arrives as it is caught, then is kept
+        const theta = new Float32Array(N);
+        let acc = 0;
+        for (let i = 1; i < N; i++) {
+            const u = (i - 0.5) / (N - 1);
+            const r = radiusAt(u);
+            const L = smooth(0, 0.3, u);
+            acc += L / (r * r + 0.09) / (N - 1);
+            theta[i] = acc;
+        }
+        const k = (Number(p.turns) * 2 * Math.PI) / Math.max(acc, 1e-6) * (p.reverse ? -1 : 1);
+        for (let i = 0; i < N; i++)
+            theta[i] *= k;
+        return { theta };
+    },
+    exit(u, out, a) { drain(u, out, a); },
+    // the drain backwards in time: out of the point, the orbit widening, the whirl slowing
+    enter(v, out, a) { drain(1 - v, out, a); },
+});
+function drain(u, out, a) {
+    const p = a.p, f = a.frame;
+    const R = Math.max(a.size.x, a.size.z) * Number(p.radius) * radiusAt(u);
+    const th = thetaAt(a.mem, u);
+    const c = Math.cos(th), s = Math.sin(th);
+    const sink = Number(p.depth) * a.size.y * Math.pow(u, 2.2);
+    out.off.set(0, 0, 0)
+        .addScaledVector(f.right, R * c)
+        .addScaledVector(f.toward, R * s)
+        .addScaledVector(f.up, -sink);
+    // spins about its own up with the whirl (a little faster), leans its top in towards the axis
+    _q.setFromAxisAngle(f.up, th * 1.25);
+    const lean = (Number(p.lean) * Math.PI / 180) * smooth(0.05, 0.5, u) * (1 - smooth(0.85, 1, u) * 0.5);
+    // the tangent of the orbit: leaning about it tips the top towards the funnel's axis
+    _axis.set(0, 0, 0).addScaledVector(f.right, -s).addScaledVector(f.toward, c).normalize();
+    _t.setFromAxisAngle(_axis, lean); // + about the tangent tips the top inwards (t × up = −radial)
+    out.q.copy(a.local(_t.multiply(_q)));
+    out.s.setScalar(1 - smooth(0.4, 1, u));
+}

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

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

package/dist/operations/catalogue/voxelize.js

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

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

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

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

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

package/dist/operations/catalogue/warp.js

@@ -0,0 +1,73 @@
+// Warp — a jump to hyperspace. The object charges: it draws back a touch and
+// compresses along its heading with a fine hum, then stretches far along it
+// while thinning across (volume kept) and accelerates exponentially, gone in a
+// few frames. The way back: it shoots in stretched, decelerating exponentially,
+// snaps out of the stretch on arrival and jiggles until it is exactly at rest.
+import { Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth, stretchAxis } from './physicalExit.js';
+const ARRIVE = 0.55;
+const _d = new Vector3();
+function dirOf(f, d) {
+    if (d === 'right')
+        return _d.copy(f.right);
+    if (d === 'left')
+        return _d.copy(f.right).negate();
+    if (d === 'up')
+        return _d.copy(f.up);
+    return _d.copy(f.toward).negate(); // away, into the scene
+}
+export default physicalExit({
+    value: 'warp',
+    label: 'Warp',
+    description: 'Charges, then stretches along its heading and jumps away in a blink — it shoots back in, snaps out of the stretch and jiggles to rest',
+    params: {
+        direction: {
+            type: 'select', label: 'Direction', default: 'right', options: [
+                { value: 'right', label: 'Right' }, { value: 'away', label: 'Away' }, { value: 'left', label: 'Left' }, { value: 'up', label: 'Up' },
+            ], hint: 'Screen-relative when it starts',
+        },
+        stretch: { type: 'number', label: 'Stretch', default: 3, min: 1, max: 8, step: 0.1, unit: '×', hint: 'How long it gets at the jump' },
+        charge: { type: 'number', label: 'Charge', default: 0.55, min: 0.1, max: 0.85, step: 0.01, hint: 'Share of the duration spent charging' },
+        distance: { type: 'number', label: 'Distance', default: 30, min: 5, max: 120, step: 1, hint: 'How far it jumps, × its size' },
+        duration: { type: 'number', label: 'Duration', default: 1.4, min: 0.3, max: 6, step: 0.05, unit: 's' },
+    },
+    exit(u, out, a) {
+        const p = a.p, D = Number(p.duration);
+        const d = dirOf(a.frame, p.direction);
+        const axis = a.axis(d);
+        const C = Number(p.charge), S = Number(p.stretch), L = Number(p.distance) * a.span;
+        if (u < C) {
+            const t = u / C;
+            // draws back a little and compresses along the heading; a fine hum builds
+            const c = smooth(0, 1, t);
+            const hum = 0.012 * smooth(0.3, 0.8, t) * (1 - smooth(0.9, 1, t)) * Math.sin(2 * Math.PI * 24 * u * D);
+            out.off.copy(d).multiplyScalar(-0.06 * a.span * c);
+            stretchAxis(out.s, axis, 1 - 0.14 * c + hum);
+            return;
+        }
+        const tau = (u - C) / (1 - C);
+        const k = 6;
+        const x = (Math.exp(k * tau) - 1) / (Math.exp(k) - 1); // exponential take-off
+        out.off.copy(d).multiplyScalar(-0.06 * a.span + (L + 0.06 * a.span) * x);
+        const s = 0.86 + (S - 0.86) * smooth(0, 0.35, tau);
+        stretchAxis(out.s, axis, s, 1 - smooth(0.7, 1, tau));
+    },
+    enter(v, out, a) {
+        const p = a.p;
+        const d = dirOf(a.frame, p.direction);
+        const axis = a.axis(d);
+        const S = Number(p.stretch), L = Number(p.distance) * a.span;
+        if (v < ARRIVE) {
+            const tau = v / ARRIVE;
+            const k = 6;
+            const x = (Math.exp(k * (1 - tau)) - 1) / (Math.exp(k) - 1); // exponential braking
+            out.off.copy(d).multiplyScalar(L * x);
+            const s = 1 + (S - 1) * (1 - smooth(0.65, 1, tau));
+            stretchAxis(out.s, axis, s, smooth(0, 0.2, tau));
+            return;
+        }
+        // snapped out of the stretch: it jiggles along the heading
+        const sg = clamp01((v - ARRIVE) / (1 - ARRIVE));
+        stretchAxis(out.s, axis, 1 - 0.18 * ring(sg, 2, 3.5));
+    },
+});

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

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

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

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

package/dist/operations/catalogue/whoosh.js

@@ -0,0 +1,84 @@
+// Whoosh — the object streaks through its own spot again and again, each pass
+// crossing the one before it (an X seen from above: back-left → front-right,
+// then back-right → front-left, the angle opening a little every pair), with a
+// soft alternating arc. On each streak it stretches along its motion (volume
+// kept) and banks into it. After `passes` fly-throughs it comes in on the next
+// crossing line, brakes exponentially into place, overshoots a touch and settles.
+// Leaving plays it backwards in time: it bolts off along that line, then streaks
+// through its spot the other way round, and is gone.
+import { Quaternion, Vector3 } from 'three';
+import { clamp01, physicalExit, ring, smooth, stretchAxis } from './physicalExit.js';
+const _d = new Vector3(), _q = new Quaternion();
+const PASS = 1, GAP = 0.14, ARRIVE = 1.5, SETTLE = 0.75; // timeline units
+/** Direction of crossing line i on the ground plane (screen-relative), mostly across the view. */
+function lineDir(a, i, out) {
+    const f = a.frame;
+    const side = (i % 2 === 0 ? 1 : -1) * (a.p.mirror ? -1 : 1); // alternates which way it crosses
+    const phi = (24 + 9 * Math.floor(i / 2)) * Math.PI / 180; // each pair opens a little wider
+    return out.set(0, 0, 0).addScaledVector(f.right, side * Math.cos(phi)).addScaledVector(f.toward, Math.sin(phi)).normalize();
+}
+function streak(out, a, tau, i) {
+    const f = a.frame, H = a.size.y;
+    const W = Number(a.p.spread) * a.span;
+    lineDir(a, i, _d);
+    // straight through its spot at constant speed, with a soft arc that alternates up / down
+    const arc = (i % 2 === 0 ? 1 : -0.45) * 0.3 * H * Math.sin(Math.PI * tau);
+    out.off.copy(_d).multiplyScalar(W * (2 * tau - 1)).addScaledVector(f.up, arc + 0.15 * H * Math.sin(Math.PI * tau));
+    stretchAxis(out.s, a.axis(_d), 1 + Number(a.p.stretch), smooth(0, 0.06, tau) * (1 - smooth(0.94, 1, tau)));
+    out.q.copy(a.local(_q.setFromAxisAngle(_d, (i % 2 === 0 ? -1 : 1) * 0.3 * Math.cos(Math.PI * tau))));
+}
+function arrive(out, a, tau, i) {
+    const st = Number(a.p.stretch);
+    const L = Number(a.p.spread) * a.span;
+    lineDir(a, i, _d);
+    const k = 5;
+    const left = (Math.exp(k * (1 - tau)) - 1) / (Math.exp(k) - 1); // exponential braking
+    out.off.copy(_d).multiplyScalar(-L * left);
+    stretchAxis(out.s, a.axis(_d), 1 + st * Math.min(1, left * 4), smooth(0, 0.06, tau));
+}
+function settle(out, a, sg, i) {
+    const st = Number(a.p.stretch);
+    lineDir(a, i, _d);
+    const r = ring(sg, 1.5, 3.4);
+    out.off.copy(_d).multiplyScalar(0.12 * a.span * r); // past its spot along the line, and back
+    stretchAxis(out.s, 1, 1 - 0.3 * st * Math.abs(r));
+    out.pivot = 'bottom';
+}
+/** The entrance at v (0 gone → 1 at rest). */
+function entrance(v, out, a) {
+    const n = Math.max(0, Math.round(Number(a.p.passes)));
+    const total = n * (PASS + GAP) + ARRIVE + SETTLE;
+    let t = clamp01(v) * total;
+    for (let i = 0; i < n; i++) {
+        if (t < PASS) {
+            streak(out, a, t / PASS, i);
+            return;
+        }
+        t -= PASS;
+        if (t < GAP) {
+            out.s.setScalar(0);
+            return;
+        } // off-screen between passes
+        t -= GAP;
+    }
+    if (t < ARRIVE) {
+        arrive(out, a, t / ARRIVE, n);
+        return;
+    }
+    settle(out, a, clamp01((t - ARRIVE) / SETTLE), n);
+}
+export default physicalExit({
+    value: 'whoosh',
+    label: 'Whoosh',
+    description: 'Streaks through its own spot again and again, each pass crossing the last, then brakes into place; it leaves the same way, in reverse',
+    params: {
+        passes: { type: 'number', label: 'Passes', default: 3, min: 0, max: 8, step: 1, hint: 'Fly-throughs before it settles (add duration with more passes)' },
+        spread: { type: 'number', label: 'Reach', default: 7, min: 2, max: 25, step: 0.5, hint: 'How far each pass runs either side of its spot, × its size' },
+        stretch: { type: 'number', label: 'Stretch', default: 0.6, min: 0, max: 2, step: 0.05, hint: 'How long it gets while it streaks' },
+        mirror: { type: 'boolean', label: 'Mirror', default: false, hint: 'Start the first pass from the right' },
+        duration: { type: 'number', label: 'Duration', default: 3, min: 0.6, max: 14, step: 0.05, unit: 's', hint: 'The whole entrance (or exit)' },
+    },
+    // leaving: the same timeline backwards (bolts off along the last line, then the passes the other way round)
+    exit(u, out, a) { entrance(1 - u, out, a); },
+    enter(v, out, a) { entrance(v, out, a); },
+});

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

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

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

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

package/dist/operations/catalogue/wobble.js

@@ -0,0 +1,23 @@
+// Wobble — the object's up axis traces a small cone, like a spinning top that is
+// settling (precession), with a slow nutation so the circle breathes.
+import { Vector3 } from 'three';
+import { DURATION, heldPhysical } from './physicalHeld.js';
+const _axis = new Vector3();
+export default heldPhysical({
+    value: 'wobble', label: 'Wobble',
+    description: 'Lean round in a circle, like a top that is settling — standing on its base',
+    params: {
+        angle: { type: 'number', label: 'Lean', default: 6, min: 0.5, max: 40, step: 0.5, unit: '°' },
+        speed: { type: 'number', label: 'Speed', default: 1, min: 0.1, max: 6, step: 0.05, unit: '×' },
+        clockwise: { type: 'boolean', label: 'Clockwise', default: false },
+        duration: { ...DURATION, default: 3 },
+    },
+    memory: () => null,
+    move(part, st, time) {
+        const p = st.p;
+        const phi = (p.clockwise ? -1 : 1) * 2 * Math.PI * 0.45 * Number(p.speed) * time;
+        const lean = (Number(p.angle) * Math.PI / 180) * (1 + 0.18 * Math.sin(phi * 0.37)) * st.amp.v;
+        part.q.setFromAxisAngle(_axis.set(Math.cos(phi), 0, Math.sin(phi)), lean);
+        part.pivot.copy(st.body.bottomLocal);
+    },
+});

package/dist/operations/clipPreview.d.ts

@@ -0,0 +1,3 @@
+/** A JPEG of the current frame, at most `maxSize` px on its long side. Null when no scene is mounted. */
+export declare function captureFrameImage(maxSize?: number, quality?: number): Promise<Blob | null>;
+//# sourceMappingURL=clipPreview.d.ts.map

package/dist/operations/clipPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipPreview.d.ts","sourceRoot":"","sources":["../../src/operations/clipPreview.ts"],"names":[],"mappings":"AAOA,yGAAyG;AACzG,wBAAgB,iBAAiB,CAAC,OAAO,SAAM,EAAE,OAAO,SAAO,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAWrF"}

package/dist/operations/clipPreview.js

@@ -0,0 +1,20 @@
+// A small preview image of what the scene shows right now — for an effect clip template's card.
+// The same full frame as the studio's screenshots (renderFrame: clouds and other full-screen
+// passes included), scaled down to a thumbnail.
+import { SceneStore } from '@3driseai/3drise-core';
+import cameraManager from '../utils/CameraSingleton.js';
+import { renderFrame } from '../utils/frameRenderer.js';
+/** A JPEG of the current frame, at most `maxSize` px on its long side. Null when no scene is mounted. */
+export function captureFrameImage(maxSize = 512, quality = 0.85) {
+    const gl = SceneStore.gl, scene = SceneStore.scene, camera = cameraManager.getCamera?.();
+    if (!gl || !scene || !camera || typeof document === 'undefined')
+        return Promise.resolve(null);
+    renderFrame(gl, scene, camera);
+    const src = gl.domElement;
+    const k = Math.min(1, maxSize / Math.max(src.width, src.height, 1));
+    const out = document.createElement('canvas');
+    out.width = Math.max(1, Math.round(src.width * k));
+    out.height = Math.max(1, Math.round(src.height * k));
+    out.getContext('2d')?.drawImage(src, 0, 0, out.width, out.height);
+    return new Promise(resolve => out.toBlob(b => resolve(b), 'image/jpeg', quality));
+}