@3driseai/3drise-viewer 0.1.26 → 0.1.28

package/dist/operations/catalogue/portal.js

@@ -0,0 +1,224 @@
+// Portal — a ring opens around the object and sweeps through it; the object
+// leaves through the ring, cut cleanly at its plane with a glowing rim.
+// The ring is drawn procedurally on one plane in its own polar coordinates, in
+// one of four styles (settings: style, colour, size, thickness, glow, spin):
+//   electric   a plasma ring with lightning arcs crawling round it and a faint plasma film
+//   runes      two counter-rotating bands of glowing glyphs inside fine circles
+//   horizon    an event horizon: a hot, lensed rim (Doppler-bright on one side), a thin
+//              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.
+import { AdditiveBlending, Color, Mesh, PlaneGeometry, Quaternion, ShaderMaterial, Vector3 } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { hideUntilWarm } from './warmup.js';
+import { SWEEP_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, sweepVector } from './transitionField.js';
+const P = 'Por';
+const KEY = 'portal';
+const STATE = '__opPortal';
+const STYLES = ['electric', 'runes', 'horizon', 'tech'];
+/** The quad is this much larger than the ring, so arcs and glow have room. */
+const PAD = 1.35;
+function cutLayer(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uPorColor: st.color },
+        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));
+        }`,
+    };
+}
+const RING_FRAG = /* glsl */ `
+uniform vec3 uColor; uniform float uTime; uniform float uStyle; uniform float uThick; uniform float uGlow; uniform float uSpin; uniform float uAlpha;
+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); }
+const float TAU = 6.2831853;
+void main() {
+  vec2 p = (vUv - 0.5) * 2.0 * ${PAD.toFixed(2)};     // ring radius = 1
+  float r = length(p);
+  float a = atan(p.y, p.x);
+  float u = a / TAU + 0.5;                             // 0..1 around
+  float t = uTime;
+  float th = 0.02 * uThick;
+  vec3 col = vec3(0.0);
+  if (uStyle < 0.5) {
+    // ELECTRIC: bright plasma ring + crawling arcs + faint plasma film
+    float ring = exp(-abs(r - 1.0) / th);
+    float arcs = 0.0;
+    for (int i = 0; i < 4; i++) {
+      float fi = float(i);
+      float tq = floor(t * 14.0 + fi * 3.1);
+      float rr = 1.0 + (n1(vec2(u * 18.0 + fi * 7.0, tq)) - 0.5) * 0.22 + (n1(vec2(u * 60.0, tq + fi)) - 0.5) * 0.05;
+      float seg = step(0.45, n1(vec2(u * 5.0 + t * uSpin * 0.5 + fi, fi * 2.0 + floor(t * 3.0))));
+      arcs += exp(-abs(r - rr) / (0.004 + 0.3 * th)) * seg;
+    }
+    float film = smoothstep(1.0, 0.2, r) * n1(vec2(a * 3.0 + r * 6.0 - t * uSpin, r * 4.0)) * 0.12;
+    col = uColor * (ring * 2.2 + arcs * 1.6 + film) + vec3(1.0) * pow(ring, 3.0) * 1.2;
+  } else if (uStyle < 1.5) {
+    // RUNES: two counter-rotating glyph bands between fine circles
+    float lines = exp(-abs(r - 1.08) / 0.004) + exp(-abs(r - 0.78) / 0.004) + exp(-abs(r - 0.92) / 0.003);
+    float glyph = 0.0;
+    for (int b = 0; b < 2; b++) {
+      float fb = float(b);
+      float r0 = fb < 0.5 ? 1.0 : 0.85;
+      float bw = 0.07;
+      float band = step(abs(r - r0), bw * 0.5);
+      float N = fb < 0.5 ? 36.0 : 28.0;
+      float uu = fract(u + (fb < 0.5 ? 1.0 : -1.0) * t * 0.03 * uSpin) * N;
+      float cell = floor(uu);
+      vec2 g = vec2(fract(uu), (r - (r0 - bw * 0.5)) / bw);     // 0..1 inside the glyph cell
+      vec2 gc = floor(g * 3.0);
+      vec2 gf = fract(g * 3.0);
+      // each glyph: a few strokes on a 3×3 grid, chosen by the cell's hash
+      float strokeH = step(0.5, h1(vec2(cell, gc.y + fb * 10.0))) * step(abs(gf.y - 0.5), 0.14) * step(0.15, g.x) * step(g.x, 0.85);
+      float strokeV = step(0.55, h1(vec2(cell + 50.0, gc.x + fb * 10.0))) * step(abs(gf.x - 0.5), 0.14) * step(0.12, g.y) * step(g.y, 0.88);
+      glyph += band * max(strokeH, strokeV);
+    }
+    float pulse = 0.75 + 0.25 * sin(t * 2.0 + u * TAU * 3.0);
+    col = uColor * (lines * 1.6 + glyph * 2.0 * pulse);
+  } else if (uStyle < 2.5) {
+    // EVENT HORIZON: a hot, lensed rim (Doppler-bright on one side), a thin photon ring,
+    // and inside only a few fine, faint spiral filaments falling inward — see-through,
+    // so the object stays visible through the portal
+    float doppler = 1.0 + 0.6 * cos(a - t * 0.35 * uSpin);
+    float rim = exp(-abs(r - 1.0) / (th * 1.6)) * doppler;
+    float photon = exp(-abs(r - 1.035) / 0.0035);
+    float spiral = pow(0.5 + 0.5 * sin(a * 2.0 + log(max(r, 0.02)) * 13.0 - t * 1.4 * uSpin), 26.0);
+    float filaments = spiral * smoothstep(0.3, 0.97, r) * (1.0 - smoothstep(0.97, 1.0, r)) * 0.28;
+    col = uColor * (rim * 2.0 + filaments) + vec3(1.0, 0.96, 0.9) * photon * 1.3;
+  } else {
+    // TECH GATE: segmented arcs both ways, tick marks, a scanning light
+    float band1 = step(abs(r - 1.0), th * 1.6) * step(0.3, fract(u * 12.0 + t * 0.05 * uSpin));
+    float band2 = step(abs(r - 1.12), th * 0.9) * step(0.6, fract(u * 3.0 - t * 0.08 * uSpin));
+    float ticks = step(abs(r - 0.9), 0.025) * step(fract(u * 72.0), 0.12);
+    float bigTicks = step(abs(r - 0.9), 0.045) * step(fract(u * 8.0), 0.012);
+    float scan = pow(max(0.0, 1.0 - fract(u - t * 0.25 * uSpin)), 12.0) * step(abs(r - 1.0), 0.16);
+    col = uColor * (band1 * 1.8 + band2 * 1.2 + ticks * 1.0 + bigTicks * 1.6) + vec3(1.0) * scan * 1.5;
+  }
+  col *= uGlow * uAlpha;
+  float lum = max(col.r, max(col.g, col.b));
+  gl_FragColor = vec4(col, clamp(lum, 0.0, 1.0));
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`;
+function makeRingMaterial(st, style) {
+    return new ShaderMaterial({
+        uniforms: { uColor: st.color, uTime: st.field.time, ...st.uni },
+        vertexShader: `varying vec2 vUv; void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0); }`,
+        fragmentShader: RING_FRAG,
+        transparent: true, depthWrite: false, premultipliedAlpha: true,
+        blending: AdditiveBlending,
+        side: 2,
+    });
+}
+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',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        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' },
+        size: { type: 'number', label: 'Ring size', default: 1, min: 0.6, max: 2.5, step: 0.05, unit: '×' },
+        thickness: { type: 'number', label: 'Thickness', default: 1, min: 0.3, max: 4, step: 0.05, unit: '×' },
+        glow: { type: 'number', label: 'Glow', default: 1, min: 0.2, max: 3, step: 0.05, unit: '×' },
+        spin: { type: 'number', label: 'Spin', default: 1, min: 0, max: 5, step: 0.05, unit: '×' },
+        duration: { type: 'number', label: 'Duration', default: 2.4, 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);
+            const own = {
+                field, color: { value: new Color() }, style: '', mats: new Set(),
+                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);
+            own.ring.raycast = () => { };
+            own.ring.userData.__opFxHelper = true;
+            own.ring.frustumCulled = false;
+            own.ring.renderOrder = 11;
+            target.add(own.ring);
+            const layer = cutLayer(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.color.value.set(String(p.color));
+        const style = STYLES.includes(String(p.ring)) ? String(p.ring) : 'electric';
+        if (style !== s.style) {
+            s.ringMat?.dispose();
+            s.ringMat = makeRingMaterial(s, style);
+            s.ring.material = s.ringMat;
+            s.style = style;
+            hideUntilWarm(s.ring);
+        }
+        s.uni.uStyle.value = STYLES.indexOf(style);
+        s.uni.uThick.value = Number(p.thickness);
+        s.uni.uGlow.value = Number(p.glow);
+        s.uni.uSpin.value = Number(p.spin);
+        // a ring wide enough to pass around the object's cross-section, across the sweep
+        const d = sweepVector(s.field);
+        const size = s.field.boundsSize.value;
+        const across = new Vector3(size.x * Math.sqrt(1 - d.x * d.x), size.y * Math.sqrt(1 - d.y * d.y), size.z * Math.sqrt(1 - d.z * d.z)).length();
+        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;
+        placeRing(s);
+        return runProgress(target, s.field, 1, {
+            duration: Number(p.duration), ease: 'power1.inOut',
+            onUpdate: () => placeRing(s),
+            onComplete: () => { hideMeshes(target, KEY, true); s.ring.visible = false; },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.ring.visible = true;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.inOut',
+            onUpdate: () => placeRing(s),
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                s.ring.removeFromParent();
+                s.ring.geometry.dispose();
+                s.ringMat?.dispose();
+                delete target.userData[STATE];
+            },
+        });
+    },
+});
+/** 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 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));
+    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

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

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

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

package/dist/operations/catalogue/print3d.js

@@ -0,0 +1,275 @@
+// 3D print — the object is printed, layer by layer, the way an FDM printer
+// builds it. Each layer is traced around the object by a nozzle (a hot point
+// running round the perimeter; every layer starts at the same angle, so it leaves
+// a faint z-seam like a real print), the freshest layers glow and cool along a
+// blackbody ramp, and fine layer lines show on the walls while it prints. Through
+// the open top you see the inside: the top layer's gyroid infill (a cap drawn on
+// the object's back faces, ray-cut at the print height and lit as a flat layer).
+// Applying un-prints it from the top down; reverting prints it back up.
+// With Disappear off (always, as an object effect) the object turns into its
+// slicer preview instead: the nozzle runs up through the layers and, behind it,
+// the surface becomes toolpath — rounded extrusion beads ringing the walls layer
+// by layer, rectilinear skin lines on the top and bottom faces (45°, alternating
+// per layer), in slicer feature colours (or by height, or the object's own).
+// While it holds, a highlighted layer climbs the object with the nozzle tracing
+// it. Reverting runs the nozzle back down and the solid object returns.
+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 { hideUntilWarm } from './warmup.js';
+const P = 'Prt';
+const KEY = 'print3d';
+const STATE = '__opPrint3d';
+/** The print state at a point (GLSL): is it printed yet, and how long ago (in layers). */
+const PRINT = /* glsl */ `
+float prtH() { return (1.0 - clamp(uPrtProgress, 0.0, 1.0)) * (1.0 + 1.0 / uPrtLayers); }
+float prtAngle(vec3 r) { vec3 c = uPrtMin + 0.5 * uPrtSize; return (atan(r.z - c.z, r.x - c.x) + 3.14159265) / 6.2831853; }
+// age in layers since the nozzle laid this point; < 0 = not printed yet
+float prtAge(vec3 r, vec3 q) {
+  float hl = prtH() * uPrtLayers;
+  float k = floor(q.y * uPrtLayers);
+  return hl - (k + prtAngle(r));
+}
+// slicer preview: the layer-time the conversion front has reached (bottom → top)
+float prtKAge(vec3 r, vec3 q) {
+  float hk = clamp(uPrtProgress, 0.0, 1.0) * (1.0 + 1.0 / uPrtLayers) * uPrtLayers;
+  return hk - (floor(q.y * uPrtLayers) + prtAngle(r));
+}
+vec3 prtHeat(float h) {
+  // blackbody-ish: dark red → orange → pale yellow
+  return mix(mix(vec3(0.5, 0.04, 0.0), vec3(1.0, 0.38, 0.06), smoothstep(0.0, 0.5, h)), vec3(1.0, 0.72, 0.42), smoothstep(0.6, 1.0, h));
+}
+`;
+function mainLayer(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uPrtLayers: st.layers, uPrtHot: st.hot, uPrtLines: st.lines, uPrtKeep: st.keep, uPrtPalette: st.palette },
+        common: `varying vec3 vPrtQ;\nvarying vec3 vPrtR;\nvarying vec3 vPrtN;\nvarying vec3 vPrtUp;\nvarying vec3 vPrtDA;\nvarying vec3 vPrtDB;\n${fieldGlsl(P)}\n${PRINT}`,
+        fragmentPars: PREVIEW,
+        vertex: /* glsl */ `
+        vPrtR = (uPrtRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vPrtQ = PrtNorm(vPrtR);
+        vPrtN = (uPrtRootInv * modelMatrix * vec4(normal, 0.0)).xyz;
+        {
+          // root axes in view space, to bend the lighting normal across the beads
+          mat3 rw = inverse(mat3(uPrtRootInv));
+          vPrtUp = normalize(mat3(viewMatrix) * (rw * vec3(0.0, 1.0, 0.0)));
+          vPrtDA = normalize(mat3(viewMatrix) * (rw * vec3(0.7071, 0.0, -0.7071)));
+          vPrtDB = normalize(mat3(viewMatrix) * (rw * vec3(0.7071, 0.0, 0.7071)));
+        }`,
+        diffuse: /* glsl */ `
+        if (uPrtKeep > 0.5) {
+          prtPreview(diffuseColor.rgb);
+          if (prtConv > 0.5) diffuseColor.rgb = prtCol * mix(0.22, 1.0, prtGap);
+        } else {
+          if (prtAge(vPrtR, vPrtQ) < 0.0) discard;
+          if (!gl_FrontFacing) discard;                       // double-sided materials: the cap draws the inside
+          // layer lines while it prints (they settle as the print finishes)
+          float yl = vPrtQ.y * uPrtLayers;
+          float ridge = pow(abs(fract(yl) - 0.5) * 2.0, 4.0);
+          diffuseColor.rgb *= 1.0 - 0.22 * ridge * uPrtLines * smoothstep(0.0, 0.06, uPrtProgress);
+        }`,
+        material: /* glsl */ `
+        if (uPrtKeep > 0.5 && prtConv > 0.5) { roughnessFactor = 0.42; metalnessFactor = 0.0; }`,
+        emissive: /* glsl */ `
+        if (uPrtKeep > 0.5 && prtConv > 0.5) {
+          // each extrusion is a round bead: bend the normal across it (up/down on walls, sideways on skin)
+          vec3 across = prtSkin > 0.5 ? prtSkinDir : vPrtUp;
+          normal = normalize(normal * sqrt(max(1.0 - prtB * prtB, 0.05)) + across * prtB * 0.85);
+        }`,
+        fragment: /* glsl */ `
+        if (uPrtKeep > 0.5) {
+          float age = prtKAge(vPrtR, vPrtQ);
+          float on = step(0.0001, uPrtProgress) * step(uPrtProgress, 0.9999);
+          // the nozzle converting the layers, and the freshly laid toolpath
+          float noz = exp(-abs(age) / 0.018) * on;
+          float fresh = exp(-max(age, 0.0) / 0.8) * step(0.0, age) * on;
+          outgoingLight += prtCol * fresh * 0.6 + vec3(1.0, 0.95, 0.85) * noz * 2.6;
+          // holding: a highlighted layer climbs the preview, the nozzle tracing it
+          float hw = smoothstep(0.97, 1.0, uPrtProgress) * prtConv;
+          float band = fract(uPrtTime * 0.045) * (uPrtLayers + 8.0) - 4.0;
+          float yl = vPrtQ.y * uPrtLayers;
+          float hl = exp(-abs(yl - band - 0.5) / 0.55);
+          float trace = band - (floor(yl) + prtAngle(vPrtR));
+          float tip = exp(-abs(trace) / 0.012) * step(abs(floor(yl) - floor(band)), 0.5);
+          outgoingLight += (prtCol * hl * 0.55 + vec3(1.0) * tip * 2.2) * hw;
+        } else {
+          float age = prtAge(vPrtR, vPrtQ);
+          float on = step(0.0001, uPrtProgress) * step(uPrtProgress, 0.9999);
+          float heat = exp(-age / 1.6) * on;
+          // the nozzle: a hot point on the current layer, where the extrusion is now
+          float noz = exp(-age / 0.02) * on;
+          outgoingLight = mix(outgoingLight, prtHeat(heat) * uPrtHot * 1.5, heat * heat * 0.6);
+          outgoingLight += vec3(1.0, 0.93, 0.8) * (noz * 3.0 + exp(-age / 0.08) * on * 0.6);
+        }`,
+    };
+}
+function capLayer(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uPrtLayers: st.layers, uPrtHot: st.hot, uPrtInfill: st.infill },
+        common: `varying vec3 vPrtQ;\nvarying vec3 vPrtR;\nvarying vec3 vPrtUp;\n${fieldGlsl(P)}\n${PRINT}`,
+        fragmentPars: 'float prtCap = 0.0; float prtLine = 0.0; float prtGlow = 0.0;',
+        vertex: /* glsl */ `
+        vPrtR = (uPrtRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+        vPrtQ = PrtNorm(vPrtR);
+        vPrtUp = normalize(mat3(viewMatrix) * (inverse(mat3(uPrtRootInv)) * vec3(0.0, 1.0, 0.0)));`,
+        diffuse: /* glsl */ `
+        {
+          if (prtAge(vPrtR, vPrtQ) < 0.0) discard;
+          // where the view ray crosses the print plane before reaching this back face, draw the top layer
+          vec3 camR = (uPrtRootInv * vec4(cameraPosition, 1.0)).xyz;
+          float planeY = uPrtMin.y + prtH() * uPrtSize.y;
+          vec3 dir = vPrtR - camR;
+          float tt = (planeY - camR.y) / (abs(dir.y) > 1e-5 ? dir.y : 1e-5);
+          if (camR.y > planeY && tt > 0.0 && tt < 1.0) {
+            vec3 X = camR + dir * tt;
+            vec3 u = (X - uPrtMin) / uPrtExtent * uPrtInfill * 6.2831853;
+            float gy = sin(u.x) * cos(u.y) + sin(u.y) * cos(u.z) + sin(u.z) * cos(u.x);
+            float fw = fwidth(gy) + 1e-4;
+            prtLine = 1.0 - smoothstep(0.2 - fw, 0.2 + fw, abs(gy));
+            prtCap = 1.0;
+            // the infill being laid: a raster front crossing the layer, alternating 45° per layer
+            float layer = floor(prtH() * uPrtLayers);
+            vec2 d2 = mod(layer, 2.0) < 0.5 ? vec2(0.7071, 0.7071) : vec2(0.7071, -0.7071);
+            vec3 c = uPrtMin + 0.5 * uPrtSize;
+            float rast = dot((X - c).xz, d2) / max(length(uPrtSize.xz), 1e-4) + 0.5;
+            float ph = fract(prtH() * uPrtLayers);
+            prtGlow = prtLine * (0.25 + exp(-abs(rast - ph) / 0.05)) * step(0.0001, uPrtProgress) * step(uPrtProgress, 0.9999);
+            diffuseColor.rgb *= mix(0.06, 1.0, prtLine);
+          } else {
+            diffuseColor.rgb *= 0.05;                           // the dark inside of the wall
+          }
+        }`,
+        emissive: /* glsl */ `
+        if (prtCap > 0.5) normal = vPrtUp;`,
+        fragment: /* glsl */ `
+        outgoingLight += prtHeat(0.55) * uPrtHot * prtGlow * 1.2;`,
+    };
+}
+const PALETTES = [{ value: 'feature', label: 'Feature type' }, { value: 'height', label: 'Layer height' }, { value: 'object', label: "Object's colours" }];
+/** The slicer-preview surface (fragment, computed once in the diffuse anchor). */
+const PREVIEW = /* glsl */ `
+float prtConv = 0.0, prtGap = 1.0, prtB = 0.0, prtSkin = 0.0;
+vec3 prtCol = vec3(1.0), prtSkinDir = vec3(0.0);
+vec3 prtRamp(float t) {
+  // a slicer height ramp: deep blue → cyan → green → amber → red
+  vec3 a = mix(vec3(0.028, 0.06, 0.687), vec3(0.014, 0.479, 0.745), smoothstep(0.0, 0.3, t));
+  a = mix(a, vec3(0.078, 0.651, 0.144), smoothstep(0.3, 0.55, t));
+  a = mix(a, vec3(1.0, 0.515, 0.027), smoothstep(0.55, 0.8, t));
+  return mix(a, vec3(0.888, 0.06, 0.042), smoothstep(0.8, 1.0, t));
+}
+void prtPreview(vec3 own) {
+  if (prtKAge(vPrtR, vPrtQ) < 0.0) return;
+  prtConv = 1.0;
+  vec3 n = normalize(vPrtN);
+  prtSkin = step(0.82, abs(n.y));                       // top / bottom faces are solid skin
+  float lh = uPrtSize.y / uPrtLayers;                    // layer height = bead width
+  float k = floor(vPrtQ.y * uPrtLayers);
+  float u;
+  if (prtSkin > 0.5) {
+    // rectilinear skin, 45° alternating per layer
+    bool alt = mod(k, 2.0) < 0.5;
+    vec2 d = alt ? vec2(0.7071, 0.7071) : vec2(0.7071, -0.7071);
+    float v = dot(vPrtR.xz, d) / lh;
+    u = fract(v);
+    prtSkinDir = alt ? vPrtDB : vPrtDA;
+    float aa = fwidth(v) * 1.2 + 1e-4;
+    prtGap = smoothstep(0.0, 0.1 + aa, u) * smoothstep(0.0, 0.1 + aa, 1.0 - u);
+  } else {
+    float yl = vPrtQ.y * uPrtLayers;
+    u = fract(yl);
+    float aa = fwidth(yl) * 1.2 + 1e-4;
+    prtGap = smoothstep(0.0, 0.08 + aa, u) * smoothstep(0.0, 0.08 + aa, 1.0 - u);
+  }
+  prtB = clamp(2.0 * u - 1.0, -1.0, 1.0) * prtGap;
+  if (uPrtPalette < 0.5) prtCol = prtSkin > 0.5 ? vec3(0.694, 0.024, 0.06) : vec3(1.0, 0.195, 0.014);   // skin · outer wall (linear)
+  else if (uPrtPalette < 1.5) prtCol = prtRamp(vPrtQ.y);
+  else prtCol = own;
+}
+`;
+const baseColor = (m) => (m.color?.isColor ? m.color.clone() : new Color('#dddddd'));
+export default defineOperation({
+    value: 'print3d',
+    label: '3D print',
+    description: 'Un-print the targets layer by layer, or (Disappear off) turn them into their slicer toolpath preview — reverting prints them back',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        layers: { type: 'number', label: 'Layers', default: 56, min: 8, max: 240, step: 1 },
+        infill: { type: 'number', label: 'Infill', default: 14, min: 2, max: 40, step: 0.5, hint: 'Gyroid cells across the object' },
+        hot: { type: 'color', label: 'Heat', default: '#ffffff', hint: 'Tints the glow of the fresh layers' },
+        lines: { type: 'number', label: 'Layer lines', default: 1, min: 0, max: 2, step: 0.05, unit: '×' },
+        preview: { type: 'select', label: 'Preview colours', default: 'feature', options: PALETTES, hint: 'The slicer preview (Disappear off)' },
+        duration: { type: 'number', label: 'Duration', default: 5, min: 0.3, max: 30, step: 0.1, unit: 's' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object turns into its slicer preview and stays' },
+    },
+    objectParams: { disappear: false },
+    apply(target, p) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            st = {
+                field, layers: { value: 56 }, infill: { value: 5 }, hot: { value: new Color() }, lines: { value: 1 },
+                keep: { value: 0 }, palette: { value: 0 }, caps: [], mats: new Set(),
+            };
+            const own = st;
+            const layer = mainLayer(own);
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            // the inside: a back-face twin of every plain mesh, sharing its geometry
+            const meshes = [];
+            target.traverse((c) => { if (c.isMesh && !c.isSkinnedMesh && !c.isInstancedMesh && !c.userData?.__opFxHelper)
+                meshes.push(c); });
+            const cap = capLayer(own);
+            for (const m of meshes) {
+                const src = (Array.isArray(m.material) ? m.material[0] : m.material);
+                const mat = new MeshStandardMaterial({ side: BackSide, color: baseColor(src), roughness: 0.6, metalness: 0 });
+                addLayer(mat, 'print3dCap', cap, { immediate: true });
+                const twin = new Mesh(m.geometry, mat);
+                twin.userData.__opFxHelper = true;
+                twin.raycast = () => { };
+                m.add(twin);
+                hideUntilWarm(twin);
+                own.caps.push(twin);
+            }
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        s.layers.value = Math.round(Number(p.layers));
+        s.infill.value = Number(p.infill);
+        s.hot.value.set(String(p.hot));
+        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;
+        // 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) {
+            return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'none', hold: true });
+        }
+        return runProgress(target, s.field, 1, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => { hideMeshes(target, KEY, true); s.caps.forEach(c => { c.visible = false; }); },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        hideMeshes(target, KEY, false);
+        s.caps.forEach(c => { c.visible = !s.keep.value; });
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => {
+                s.mats.forEach(m => removeLayer(m, KEY));
+                s.caps.forEach(c => { c.removeFromParent(); c.material.dispose(); });
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

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

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

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

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