@3driseai/3drise-viewer 0.1.25 → 0.1.27

package/dist/operations/catalogue/glow.js

@@ -0,0 +1,50 @@
+import { gsap } from 'gsap';
+import { defineOperation } from '../types.js';
+import { forEachMaterial, isLit, toColor } from './materialFx.js';
+const KEY = '__opGlow';
+export default defineOperation({
+    value: 'glow',
+    label: 'Glow',
+    description: 'Light the targets up with an emissive glow',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        color: { type: 'color', label: 'Colour', default: '#3380ff' },
+        intensity: { type: 'number', label: 'Intensity', default: 3, min: 0, max: 20, step: 0.1 },
+        duration: { type: 'number', label: 'Duration', default: 0.4, min: 0, max: 10, step: 0.05, unit: 's' },
+    },
+    apply(target, p) {
+        const color = toColor(String(p.color));
+        forEachMaterial(target, (mat) => {
+            if (!isLit(mat))
+                return;
+            if (!mat.userData[KEY]) {
+                mat.userData[KEY] = { emissive: mat.emissive.getHex(), intensity: mat.emissiveIntensity, toneMapped: mat.toneMapped };
+            }
+            mat.toneMapped = false;
+            gsap.killTweensOf(mat);
+            gsap.killTweensOf(mat.emissive);
+            gsap.to(mat, { emissiveIntensity: Number(p.intensity), duration: Number(p.duration), ease: 'power2.out' });
+            gsap.to(mat.emissive, { r: color.r, g: color.g, b: color.b, duration: Number(p.duration), ease: 'power2.out' });
+        });
+    },
+    revert(target, p) {
+        forEachMaterial(target, (mat) => {
+            if (!isLit(mat))
+                return;
+            const orig = mat.userData[KEY];
+            if (!orig)
+                return;
+            const c = toColor('#000000').setHex(orig.emissive);
+            gsap.killTweensOf(mat);
+            gsap.killTweensOf(mat.emissive);
+            gsap.to(mat, {
+                emissiveIntensity: orig.intensity, duration: Number(p.duration), ease: 'power2.in',
+                onComplete: () => { mat.toneMapped = orig.toneMapped; delete mat.userData[KEY]; },
+            });
+            gsap.to(mat.emissive, { r: c.r, g: c.g, b: c.b, duration: Number(p.duration), ease: 'power2.in' });
+        });
+    },
+});

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

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

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

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

package/dist/operations/catalogue/heatCracks.js

@@ -0,0 +1,134 @@
+// Heat cracks — heat takes hold of the object and you see what it does to it:
+// a network of cracks spreads along the front and glows from inside like cooling
+// lava; the cracks sink into the surface (real relief — vertices along the crack
+// seams are pushed in, the plates between them swell slightly), the plates char
+// and darken from their edges inward, and a few plates run hot as a whole. The
+// glow keeps breathing slowly while the effect is on. A state, not an exit —
+// nothing dissolves; reverting cools the object and the cracks close.
+import { gsap } from 'gsap';
+import { Color } from 'three';
+import { defineOperation } from '../types.js';
+import { GLSL_WORLEY, addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams, syncRoot } from './transitionField.js';
+const P = 'Hot';
+const KEY = 'heatCracks';
+const STATE = '__opHeatCracks';
+const CRACKS = /* glsl */ `
+// how far the cracking has got at a point, and where the seams are
+float hotCracked(vec3 q) { return smoothstep(0.0, uHotEdgeWidth, HotThreshold() - HotField(q)); }
+vec3 hotCells(vec3 r) { return fxWorley(r * (uHotDensity / uHotExtent)); }
+`;
+function layerFor(st) {
+    return {
+        uniforms: { ...fieldUniforms(P, st.field), uHotHeat: st.heat, uHotDensity: st.density, uHotDepth: st.depth },
+        common: `varying vec3 vHotQ;\nvarying vec3 vHotR;\n${fieldGlsl(P)}\n${GLSL_WORLEY}\n${CRACKS}`,
+        fragmentPars: 'vec3 hotCell = vec3(1.0); float hotCr = 0.0; bool hotDone = false;',
+        vertex: /* glsl */ `
+        {
+          vec3 r = (uHotRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+          vec3 q = HotNorm(r);
+          float cracked = hotCracked(q);
+          vec3 cell = hotCells(r);
+          float e = cell.y - cell.x;
+          // seams sink, plates swell a touch — relief that catches the light
+          float relief = -(1.0 - smoothstep(0.0, 0.12, e)) + 0.25 * smoothstep(0.12, 0.5, e);
+          transformed += normal * (relief * cracked * uHotDepth * 0.012 * uHotExtent);
+          vHotR = r;
+          vHotQ = q;
+        }`,
+        diffuse: /* glsl */ `
+        {
+          // computed once here, shared with the lighting pass below
+          hotCr = hotCracked(vHotQ);
+          hotCell = hotCells(vHotR);
+          hotDone = true;
+          float cracked = hotCr;
+          vec3 cell = hotCell;
+          float e = cell.y - cell.x;
+          // plates char from their edges inward as the heat soaks in
+          float soak = cracked * clamp(uHotProgress * 1.2, 0.0, 1.0);
+          float charEdge = 1.0 - smoothstep(0.0, 0.35 * soak + 0.05, e);
+          vec3 charred = vec3(0.06, 0.05, 0.045);
+          diffuseColor.rgb = mix(diffuseColor.rgb, charred, cracked * (0.35 + 0.6 * charEdge));
+        }`,
+        material: /* glsl */ `
+        {
+          float cracked = hotDone ? hotCr : hotCracked(vHotQ);
+          roughnessFactor = mix(roughnessFactor, 0.9, cracked);
+          metalnessFactor = mix(metalnessFactor, 0.0, cracked);
+        }`,
+        fragment: /* glsl */ `
+        {
+          if (!hotDone) { hotCr = hotCracked(vHotQ); hotCell = hotCells(vHotR); }
+          float cracked = hotCr;
+          vec3 cell = hotCell;
+          float e = cell.y - cell.x;
+          float cw = 0.05 + 0.04 * uHotProgress;                   // cracks widen as it heats
+          float crack = (1.0 - smoothstep(0.0, cw, e)) * cracked;
+          float breathe = 0.72 + 0.28 * sin(uHotTime * 1.1 + cell.z * 6.2832);
+          // a few whole plates run hot
+          float hotPlate = step(0.8, cell.z) * cracked * 0.35 * breathe;
+          float T = clamp(crack * breathe + hotPlate, 0.0, 1.0);
+          vec3 bb = mix(uHotHeat * vec3(0.35, 0.05, 0.0), uHotHeat, smoothstep(0.0, 0.6, T));
+          bb = mix(bb, vec3(1.0, 0.9, 0.65), smoothstep(0.75, 1.0, T));
+          float front = exp(-abs(HotThreshold() - HotField(vHotQ)) / 0.02) * step(0.0001, uHotProgress) * step(uHotProgress, 0.9999);
+          outgoingLight += bb * T * 3.0 + uHotHeat * front * 0.8;
+        }`,
+    };
+}
+export default defineOperation({
+    value: 'heatCracks',
+    label: 'Heat cracks',
+    description: 'Crack the targets with glowing lava seams that sink into the surface and char it — reverting cools them',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'up', options: DIRECTION_OPTIONS },
+        heat: { type: 'color', label: 'Heat', default: '#ff5a14' },
+        density: { type: 'number', label: 'Cracks', default: 9, min: 2, max: 40, step: 1, hint: 'Crack cells across the object' },
+        depth: { type: 'number', label: 'Crack depth', default: 1, min: 0, max: 4, step: 0.05, unit: '×' },
+        scale: { type: 'number', label: 'Front pattern', default: 2.5, 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' },
+    },
+    apply(target, p, ctx) {
+        let st = target.userData[STATE];
+        if (!st) {
+            const field = createFieldState(target);
+            field.edgeWidth.value = 0.06;
+            const own = { field, heat: { value: new Color() }, density: { value: 9 }, depth: { value: 1 }, mats: new Set() };
+            // the glow keeps breathing while the object stays cracked
+            own.tick = () => { own.field.time.value += gsap.ticker.deltaRatio() / 60; syncRoot(target, own.field); };
+            const layer = layerFor(own);
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            gsap.ticker.add(own.tick);
+            st = own;
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.heat.value.set(String(p.heat));
+        s.density.value = Number(p.density);
+        s.depth.value = Number(p.depth);
+        return runProgress(target, s.field, 1, { duration: Number(p.duration), ease: 'power1.out', clock: false });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.in', clock: false,
+            onComplete: () => {
+                gsap.ticker.remove(s.tick);
+                s.mats.forEach(m => removeLayer(m, KEY));
+                delete target.userData[STATE];
+            },
+        });
+    },
+});

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

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

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

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

package/dist/operations/catalogue/hologram.js

@@ -0,0 +1,118 @@
+// Hologram scan — a scan plane sweeps the target and turns the solid surface into
+// a hologram: glowing grid lines in the object's own space, a Fresnel rim and
+// drifting scanlines, everything else cut away (no transparency, so it sorts
+// cleanly). A second plane follows and switches the hologram off.
+// Reverting scans it back in: hologram first, then solid.
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer } from './shaderLayers.js';
+import { SWEEP_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, runProgress, setFieldParams } from './transitionField.js';
+import { Color } from 'three';
+const P = 'Holo';
+const KEY = 'hologram';
+const STATE = '__opHologram';
+export default defineOperation({
+    value: 'hologram',
+    label: 'Hologram scan',
+    description: 'A scan plane turns the targets into a glowing hologram, then switches it off — reverting scans them back in',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action', 'object'],
+    objectParams: { disappear: false },
+    params: {
+        direction: { type: 'select', label: 'Scan', default: 'down', options: SWEEP_OPTIONS },
+        color: { type: 'color', label: 'Colour', default: '#3fd4ff' },
+        density: { type: 'number', label: 'Grid', default: 14, min: 2, max: 60, step: 1, hint: 'Grid lines across the object' },
+        disappear: { type: 'boolean', label: 'Disappear', default: true, hint: 'Off: the object stays as a hologram after the scan' },
+        hold: { type: 'number', label: 'Hologram band', default: 0.45, min: 0.1, max: 1, step: 0.05, hint: 'How much of the object is hologram at once' },
+        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);
+            st = { field, color: { value: new Color() }, density: { value: 14 }, gap: { value: 0.45 }, keep: { value: 0 }, mats: new Set() };
+            const own = st;
+            const layer = {
+                uniforms: { ...fieldUniforms(P, field), uHoloColor: st.color, uHoloDensity: st.density, uHoloGap: st.gap, uHoloKeep: st.keep },
+                common: `varying vec3 vHoloR;\nvarying vec3 vHoloView;\n${fieldGlsl(P)}`,
+                vertex: /* glsl */ `
+                vHoloR = (uHoloRootInv * modelMatrix * vec4(transformed, 1.0)).xyz;
+                vHoloView = (modelViewMatrix * vec4(transformed, 1.0)).xyz;`,
+                fragment: /* glsl */ `
+                {
+                  vec3 q = HoloNorm(vHoloR);
+                  // scan coordinate: 0 where the scan starts, 1 where it ends
+                  float s = HoloAlong(q);
+                  float band = 0.02;
+                  float fa = mix(-band, 1.0 + uHoloGap + band, clamp(uHoloProgress, 0.0, 1.0)); // solid → hologram
+                  // hologram → gone (never, when the object should stay as a hologram)
+                  float fb = uHoloKeep > 0.5 ? -1.0 : fa - uHoloGap;
+                  if (s < fb) discard;
+                  if (s < fa) {
+                    // grid in root-local units, square cells, anti-aliased
+                    vec3 cell = vHoloR * (uHoloDensity / uHoloExtent);
+                    vec3 g = abs(fract(cell - 0.5) - 0.5) / max(fwidth(cell), vec3(1e-4));
+                    float line = 1.0 - clamp(min(min(g.x, g.y), g.z), 0.0, 1.0);
+                    // facing ratio from screen-space derivatives: works on lit and unlit materials
+                    vec3 nv = normalize(cross(dFdx(vHoloView), dFdy(vHoloView)));
+                    float fres = pow(1.0 - abs(dot(nv, normalize(-vHoloView))), 2.0);
+                    float scan = 0.5 + 0.5 * sin(vHoloR.y / uHoloExtent * 180.0 - uHoloTime * 5.0);
+                    float I = line * 0.9 + fres * 1.1 + scan * 0.12;
+                    // hot edges at both planes
+                    I += exp(-abs(s - fa) / 0.012) * 2.5 + exp(-abs(s - fb) / 0.01) * 1.5;
+                    if (I < 0.32) discard;
+                    outgoingLight = uHoloColor * I * 1.6;
+                  } else {
+                    // the solid side gets a faint pre-glow just ahead of the plane
+                    outgoingLight += uHoloColor * exp(-(s - fa) / 0.03) * 0.6;
+                  }
+                }`,
+            };
+            forEachMeshMaterial(target, (mat, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(mat, KEY, layer))
+                    own.mats.add(mat);
+            });
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, { direction: p.direction }, target, ctx);
+        s.color.value.set(String(p.color));
+        s.density.value = Number(p.density);
+        s.gap.value = Number(p.hold);
+        const keep = p.disappear === false;
+        s.keep.value = keep ? 1 : 0;
+        return runProgress(target, s.field, 1, {
+            duration: Number(p.duration), ease: 'power1.inOut', hold: keep,
+            onComplete: () => { if (!keep)
+                setMeshesHidden(target, true); },
+        });
+    },
+    revert(target, p) {
+        const s = target.userData[STATE];
+        if (!s)
+            return;
+        setMeshesHidden(target, false);
+        return runProgress(target, s.field, 0, {
+            duration: Number(p.duration), ease: 'power1.inOut',
+            onComplete: () => { s.mats.forEach(m => removeLayer(m, KEY)); delete target.userData[STATE]; },
+        });
+    },
+});
+function setMeshesHidden(target, hidden) {
+    target.traverse((c) => {
+        if (!c.isMesh || c.userData?.__opFxHelper)
+            return;
+        if (hidden) {
+            if (c.userData.__opHoloVis === undefined)
+                c.userData.__opHoloVis = c.visible;
+            c.visible = false;
+        }
+        else if (c.userData.__opHoloVis !== undefined) {
+            c.visible = c.userData.__opHoloVis;
+            delete c.userData.__opHoloVis;
+        }
+    });
+}

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

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

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

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

package/dist/operations/catalogue/inkBloom.js

@@ -0,0 +1,156 @@
+// Ink bloom — the object bleeds into ink, like a drop let go in still water.
+// The surface stains along the front, then comes apart into ink FILAMENTS: each
+// wisp is drawn as a crisp, fine line — its own recent path through the water —
+// so the ink reads as clean curling threads that fray, sink and thin out, not
+// as soft blobs. Normal blending (dark on light), so it works on light scenes.
+// Reverting draws the ink back into the object.
+import { BufferAttribute, BufferGeometry, LineSegments, NormalBlending, ShaderMaterial } from 'three';
+import { defineOperation } from '../types.js';
+import { addLayer, forEachMeshMaterial, removeLayer, uniformDecl } from './shaderLayers.js';
+import { DIRECTION_OPTIONS, createFieldState, fieldGlsl, fieldUniforms, hideMeshes, runProgress, setFieldParams, surfaceLayer, } from './transitionField.js';
+import { sampleSurfaceCached } from './surfaceSample.js';
+import { hideUntilWarm } from './warmup.js';
+const P = 'Ink';
+const KEY = 'inkBloom';
+const STATE = '__opInk';
+const LIFE = 0.9;
+/** Points per filament (its trail through the water). */
+const TRAIL = 12;
+function buildFilaments(target, count) {
+    const s = sampleSurfaceCached(target, count, 29);
+    const segs = TRAIL - 1;
+    const n = s.count * segs * 2;
+    const P3 = new Float32Array(n * 3), N3 = new Float32Array(n * 3), C3 = new Float32Array(n * 3), R4 = new Float32Array(n * 4), K = new Float32Array(n);
+    let v = 0;
+    for (let i = 0; i < s.count; i++) {
+        for (let k = 0; k < segs; k++) {
+            for (const kk of [k, k + 1]) {
+                P3.set(s.position.subarray(i * 3, i * 3 + 3), v * 3);
+                N3.set(s.normal.subarray(i * 3, i * 3 + 3), v * 3);
+                C3.set(s.color.subarray(i * 3, i * 3 + 3), v * 3);
+                R4.set(s.random.subarray(i * 4, i * 4 + 4), v * 4);
+                K[v] = kk / (TRAIL - 1);
+                v++;
+            }
+        }
+    }
+    const g = new BufferGeometry();
+    g.setAttribute('position', new BufferAttribute(P3, 3));
+    g.setAttribute('aN', new BufferAttribute(N3, 3));
+    g.setAttribute('aC', new BufferAttribute(C3, 3));
+    g.setAttribute('aR', new BufferAttribute(R4, 4));
+    g.setAttribute('aK', new BufferAttribute(K, 1));
+    return g;
+}
+export default defineOperation({
+    value: 'inkBloom',
+    label: 'Ink bloom',
+    description: 'Bleed the targets into fine curling ink filaments, like a drop in water — reverting draws the ink back in',
+    channel: 'visual',
+    multi: true,
+    toggles: true,
+    usableIn: ['interaction', 'action'],
+    params: {
+        direction: { type: 'select', label: 'Direction', default: 'noise', options: DIRECTION_OPTIONS },
+        edgeColor: { type: 'color', label: 'Ink colour', default: '#16203a' },
+        tint: { type: 'number', label: 'Object colour', default: 0.15, min: 0, max: 1, step: 0.05, hint: 'How much of the object’s own colour the ink keeps' },
+        filaments: { type: 'number', label: 'Filaments', default: 9000, min: 1000, max: 40000, step: 500 },
+        opacity: { type: 'number', label: 'Density', default: 0.55, min: 0.05, max: 1, step: 0.05 },
+        sink: { type: 'number', label: 'Sink', default: 1, min: -2, max: 3, step: 0.05, unit: '×', hint: 'Negative rises like smoke' },
+        scale: { type: 'number', label: 'Pattern', default: 2.5, min: 0.5, max: 12, step: 0.1 },
+        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.12;
+            const mixC = { value: 0.15 }, sink = { value: 1 }, opacity = { value: 0.55 };
+            const uniforms = { ...fieldUniforms(P, field), uInkMix: mixC, uInkSink: sink, uInkOpacity: opacity };
+            const decl = Object.keys(uniforms).map(n => uniformDecl(n, uniforms[n].value)).join('\n');
+            const mat = new ShaderMaterial({
+                uniforms: uniforms,
+                vertexShader: `${decl}
+attribute vec3 aN; attribute vec3 aC; attribute vec4 aR; attribute float aK;
+varying vec3 vColor; varying float vAlpha;
+${fieldGlsl(P)}
+// where a wisp that left from p0 is, at age a (the drift is a smooth function of age, so a trail is exact)
+vec3 inkAt(vec3 p0, vec3 n0, vec4 r, float a) {
+  float E = uInkExtent;
+  vec3 np = p0 / E * 1.8 + r.xyz * 4.0;
+  float t = a * 1.1;
+  vec3 d = vec3(fxNoise(np + vec3(t, 0.0, 0.0)), fxNoise(np + vec3(13.7, t, 5.1)), fxNoise(np + vec3(3.3, 9.2, t))) - 0.5;
+  vec3 d2 = vec3(fxNoise(np * 2.3 + vec3(0.0, t * 1.7, 0.0)), fxNoise(np * 2.3 + vec3(7.1, 2.0, t * 1.7)), fxNoise(np * 2.3 + vec3(t * 1.7, 4.4, 8.8))) - 0.5;
+  vec3 q = p0 + n0 * (0.05 * E * sqrt(a)) + (d * 0.75 + d2 * 0.55) * E * a;
+  q.y -= uInkSink * 0.25 * E * a * a;
+  return q;
+}
+void main() {
+  float birth = InkBirthOf(InkField(InkNorm(position)));
+  float a = (uInkProgress - birth) / ${LIFE.toFixed(2)};
+  // the trail: this vertex sits a little back along the wisp's own path
+  float trail = 0.22 * (0.6 + 0.8 * aR.w);
+  float ak = clamp(a - aK * trail, 0.0, 1.0);
+  if (a <= 0.0 || a >= 1.0) { gl_Position = vec4(2.0, 2.0, 2.0, 1.0); vColor = vec3(0.0); vAlpha = 0.0; return; }
+  vec3 q = inkAt(position, aN, aR, ak);
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(q, 1.0);
+  vColor = mix(uInkEdgeColor, aC, uInkMix) * (0.85 + 0.3 * aR.z);
+  // denser at the head, thinning along the trail and as the ink diffuses
+  vAlpha = uInkOpacity * (1.0 - aK) * smoothstep(0.0, 0.06, a) * pow(1.0 - a, 1.1);
+}`,
+                fragmentShader: `
+varying vec3 vColor; varying float vAlpha;
+void main() {
+  gl_FragColor = vec4(vColor * vAlpha, vAlpha);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}`,
+                transparent: true, depthWrite: false, blending: NormalBlending, premultipliedAlpha: true,
+            });
+            const lines = new LineSegments(buildFilaments(target, Math.round(Number(p.filaments))), mat);
+            lines.frustumCulled = false;
+            lines.raycast = () => { };
+            lines.userData.__opFxHelper = true;
+            lines.renderOrder = 10;
+            target.add(lines);
+            hideUntilWarm(lines);
+            st = { field, mixC, sink, opacity, lines, mats: new Set() };
+            const own = st;
+            const layer = surfaceLayer(P, field, 'stain');
+            forEachMeshMaterial(target, (m, mesh) => {
+                if (mesh.userData?.__opFxHelper)
+                    return;
+                if (addLayer(m, KEY, layer))
+                    own.mats.add(m);
+            });
+            target.userData[STATE] = st;
+        }
+        const s = st;
+        setFieldParams(s.field, p, target, ctx);
+        s.mixC.value = Number(p.tint);
+        s.sink.value = Number(p.sink);
+        s.opacity.value = Number(p.opacity);
+        s.lines.visible = true;
+        return runProgress(target, s.field, 1 + LIFE, {
+            duration: Number(p.duration), ease: 'none',
+            onComplete: () => { hideMeshes(target, KEY, true); 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/ivy.d.ts

@@ -0,0 +1,13 @@
+import { type SurfaceSample } from './surfaceSample';
+interface Growth {
+    pos: number[];
+    nrm: number[];
+    parent: number[];
+    birth: number[];
+    desc: number[];
+    count: number;
+}
+export declare function grow(sample: SurfaceSample, extent: number, attractors: number, from: string, seed: number): Growth;
+declare const _default: import("..").OperationDefinition;
+export default _default;
+//# sourceMappingURL=ivy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ivy.d.ts","sourceRoot":"","sources":["../../../src/operations/catalogue/ivy.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAmC,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAiBtF,UAAU,MAAM;IAAG,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;AAgBnH,wBAAgB,IAAI,CAAC,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAkHlH;;AAwFD,wBAgKG"}