@3driseai/3drise-viewer 0.1.26 → 0.1.28

package/dist/operations/catalogue/transitionField.js

@@ -0,0 +1,278 @@
+// =============================================================================
+// Transition field — the shared backbone of the visual in/out effects.
+// =============================================================================
+//
+// Every transition (dissolve, ember ash, swarm, hologram, shatter) is driven by
+// one scalar field over the target, f(q) in 0..1, where q is the position in the
+// target's own space normalised by its bounds (0..1 on each axis). A threshold
+// sweeps through f as progress runs 0 → 1:
+//
+//   surface    visible where f > threshold          (layer on the material)
+//   particles  born at f, so they leave exactly where the surface goes
+//   shards     each triangle leaves when the front reaches its centroid
+//
+// Root space: the target root's inverse world matrix is a uniform refreshed
+// every frame while a transition runs, so the pattern is fixed to the object —
+// it fits any size, never swims when the object moves, and a model's many meshes
+// transition as one piece.
+//
+// GLSL names carry a per-effect prefix, so two different transitions layered on
+// one material never redeclare each other's uniforms or functions.
+//
+import { gsap } from 'gsap';
+import { Box3, Color, Matrix4, Vector3 } from 'three';
+import { GLSL_NOISE, commitPendingLayers } from './shaderLayers.js';
+import { warmHelpers, warmMode } from './warmup.js';
+export const DIRECTION_OPTIONS = [
+    { value: 'noise', label: 'Scattered' },
+    { value: 'up', label: 'Bottom → top' },
+    { value: 'down', label: 'Top → bottom' },
+    { value: 'outward', label: 'Centre → out' },
+    { value: 'left', label: 'Left → right' },
+    { value: 'right', label: 'Right → left' },
+];
+/** The sweeping (non-scattered) directions, for effects that need a front with a side. */
+export const SWEEP_OPTIONS = DIRECTION_OPTIONS.filter(o => o.value !== 'noise' && o.value !== 'outward');
+const DIRECTIONS = DIRECTION_OPTIONS.map(o => o.value);
+/** Bounds of `root` in its own (root-local) space. */
+export function localBounds(root) {
+    root.updateWorldMatrix(true, true);
+    const inv = new Matrix4().copy(root.matrixWorld).invert();
+    const box = new Box3();
+    const tmp = new Box3();
+    const m = new Matrix4();
+    root.traverse((c) => {
+        if (!c.isMesh || !c.geometry || c.userData?.__opFxHelper)
+            return;
+        if (!c.geometry.boundingBox)
+            c.geometry.computeBoundingBox();
+        tmp.copy(c.geometry.boundingBox).applyMatrix4(m.multiplyMatrices(inv, c.matrixWorld));
+        box.union(tmp);
+    });
+    if (box.isEmpty())
+        box.set(new Vector3(-0.5, -0.5, -0.5), new Vector3(0.5, 0.5, 0.5));
+    return box;
+}
+export function createFieldState(root) {
+    const b = localBounds(root);
+    const size = b.getSize(new Vector3());
+    return {
+        progress: { value: 0 }, time: { value: 0 }, rootInv: { value: new Matrix4() },
+        boundsMin: { value: b.min.clone() }, boundsSize: { value: size }, extent: { value: Math.max(size.length(), 1e-3) },
+        scale: { value: 3 }, direction: { value: 0 }, edgeWidth: { value: 0.08 }, edgeColor: { value: new Color('#ff7a2e') },
+        sweep: { value: new Vector3(1, 0, 0) },
+    };
+}
+/** The camera's screen-right, in `root`'s local space (world X when there is no camera). */
+export function screenRight(root, ctx) {
+    const pose = ctx?.tools?.cameraPose?.();
+    const right = new Vector3(1, 0, 0);
+    if (pose) {
+        const fwd = new Vector3(pose.target[0] - pose.position[0], pose.target[1] - pose.position[1], pose.target[2] - pose.position[2]);
+        const r = fwd.cross(new Vector3(0, 1, 0));
+        if (r.lengthSq() > 1e-8)
+            right.copy(r.normalize());
+    }
+    root.updateWorldMatrix(true, false);
+    const inv = new Matrix4().copy(root.matrixWorld).invert();
+    return right.transformDirection(inv);
+}
+/**
+ * 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 function setFieldParams(st, p, root, ctx) {
+    if (p.direction !== undefined) {
+        const d = String(p.direction);
+        st.direction.value = Math.max(0, DIRECTIONS.indexOf(d));
+        if ((d === 'left' || d === 'right') && root) {
+            const r = screenRight(root, ctx);
+            st.sweep.value.copy(d === 'left' ? r : r.negate());
+        }
+    }
+    if (p.scale !== undefined)
+        st.scale.value = Number(p.scale);
+    if (p.edgeWidth !== undefined)
+        st.edgeWidth.value = Number(p.edgeWidth);
+    if (p.edgeColor !== undefined)
+        st.edgeColor.value.set(String(p.edgeColor));
+}
+export const syncRoot = (root, st) => {
+    root.updateWorldMatrix(true, false);
+    st.rootInv.value.copy(root.matrixWorld).invert();
+};
+/** The field's uniforms under a prefix: `u<P>Progress`, `u<P>RootInv`, … */
+export function fieldUniforms(P, st) {
+    return {
+        [`u${P}Progress`]: st.progress, [`u${P}Time`]: st.time, [`u${P}RootInv`]: st.rootInv,
+        [`u${P}Min`]: st.boundsMin, [`u${P}Size`]: st.boundsSize, [`u${P}Extent`]: st.extent,
+        [`u${P}Scale`]: st.scale, [`u${P}Direction`]: st.direction,
+        [`u${P}EdgeWidth`]: st.edgeWidth, [`u${P}EdgeColor`]: st.edgeColor, [`u${P}Sweep`]: st.sweep,
+    };
+}
+/**
+ * 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 const fieldGlsl = (P) => /* glsl */ `
+${GLSL_NOISE}
+vec3 ${P}Norm(vec3 r) { return (r - u${P}Min) / max(u${P}Size, vec3(1e-4)); }
+// 0 → 1 along the chosen direction (up for 'scattered')
+float ${P}Along(vec3 q) {
+  if (u${P}Direction < 1.5) return q.y;
+  if (u${P}Direction < 2.5) return 1.0 - q.y;
+  if (u${P}Direction < 3.5) return clamp(length(q - 0.5) * 1.1547, 0.0, 1.0);
+  vec3 rc = (q - 0.5) * u${P}Size;
+  float h = max(dot(abs(u${P}Sweep), u${P}Size) * 0.5, 1e-4);
+  return clamp(dot(rc, u${P}Sweep) / (2.0 * h) + 0.5, 0.0, 1.0);
+}
+float ${P}Field(vec3 q) {
+  float n = clamp((fxFbm(q * u${P}Scale) - 0.25) * 2.0, 0.0, 1.0);
+  if (u${P}Direction < 0.5) return n;
+  return clamp(mix(${P}Along(q), n, 0.3), 0.0, 1.0);
+}
+float ${P}Threshold() { return clamp(u${P}Progress, 0.0, 1.0) * (1.0 + 2.0 * u${P}EdgeWidth) - u${P}EdgeWidth; }
+// progress at which the front reaches field value f (inverse of Threshold)
+float ${P}BirthOf(float f) { return (f + u${P}EdgeWidth) / (1.0 + 2.0 * u${P}EdgeWidth); }
+`;
+// ---------------------------------------------------------------- hold clock
+/** Field states holding their finished state → their root. One ticker drives them all. */
+const holds = new Map();
+let holdTick = null;
+let holdLast = 0;
+function startHold(root, st) {
+    holds.set(st, root);
+    if (holdTick)
+        return;
+    holdLast = performance.now();
+    holdTick = () => {
+        const now = performance.now();
+        const dt = Math.min(0.1, (now - holdLast) / 1000);
+        holdLast = now;
+        holds.forEach((r, s) => { s.time.value += dt; syncRoot(r, s); });
+    };
+    gsap.ticker.add(holdTick);
+}
+function stopHold(st) {
+    if (!holds.delete(st) || holds.size || !holdTick)
+        return;
+    gsap.ticker.remove(holdTick);
+    holdTick = null;
+}
+/** Whether a field state is holding (tests / debugging). */
+export const isHolding = (st) => holds.has(st);
+/**
+ * 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 function runProgress(root, st, to, opts) {
+    syncRoot(root, st);
+    gsap.killTweensOf(st.progress);
+    const s = st;
+    s.__resolve?.(); // a run that is replaced still "finishes" for whoever waits on it
+    // Nothing starts until the new shaders are compiled in the background (no freeze —
+    // see warmup.ts) and the first frame with them has been drawn. The token makes a
+    // quick re-trigger win over a start that is still waiting.
+    const token = (s.__run = (s.__run ?? 0) + 1);
+    return new Promise((resolve) => {
+        s.__resolve = resolve;
+        const start = () => {
+            if (s.__run !== token) {
+                resolve();
+                return;
+            }
+            stopHold(st);
+            let last = performance.now();
+            gsap.to(st.progress, {
+                value: to, duration: opts.duration, ease: opts.ease,
+                onUpdate: () => {
+                    const now = performance.now();
+                    if (opts.clock !== false)
+                        st.time.value += Math.min(0.1, (now - last) / 1000);
+                    last = now;
+                    syncRoot(root, st);
+                    opts.onUpdate?.();
+                },
+                onComplete: () => {
+                    if (opts.hold && to > 0 && opts.clock !== false)
+                        startHold(root, st);
+                    opts.onComplete?.();
+                    if (s.__resolve === resolve)
+                        s.__resolve = null;
+                    resolve();
+                },
+            });
+        };
+        const nextFrame = (fn) => (typeof requestAnimationFrame === 'function' ? requestAnimationFrame(() => fn()) : fn());
+        const warmOnly = warmMode.on;
+        Promise.all([commitPendingLayers(root), warmHelpers(root), opts.ready])
+            .catch(() => undefined)
+            .then(() => { if (warmOnly) {
+            if (s.__resolve === resolve)
+                s.__resolve = null;
+            resolve();
+        }
+        else
+            nextFrame(start); });
+    });
+}
+/** The surface part of a transition: discard behind the front, light the edge. */
+export function surfaceLayer(P, st, edge = 'ember') {
+    const edgeGlsl = edge === 'none' ? '' : edge === 'stain'
+        ? /* glsl */ `
+          outgoingLight = mix(outgoingLight, u${P}EdgeColor, ${P}E * ${P}On * 0.85);`
+        : edge === 'ember'
+            ? /* glsl */ `
+          vec3 ${P}Hot = mix(u${P}EdgeColor, vec3(1.0, 0.95, 0.85), ${P}E * ${P}E);
+          outgoingLight = mix(outgoingLight, ${P}Hot * (1.0 + 3.0 * ${P}E), ${P}E * ${P}On);`
+            : /* glsl */ `
+          outgoingLight += u${P}EdgeColor * (2.5 * ${P}E * ${P}E * ${P}On);`;
+    return {
+        uniforms: fieldUniforms(P, st),
+        common: `varying vec3 v${P}Q;\n${fieldGlsl(P)}`,
+        vertex: /* glsl */ `
+        v${P}Q = ${P}Norm((u${P}RootInv * modelMatrix * vec4(transformed, 1.0)).xyz);`,
+        fragment: /* glsl */ `
+        {
+          float ${P}D = ${P}Field(v${P}Q) - ${P}Threshold();
+          if (${P}D < 0.0) discard;
+          float ${P}E = 1.0 - smoothstep(0.0, u${P}EdgeWidth, ${P}D);
+          float ${P}On = step(0.0001, u${P}Progress) * step(u${P}Progress, 0.9999);
+          ${edgeGlsl}
+        }`,
+    };
+}
+/**
+ * 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 function hideMeshes(target, tag, hidden) {
+    const k = `__opVis_${tag}`;
+    target.traverse((c) => {
+        if (!c.isMesh || c.userData?.__opFxHelper)
+            return;
+        if (hidden) {
+            if (c.userData[k] === undefined)
+                c.userData[k] = c.visible;
+            c.visible = false;
+        }
+        else if (c.userData[k] !== undefined) {
+            c.visible = c.userData[k];
+            delete c.userData[k];
+        }
+    });
+}
+/** The current direction as a root-local unit vector (up for scattered / centre → out). */
+export function sweepVector(st) {
+    const d = st.direction.value;
+    if (d === 2)
+        return new Vector3(0, -1, 0);
+    if (d === 4 || d === 5)
+        return st.sweep.value.clone();
+    return new Vector3(0, 1, 0);
+}

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

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

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

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

package/dist/operations/catalogue/unweave.js

@@ -0,0 +1,233 @@
+// Unweave — the object is re-drawn as glowing contour threads (the real mesh
+// sliced by horizontal planes, so the threads follow its exact shape) and the
+// surface falls away behind them. Then, optionally, the threads disperse:
+//   up / down / left → right / right → left   unravel ring by ring from the far
+//        end, each thread unwinding around the axis as it is drawn into a point
+//        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.
+// Reverting weaves the object back together.
+import { AdditiveBlending, BufferAttribute, BufferGeometry, Color, LineSegments, Matrix4, ShaderMaterial, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { GLSL_ROT, addLayer, forEachMeshMaterial, removeLayer, uniformDecl } from './shaderLayers.js';
+import { createFieldState, fieldGlsl, fieldUniforms, hideMeshes, localBounds, runProgress, screenRight, surfaceLayer } from './transitionField.js';
+import { mulberry32 } from './surfaceSample.js';
+import { hideUntilWarm } from './warmup.js';
+const P = 'Unw';
+const KEY = 'unweave';
+const STATE = '__opUnweave';
+const MAX_TRIS = 300_000;
+const MAX_SEGMENTS = 200_000;
+const MODES = ['up', 'down', 'left', 'right', 'random', 'scale'];
+/** Slice every mesh of the target with `levels` horizontal planes (root space). */
+function contourSegments(target, levels) {
+    target.updateWorldMatrix(true, true);
+    const rootInv = new Matrix4().copy(target.matrixWorld).invert();
+    const box = localBounds(target);
+    const y0 = box.min.y, h = Math.max(box.max.y - box.min.y, 1e-4);
+    const step = h / levels;
+    const cx = (box.min.x + box.max.x) / 2, cz = (box.min.z + box.max.z) / 2;
+    const pos = [], lvl = [], ang = [], rnd = [];
+    const r = mulberry32(43);
+    const a = new Vector3(), b = new Vector3(), c = new Vector3();
+    const m = new Matrix4();
+    const cut = (p, q, y, out) => {
+        const t = (y - p.y) / (q.y - p.y);
+        out.push(p.x + (q.x - p.x) * t, y, p.z + (q.z - p.z) * t);
+    };
+    target.traverse((o) => {
+        if (!o.isMesh || o.userData?.__opFxHelper || !o.geometry?.getAttribute('position'))
+            return;
+        const g = o.geometry, P3 = g.getAttribute('position'), idx = g.index;
+        const tris = (idx ? idx.count : P3.count) / 3;
+        if (tris > MAX_TRIS)
+            return;
+        m.multiplyMatrices(rootInv, o.matrixWorld);
+        for (let t = 0; t < tris && pos.length / 6 < MAX_SEGMENTS; t++) {
+            a.fromBufferAttribute(P3, idx ? idx.getX(t * 3) : t * 3).applyMatrix4(m);
+            b.fromBufferAttribute(P3, idx ? idx.getX(t * 3 + 1) : t * 3 + 1).applyMatrix4(m);
+            c.fromBufferAttribute(P3, idx ? idx.getX(t * 3 + 2) : t * 3 + 2).applyMatrix4(m);
+            const lo = Math.min(a.y, b.y, c.y), hi = Math.max(a.y, b.y, c.y);
+            for (let k = Math.ceil((lo - y0) / step - 0.5); k <= Math.floor((hi - y0) / step - 0.5); k++) {
+                const y = y0 + (k + 0.5) * step;
+                const pts = [];
+                if ((a.y - y) * (b.y - y) < 0)
+                    cut(a, b, y, pts);
+                if ((b.y - y) * (c.y - y) < 0)
+                    cut(b, c, y, pts);
+                if ((c.y - y) * (a.y - y) < 0)
+                    cut(c, a, y, pts);
+                if (pts.length !== 6)
+                    continue;
+                pos.push(...pts);
+                const l = (k + 0.5) / levels;
+                const rr = r();
+                for (let e = 0; e < 2; e++) {
+                    lvl.push(l);
+                    ang.push((Math.atan2(pts[e * 3 + 2] - cz, pts[e * 3] - cx) / (2 * Math.PI) + 1) % 1);
+                    rnd.push(rr);
+                }
+            }
+        }
+    });
+    return { pos: new Float32Array(pos), lvl: new Float32Array(lvl), ang: new Float32Array(ang), rnd: new Float32Array(rnd) };
+}
+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',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    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' },
+        mode: {
+            type: 'select', label: 'Dispersal', default: 'up',
+            options: [
+                { value: 'up', label: 'Unravel upward' }, { value: 'down', label: 'Unravel downward' },
+                { value: 'left', label: 'Unravel left → right' }, { value: 'right', label: 'Unravel right → left' },
+                { value: 'random', label: 'Scatter randomly' }, { value: 'scale', label: 'Expand (keep shape)' },
+            ],
+        },
+        duration: { type: 'number', label: 'Duration', default: 3.6, min: 0.3, max: 14, step: 0.1, unit: 's' },
+    },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.05;
+            const color = { value: new Color() };
+            const seg = contourSegments(target, Math.round(Number(p.threads)));
+            const geo = new BufferGeometry();
+            geo.setAttribute('position', new BufferAttribute(seg.pos, 3));
+            geo.setAttribute('aUnwLevel', new BufferAttribute(seg.lvl, 1));
+            geo.setAttribute('aUnwAng', new BufferAttribute(seg.ang, 1));
+            geo.setAttribute('aUnwRand', new BufferAttribute(seg.rnd, 1));
+            const mode = { value: 0 }, axis = { value: new Vector3(0, 1, 0) }, disperse = { value: 1 };
+            const uniforms = { ...fieldUniforms(P, field), uUnwColor: color, uUnwMode: mode, uUnwAxis: axis, uUnwDisperse: disperse };
+            const decl = Object.keys(uniforms).map(n => uniformDecl(n, uniforms[n].value)).join('\n');
+            const mat = new ShaderMaterial({
+                uniforms: uniforms,
+                vertexShader: `${decl}
+attribute float aUnwLevel; attribute float aUnwAng; attribute float aUnwRand;
+varying float vUnwA; varying float vUnwU;
+${fieldGlsl(P)}
+${GLSL_ROT}
+void main() {
+  float prog = uUnwProgress;
+  float E = uUnwExtent;
+  // threads light up first
+  vUnwA = smoothstep(0.0, 0.18, prog);
+  vec3 C = uUnwMin + uUnwSize * 0.5;
+  vec3 ax = uUnwAxis;
+  float h = max(dot(abs(ax), uUnwSize) * 0.5, 1e-4);
+  vec3 rel0 = position - C;
+  float s = clamp(dot(rel0, ax) / (2.0 * h) + 0.5, 0.0, 1.0);
+  vec3 b1 = normalize(cross(ax, abs(ax.y) > 0.9 ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 1.0, 0.0)));
+  vec3 b2 = cross(ax, b1);
+  float ang = atan(dot(rel0, b2), dot(rel0, b1)) / 6.2832 + 0.5;
+  float delay = uUnwMode < 3.5 ? (1.0 - s) * 0.55 + ang * 0.3     // far end first, unwinding round the axis
+              : uUnwMode < 4.5 ? aUnwRand * 0.75                    // random
+              : aUnwRand * 0.12;                                    // scale: nearly all together
+  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;
+  vec3 p;
+  if (uUnwMode < 3.5) {
+    vec3 rel = fxRot(ax, u * (2.5 + aUnwRand)) * rel0;
+    float along = dot(rel, ax);
+    vec3 perp = rel - ax * along;
+    vec3 wound = C + perp * (1.0 - u) + ax * mix(along, h + 0.25 * E, u * u);
+    p = mix(wound, C + ax * (h + 0.25 * E), u * u * u);
+  } else if (uUnwMode < 4.5) {
+    vec3 dir = normalize(vec3(fract(aUnwRand * 13.7), fract(aUnwRand * 71.3), fract(aUnwRand * 37.1)) - 0.5 + vec3(1e-3));
+    p = position + dir * (E * 1.3 * u * u);
+  } else {
+    p = C + rel0 * (1.0 + 1.8 * u);
+  }
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
+}`,
+                fragmentShader: `
+uniform vec3 uUnwColor; varying float vUnwA; varying float vUnwU;
+void main() {
+  float a = vUnwA * (1.0 - smoothstep(0.85, 1.0, vUnwU));
+  vec3 c = uUnwColor * (1.2 + 2.5 * vUnwU);
+  gl_FragColor = vec4(c * a, a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`,
+                transparent: true, depthWrite: false, blending: AdditiveBlending, premultipliedAlpha: true,
+            });
+            const lines = new LineSegments(geo, mat);
+            lines.frustumCulled = false;
+            lines.raycast = () => { };
+            lines.userData.__opFxHelper = true;
+            lines.renderOrder = 10;
+            target.add(lines);
+            hideUntilWarm(lines);
+            st = { field, color, mode, axis, disperse, lines, mats: new Set() };
+            const own = st;
+            // the surface itself falls away while the threads are drawn (tinted edge in the thread colour)
+            field.edgeColor.value = color.value;
+            const layer = surfaceLayer(P, field, 'tint');
+            forEachMeshMaterial(target, (mt, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mt, KEY, layer))
+                    own.mats.add(mt);
+            });
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        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;
+        if (mode === 'up')
+            s.axis.value.set(0, 1, 0);
+        else if (mode === 'down')
+            s.axis.value.set(0, -1, 0);
+        else if (mode === 'left' || mode === 'right') {
+            const r = screenRight(target, ctx);
+            s.axis.value.copy(mode === 'left' ? r : r.negate());
+        }
+        else
+            s.axis.value.set(0, 1, 0);
+        // the surface falls away from the far end (scattered for random / scale)
+        if (mode === 'random' || mode === 'scale')
+            s.field.direction.value = 0;
+        else {
+            s.field.direction.value = 4;
+            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, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => { hideMeshes(target, KEY, true); if (!keep)
+                s.lines.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.lines.visible = true;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                s.lines.removeFromParent();
+                s.lines.geometry.dispose();
+                s.lines.material.dispose();
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

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

@@ -1 +1 @@
-{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/visibility.ts"],"names":[],"mappings":";AAIA,wBAmBG"}
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/visibility.ts"],"names":[],"mappings":";AAIA,wBAoBG"}

package/dist/operations/catalogue/visibility.js

@@ -4,6 +4,7 @@ export default defineOperation({
     value: 'visibility',
     label: 'Show / hide',
     description: 'Hide (or show) the targets instantly',
+    channel: 'visual',
     multi: true,
     toggles: true,
     usableIn: ['interaction', 'action'],

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

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

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

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