@3driseai/3drise-viewer 0.1.26 → 0.1.28

package/dist/operations/catalogue/swirl.js

@@ -0,0 +1,69 @@
+// Swirl — the object is drawn up into a vortex: it spirals out on a widening,
+// rising helix, spinning about its own centre and shrinking to nothing.
+// Reverting spirals it back down into place.
+import { gsap } from 'gsap';
+import { Quaternion, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { acquireRest, poseAbout, releaseRest } from './restPose.js';
+const KEY = '__opSwirl';
+const UP = new Vector3(0, 1, 0);
+function pose(target, st, p) {
+    const t = st.proxy.t;
+    const r = st.rest;
+    const R = Math.max(r.size.x, r.size.z) * Number(p.radius);
+    const rise = r.size.y * Number(p.rise);
+    const turns = Number(p.turns);
+    const dir = p.reverse ? -1 : 1;
+    // helix: radius opens with an ease-out, height with an ease-in (it gets pulled up)
+    const phi = dir * turns * 2 * Math.PI * t;
+    const rad = R * Math.sin((Math.PI / 2) * t);
+    const off = new Vector3(rad * Math.cos(phi) - rad, rise * t * t, rad * Math.sin(phi));
+    // spins faster than it orbits, shrinks over the second half
+    const q = new Quaternion().setFromAxisAngle(UP, dir * turns * 2 * Math.PI * 1.6 * t * t);
+    const k = 1 - smoothstep(0.3, 1, t);
+    const s = new Vector3(1, 1, 1).multiplyScalar(Math.max(k, 1e-4));
+    poseAbout(target, r, r.centerLocal, q, s, off);
+}
+const smoothstep = (a, b, x) => { const v = Math.min(1, Math.max(0, (x - a) / (b - a))); return v * v * (3 - 2 * v); };
+export default defineOperation({
+    value: 'swirl',
+    label: 'Swirl away',
+    description: 'Spiral the target up into a vortex until it vanishes — reverting spirals it back into place',
+    channel: 'transform',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        turns: { type: 'number', label: 'Turns', default: 1.5, min: 0.5, max: 6, step: 0.25 },
+        radius: { type: 'number', label: 'Radius', default: 0.6, min: 0, max: 3, step: 0.05, hint: 'A fraction of the object’s width' },
+        rise: { type: 'number', label: 'Rise', default: 1.2, min: 0, max: 5, step: 0.05, hint: 'A fraction of the object’s height' },
+        reverse: { type: 'boolean', label: 'Clockwise', default: false },
+        duration: { type: 'number', label: 'Duration', default: 1.6, min: 0.2, max: 8, step: 0.05, unit: 's' },
+    },
+    apply(target, p) {
+        let st = target.userData[KEY];
+        if (!st) {
+            st = { rest: acquireRest(target), proxy: { t: 0 }, visible: target.visible };
+            target.userData[KEY] = st;
+        }
+        const s = st;
+        gsap.killTweensOf(s.proxy);
+        gsap.to(s.proxy, {
+            t: 1, duration: Number(p.duration), ease: 'power2.in',
+            onUpdate: () => pose(target, s, p),
+            onComplete: () => { target.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[KEY];
+        if (!s)
+            return;
+        target.visible = s.visible;
+        gsap.killTweensOf(s.proxy);
+        gsap.to(s.proxy, {
+            t: 0, duration: Number(p.duration), ease: 'power2.out',
+            onUpdate: () => pose(target, s, p),
+            onComplete: () => { delete target.userData[KEY]; releaseRest(target); },
+        });
+    },
+});

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

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

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

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

package/dist/operations/catalogue/teleport.js

@@ -0,0 +1,213 @@
+// Teleport — the object is drawn toward a point of light just above it and sent
+// up a beam. The surface leans in, heats to white and breaks into light along a
+// noisy front; particles sampled from the surface spiral smoothly into the point
+// and rise up the beam in tight helical streams. The beam itself is a clean
+// column of light: a soft core that is brightest face-on, fine streaks flowing
+// upward, and thin rings of light climbing it. Reverting materialises the
+// object back down the beam.
+import { AdditiveBlending, Color, CylinderGeometry, Mesh, ShaderMaterial } from 'three';
+import { defineOperation } from '../types.js';
+import { GLSL_ROT, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { GLSL_POINT_SIZE, createFxPoints, disposeFxPoints } from './fxPoints.js';
+import { hideUntilWarm } from './warmup.js';
+const P = 'Tel';
+const KEY = 'teleport';
+const STATE = '__opTeleport';
+const LIFE = 0.5;
+const END = 1 + LIFE * 1.6;
+/** The singularity: just above the top centre (GLSL, root-local). */
+const SING = `(u${P}Min + u${P}Size * vec3(0.5, 1.0, 0.5) + vec3(0.0, 0.18 * u${P}Extent, 0.0))`;
+function surface(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uTelLife: st.life, uTelGlow: st.glow },
+        common: `varying float vTelK;\nvarying vec3 vTelQ;\n${fieldGlsl(P)}\n${GLSL_ROT}`,
+        vertex: /* glsl */ `
+        {
+          mat4 toRoot = uTelRootInv * modelMatrix;
+          vec3 rl = (toRoot * vec4(transformed, 1.0)).xyz;
+          float birth = TelBirthOf(TelField(TelNorm(rl)));
+          float k = clamp((uTelProgress - birth) / uTelLife, 0.0, 1.0);
+          k = k * k * (3.0 - 2.0 * k);
+          vTelK = k;
+          vTelQ = TelNorm(rl);
+          vec3 S = ${SING};
+          // a gentle pull toward the point; the surface breaks into light long before it could smear
+          vec3 rel = fxRot(vec3(0.0, 1.0, 0.0), k * k * 0.9) * (rl - S);
+          rel.xz *= 1.0 - 0.35 * k;
+          rel.y *= 1.0 - 0.22 * k;
+          transformed = (inverse(toRoot) * vec4(S + rel, 1.0)).xyz;
+        }`,
+        fragment: /* glsl */ `
+        {
+          float cut = 0.1 + 0.35 * fxFbm(vTelQ * 7.0);
+          if (vTelK > cut) discard;
+          float h = smoothstep(0.0, cut, vTelK);
+          outgoingLight = mix(outgoingLight, uTelGlow * (1.5 + 3.5 * h), h);
+        }`,
+    };
+}
+/** The beam: an open cylinder drawn as a soft column of light. */
+function createColumn(target, st) {
+    const geo = new CylinderGeometry(1, 1, 1, 48, 1, true);
+    geo.translate(0, 0.5, 0); // base at the singularity
+    const mat = new ShaderMaterial({
+        uniforms: { uGlow: st.glow, uTime: st.field.time, uOn: { value: 0 } },
+        vertexShader: /* glsl */ `
+        varying vec3 vN; varying vec3 vV; varying vec2 vUv;
+        void main() {
+          vUv = uv;
+          vec4 mv = modelViewMatrix * vec4(position, 1.0);
+          vN = normalize(normalMatrix * normal);
+          vV = normalize(-mv.xyz);
+          gl_Position = projectionMatrix * mv;
+        }`,
+        fragmentShader: /* glsl */ `
+        uniform vec3 uGlow; uniform float uTime; uniform float uOn;
+        varying vec3 vN; varying vec3 vV; varying vec2 vUv;
+        float h1(vec2 p) { return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453); }
+        float n1(vec2 p) { vec2 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f);
+          return mix(mix(h1(i), h1(i + vec2(1.0, 0.0)), f.x), mix(h1(i + vec2(0.0, 1.0)), h1(i + vec2(1.0, 1.0)), f.x), f.y); }
+        void main() {
+          // a column of light is brightest where you look through its core
+          float face = pow(abs(dot(vN, vV)), 2.2) * 0.22;   // a veil: the object shows through
+          // fine streaks flowing up
+          float streak = n1(vec2(vUv.x * 60.0, vUv.y * 3.0 - uTime * 2.2)) * n1(vec2(vUv.x * 23.0 + 7.0, vUv.y * 1.5 - uTime * 1.3));
+          // thin rings of light climbing the beam
+          float rings = pow(max(0.0, 1.0 - abs(fract(vUv.y * 4.0 - uTime * 0.6) - 0.5) * 2.0), 60.0) * (0.4 + 0.6 * (1.0 - face));
+          // fade in at the base, thin out toward the top
+          float along = smoothstep(0.0, 0.03, vUv.y) * pow(1.0 - vUv.y, 1.1);
+          float edge = pow(1.0 - abs(dot(vN, vV)), 3.0) * 0.35;   // the column's silhouette
+          float I = (face * (0.4 + 1.2 * streak) + edge + rings * 0.7) * along * uOn;
+          vec3 c = mix(uGlow, vec3(1.0), 0.25) * I;
+          gl_FragColor = vec4(c, clamp(I, 0.0, 1.0));
+          #include <tonemapping_fragment>
+          #include <colorspace_fragment>
+        }`,
+        transparent: true, depthWrite: false, blending: AdditiveBlending, premultipliedAlpha: true, side: 2,
+    });
+    const m = new Mesh(geo, mat);
+    m.raycast = () => { };
+    m.userData.__opFxHelper = true;
+    m.frustumCulled = false;
+    m.renderOrder = 12;
+    target.add(m);
+    hideUntilWarm(m);
+    return m;
+}
+/** Place and light the column for the current progress (CPU side). */
+function updateColumn(s) {
+    const f = s.field;
+    const E = f.extent.value;
+    const min = f.boundsMin.value, size = f.boundsSize.value;
+    const p = f.progress.value;
+    // the column rises around the object as it starts to break up, and fades once it has gone up
+    const on = Math.max(0, Math.min(1, (p - 0.02) / 0.3)) * (1 - Math.max(0, Math.min(1, (p - (END - 0.4)) / 0.4)));
+    s.column.material.uniforms.uOn.value = on;
+    // from the ground, around the object, and on up past it
+    s.column.position.set(min.x + size.x / 2, min.y, min.z + size.z / 2);
+    const r = Math.max(size.x, size.z) * 0.62 * s.width.value + 0.02 * E;
+    s.column.scale.set(r, size.y * (1.2 + s.beam.value), r);
+    s.column.visible = on > 0.001;
+}
+export default defineOperation({
+    value: 'teleport',
+    label: 'Teleport',
+    description: 'Draw the targets into a point of light and send them up a beam — reverting brings them back down',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'down', options: DIRECTION_OPTIONS },
+        color: { type: 'color', label: 'Light', default: '#a8ecff' },
+        sparks: { type: 'number', label: 'Particles', default: 9000, min: 1000, max: 60000, step: 1000 },
+        beam: { type: 'number', label: 'Beam height', default: 3, min: 0.5, max: 10, step: 0.1, unit: '×' },
+        width: { type: 'number', label: 'Beam width', default: 1, min: 0.2, max: 4, step: 0.05, unit: '×' },
+        scale: { type: 'number', label: 'Pattern', default: 2, min: 0.5, max: 12, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 2.8, min: 0.3, max: 12, step: 0.1, unit: 's' },
+    },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.1;
+            const own = { field, life: { value: LIFE }, glow: { value: new Color() }, beam: { value: 3 }, width: { value: 1 }, mats: new Set() };
+            const sample = sampleSurfaceCached(target, Math.round(Number(p.sparks)), 23);
+            own.points = createFxPoints(target, sample, {
+                additive: true,
+                uniforms: { ...fieldUniforms(P, field), uTelLife: own.life, uTelGlow: own.glow, uTelBeam: own.beam, uTelWidth: own.width },
+                vertexPars: fieldGlsl(P) + GLSL_POINT_SIZE + GLSL_ROT,
+                vertexMain: /* glsl */ `
+                  float birth = TelBirthOf(TelField(TelNorm(aP)));
+                  float a = (uTelProgress - birth) / (uTelLife * 1.6);
+                  if (a <= 0.0 || a >= 1.0) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); gl_PointSize = 0.0; vColor = vec3(0.0); vAlpha = 0.0; return; }
+                  float E = uTelExtent;
+                  vec3 S = ${SING};
+                  float R = max(u${P}Size.x, u${P}Size.z) * 0.35 * uTelWidth + 0.01 * E;
+                  vec3 local;
+                  if (a < 0.5) {
+                    // spiral smoothly into the point
+                    float k = a / 0.5; k = k * k * (3.0 - 2.0 * k);
+                    vec3 rel = fxRot(vec3(0.0, 1.0, 0.0), k * 4.5 + aR.x * 0.4) * (aP - S);
+                    local = S + rel * (1.0 - k);
+                  } else {
+                    // up the beam on a tight helix (a few clean streams, not a random spray)
+                    float k = (a - 0.5) / 0.5;
+                    float stream = floor(aR.y * 5.0);
+                    float ang = stream * 1.2566 + k * 9.0 + u${P}Time * 1.5;
+                    float rad = R * (0.25 + 0.5 * aR.z) * (1.0 - 0.4 * k);
+                    local = S + vec3(cos(ang) * rad, k * k * uTelBeam * u${P}Size.y, sin(ang) * rad);
+                  }
+                  vec4 mv = modelViewMatrix * vec4(local, 1.0);
+                  gl_Position = projectionMatrix * mv;
+                  float fade = smoothstep(0.0, 0.06, a) * (1.0 - smoothstep(0.82, 1.0, a));
+                  vColor = mix(uTelGlow, vec3(1.0), 0.3 + 0.3 * aR.w) * 1.8;
+                  vAlpha = fade * 0.85;
+                  gl_PointSize = clamp(fxPointPx(E * 0.0026 * (0.7 + 0.6 * aR.w), mv), 1.0, 7.0);`,
+            });
+            own.column = createColumn(target, own);
+            const layer = surface(own);
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            st = own;
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.glow.value.set(String(p.color));
+        s.beam.value = Number(p.beam);
+        s.width.value = Number(p.width);
+        s.points.visible = true;
+        updateColumn(s);
+        return runProgress(target, s.field, END, {
+            duration: Number(p.duration), ease: 'power1.in',
+            onUpdate: () => updateColumn(s),
+            onComplete: () => { hideMeshes(target, KEY, true); s.points.visible = false; s.column.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.points.visible = true;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.out',
+            onUpdate: () => updateColumn(s),
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                disposeFxPoints(s.points);
+                s.column.removeFromParent();
+                s.column.geometry.dispose();
+                s.column.material.dispose();
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

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

@@ -0,0 +1,124 @@
+import { Box3, Color, Matrix4, Vector3 } from 'three';
+import type { Object3D } from 'three';
+export declare const DIRECTION_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+/** The sweeping (non-scattered) directions, for effects that need a front with a side. */
+export declare const SWEEP_OPTIONS: {
+    value: string;
+    label: string;
+}[];
+export interface FieldState {
+    /** 0 = whole, 1 = the surface is gone (particles may still be in flight, see `tail`). */
+    progress: {
+        value: number;
+    };
+    time: {
+        value: number;
+    };
+    rootInv: {
+        value: Matrix4;
+    };
+    boundsMin: {
+        value: Vector3;
+    };
+    boundsSize: {
+        value: Vector3;
+    };
+    /** Length of the bounds diagonal — the unit every motion is scaled by. */
+    extent: {
+        value: number;
+    };
+    scale: {
+        value: number;
+    };
+    direction: {
+        value: number;
+    };
+    edgeWidth: {
+        value: number;
+    };
+    edgeColor: {
+        value: Color;
+    };
+    /**
+     * Left → right / right → left: the screen direction at the moment the effect
+     * was triggered, in the target's root-local space (unit). Fixed for the run, so
+     * the camera moving mid-transition doesn't bend the front.
+     */
+    sweep: {
+        value: Vector3;
+    };
+}
+/** Bounds of `root` in its own (root-local) space. */
+export declare function localBounds(root: Object3D): Box3;
+export declare function createFieldState(root: Object3D): FieldState;
+/** The camera's screen-right, in `root`'s local space (world X when there is no camera). */
+export declare function screenRight(root: Object3D, ctx?: {
+    tools?: {
+        cameraPose?: () => {
+            position: number[];
+            target: number[];
+        } | null;
+    };
+}): Vector3;
+/**
+ * Apply the shared knobs. Pass the target and the operation context so the
+ * left → right / right → left directions can be taken from the screen at trigger.
+ */
+export declare function setFieldParams(st: FieldState, p: Record<string, unknown>, root?: Object3D, ctx?: any): void;
+export declare const syncRoot: (root: Object3D, st: FieldState) => void;
+/** The field's uniforms under a prefix: `u<P>Progress`, `u<P>RootInv`, … */
+export declare function fieldUniforms(P: string, st: FieldState): Record<string, {
+    value: unknown;
+}>;
+/**
+ * GLSL (after the uniform declarations):
+ *   <P>Norm(vec3 rootLocal) → q in 0..1         root-local position → normalised
+ *   <P>Field(vec3 q)        → f in 0..1         the field
+ *   <P>Threshold()          → t                 the front; surface visible where f > t
+ * Calm, low-frequency fBm — stretched so the front moves evenly over the whole run.
+ */
+export declare const fieldGlsl: (P: string) => string;
+/** Whether a field state is holding (tests / debugging). */
+export declare const isHolding: (st: FieldState) => boolean;
+/**
+ * Run the field's progress to `to`, refreshing the root matrix and the clock
+ * every tick. `tail` (in progress units) lets particles finish after the surface
+ * is gone: the tween covers 0 → 1 + tail.
+ */
+export declare function runProgress(root: Object3D, st: FieldState, to: number, opts: {
+    duration: number;
+    ease: string;
+    onUpdate?: () => void;
+    onComplete?: () => void;
+    /** false when the effect runs its own clock */
+    clock?: boolean;
+    /** Extra work to finish before the clock starts (e.g. shatter's geometry swap). */
+    ready?: Promise<unknown>;
+    /**
+     * A state effect (frost, metalize…): once it has run on, keep the clock and
+     * the root matrix running while it holds, so its own motion continues and
+     * its pattern stays fixed to an object that moves. Stops when the next run starts.
+     */
+    hold?: boolean;
+}): Promise<void>;
+/** The surface part of a transition: discard behind the front, light the edge. */
+export declare function surfaceLayer(P: string, st: FieldState, edge?: 'ember' | 'tint' | 'stain' | 'none'): {
+    uniforms: Record<string, {
+        value: unknown;
+    }>;
+    common: string;
+    vertex: string;
+    fragment: string;
+};
+/**
+ * Hide / show the target's own meshes (never the effect's helpers) once a
+ * transition has taken the surface away. `tag` keeps each effect's bookkeeping
+ * separate, so two effects never restore each other's visibility.
+ */
+export declare function hideMeshes(target: Object3D, tag: string, hidden: boolean): void;
+/** The current direction as a root-local unit vector (up for scattered / centre → out). */
+export declare function sweepVector(st: FieldState): Vector3;
+//# sourceMappingURL=transitionField.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transitionField.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/transitionField.ts"],"names":[],"mappings":"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"}