@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/effects/LichtenbergEffect.js

@@ -0,0 +1,517 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+/**
+ * A Lichtenberg figure grown by the dielectric breakdown model: a glowing fern of electricity creeps over the surface, holds, fades and regrows. Use for energy, sci-fi, power and lightning scenes.
+ *
+ * Niemeyer–Pietronero DBM: ∇²φ = 0, φ = 0 on the cluster · P(grow at i) ∝ φᵢ^η · φ from point charges Σ(1 − R₁/rᵢⱼ)
+ */
+// ---------------------------------------------------------------------------
+// Dielectric breakdown model (Niemeyer, Pietronero & Wiesmann 1984).
+// The discharge is a cluster held at potential 0 inside a field that is 1 far
+// away; the potential obeys Laplace's equation. A new site next to the cluster
+// breaks down with probability proportional to phi^eta. Tips poke furthest into
+// the field, so they see the largest phi and grow fastest; that runaway is what
+// makes the fern. eta ~ 1 gives dense, DLA-like bushes, eta ~ 3-4 thin lightning.
+// Laplace is solved with the point-charge approximation of Kim et al. (2007):
+// phi_i = sum over cluster points j of (1 - R1 / r_ij), updated incrementally.
+// The sites are a jittered Fibonacci set on the unit sphere with a k-nearest
+// neighbour graph, so the figure crawls over the host's surface.
+// ---------------------------------------------------------------------------
+function mulberry32(seed) {
+    return () => {
+        seed |= 0;
+        seed = (seed + 0x6d2b79f5) | 0;
+        let r = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+        r = (r + Math.imul(r ^ (r >>> 7), 61 | r)) ^ r;
+        return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const LB_K = 7; // neighbours per site
+const LB_FILL = 0.5; // most of the sites the discharge may take
+const LB_REACH = -0.72; // stop once a channel gets this far round the sphere (cos of the angle from the root)
+/** Grow the tree once. Returns sites, growth order, parents, subtree sizes and depths. */
+function growLichtenberg(count, eta) {
+    const n = Math.round(Math.min(Math.max(count, 800), 8000));
+    const rand = mulberry32(1931);
+    const pos = new Float32Array(n * 3);
+    const spacing = Math.sqrt((4 * Math.PI) / n);
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    // jittered Fibonacci sphere
+    for (let i = 0; i < n; i++) {
+        const y = 1 - (2 * (i + 0.5)) / n;
+        const r = Math.sqrt(Math.max(0, 1 - y * y));
+        const a = i * golden;
+        let x = Math.cos(a) * r + (rand() - 0.5) * spacing * 0.55;
+        let yy = y + (rand() - 0.5) * spacing * 0.55;
+        let z = Math.sin(a) * r + (rand() - 0.5) * spacing * 0.55;
+        const l = Math.hypot(x, yy, z);
+        x /= l;
+        yy /= l;
+        z /= l;
+        pos[i * 3] = x;
+        pos[i * 3 + 1] = yy;
+        pos[i * 3 + 2] = z;
+    }
+    // k-nearest neighbours through a uniform grid
+    const cell = spacing * 1.8;
+    const gdim = Math.ceil(2.2 / cell);
+    const cellOf = (v) => Math.min(gdim - 1, Math.max(0, Math.floor((v + 1.1) / cell)));
+    const heads = new Int32Array(gdim * gdim * gdim).fill(-1);
+    const next = new Int32Array(n);
+    for (let i = 0; i < n; i++) {
+        const key = (cellOf(pos[i * 3]) * gdim + cellOf(pos[i * 3 + 1])) * gdim + cellOf(pos[i * 3 + 2]);
+        next[i] = heads[key];
+        heads[key] = i;
+    }
+    const nbr = new Int32Array(n * LB_K).fill(-1);
+    const bestD = new Float32Array(LB_K);
+    const maxD2 = cell * cell;
+    for (let i = 0; i < n; i++) {
+        const px = pos[i * 3], py = pos[i * 3 + 1], pz = pos[i * 3 + 2];
+        const cx = cellOf(px), cy = cellOf(py), cz = cellOf(pz);
+        bestD.fill(1e9);
+        for (let ax = Math.max(0, cx - 1); ax <= Math.min(gdim - 1, cx + 1); ax++)
+            for (let ay = Math.max(0, cy - 1); ay <= Math.min(gdim - 1, cy + 1); ay++)
+                for (let az = Math.max(0, cz - 1); az <= Math.min(gdim - 1, cz + 1); az++) {
+                    for (let j = heads[(ax * gdim + ay) * gdim + az]; j >= 0; j = next[j]) {
+                        if (j === i)
+                            continue;
+                        const dx = pos[j * 3] - px, dy = pos[j * 3 + 1] - py, dz = pos[j * 3 + 2] - pz;
+                        const d2 = dx * dx + dy * dy + dz * dz;
+                        if (d2 > maxD2 || d2 >= bestD[LB_K - 1])
+                            continue;
+                        // insertion into the sorted k-best list
+                        let k = LB_K - 1;
+                        while (k > 0 && bestD[k - 1] > d2) {
+                            bestD[k] = bestD[k - 1];
+                            nbr[i * LB_K + k] = nbr[i * LB_K + k - 1];
+                            k--;
+                        }
+                        bestD[k] = d2;
+                        nbr[i * LB_K + k] = j;
+                    }
+                }
+    }
+    // --- DBM growth ------------------------------------------------------
+    const target = Math.floor(n * LB_FILL);
+    const R1 = spacing * 0.5;
+    const state = new Uint8Array(n); // 0 free, 1 candidate, 2 cluster
+    const phi = new Float64Array(n);
+    const cands = new Int32Array(n);
+    let nc = 0;
+    const order = new Int32Array(target + 1); // site index by growth step
+    const parent = new Int32Array(n).fill(-1);
+    const weights = new Float64Array(n);
+    let grown = 0;
+    // root: the site closest to a fixed direction (upper front)
+    let root = 0, rootDot = -2;
+    for (let i = 0; i < n; i++) {
+        const d = pos[i * 3] * 0.35 + pos[i * 3 + 1] * 0.8 + pos[i * 3 + 2] * 0.49;
+        if (d > rootDot) {
+            rootDot = d;
+            root = i;
+        }
+    }
+    let lo = 0, hi = 0;
+    const addSite = (s) => {
+        state[s] = 2;
+        order[grown++] = s;
+        const sx = pos[s * 3], sy = pos[s * 3 + 1], sz = pos[s * 3 + 2];
+        const rmin = R1 * 1.2;
+        lo = Infinity;
+        hi = -Infinity;
+        // remove s from the candidate list; every candidate feels the new charge
+        for (let c = 0; c < nc; c++) {
+            const j = cands[c];
+            if (j === s) {
+                cands[c] = cands[--nc];
+                c--;
+                continue;
+            }
+            const dx = pos[j * 3] - sx, dy = pos[j * 3 + 1] - sy, dz = pos[j * 3 + 2] - sz;
+            const p = phi[j] + 1 - R1 / Math.max(Math.sqrt(dx * dx + dy * dy + dz * dz), rmin);
+            phi[j] = p;
+            if (p < lo)
+                lo = p;
+            if (p > hi)
+                hi = p;
+        }
+        // new candidates get the potential of the whole cluster
+        for (let k = 0; k < LB_K; k++) {
+            const j = nbr[s * LB_K + k];
+            if (j < 0 || state[j] !== 0)
+                continue;
+            state[j] = 1;
+            const jx = pos[j * 3], jy = pos[j * 3 + 1], jz = pos[j * 3 + 2];
+            let p = 0;
+            for (let g = 0; g < grown; g++) {
+                const o = order[g];
+                const dx = pos[o * 3] - jx, dy = pos[o * 3 + 1] - jy, dz = pos[o * 3 + 2] - jz;
+                p += 1 - R1 / Math.max(Math.sqrt(dx * dx + dy * dy + dz * dz), rmin);
+            }
+            phi[j] = p;
+            if (p < lo)
+                lo = p;
+            if (p > hi)
+                hi = p;
+            cands[nc++] = j;
+        }
+    };
+    addSite(root);
+    const rx = pos[root * 3], ry = pos[root * 3 + 1], rz = pos[root * 3 + 2];
+    let reached = false;
+    while (grown < target && nc > 0 && !reached) {
+        const span = Math.max(hi - lo, 1e-9);
+        // P(i) ~ Phi_i^eta by rejection: draw a candidate uniformly, keep it with
+        // probability Phi^eta (Phi <= 1). Exact, and O(1/mean(Phi^eta)) instead of O(C).
+        let c = -1;
+        for (let tries = 0; tries < 6000; tries++) {
+            const t = Math.floor(rand() * nc);
+            if (rand() < Math.pow((phi[cands[t]] - lo) / span, eta)) {
+                c = t;
+                break;
+            }
+        }
+        if (c < 0) {
+            // fallback: roulette wheel over all candidates
+            let sum = 0;
+            for (let t = 0; t < nc; t++) {
+                sum += Math.pow((phi[cands[t]] - lo) / span, eta) + 1e-9;
+                weights[t] = sum;
+            }
+            const pick = rand() * sum;
+            c = 0;
+            while (c < nc - 1 && weights[c] < pick)
+                c++;
+        }
+        const s = cands[c];
+        // attach to the cluster neighbour that keeps the channel straightest
+        let best = -1, bestScore = -Infinity;
+        for (let k = 0; k < LB_K; k++) {
+            const j = nbr[s * LB_K + k];
+            if (j < 0 || state[j] !== 2)
+                continue;
+            const dx = pos[s * 3] - pos[j * 3], dy = pos[s * 3 + 1] - pos[j * 3 + 1], dz = pos[s * 3 + 2] - pos[j * 3 + 2];
+            const l = Math.hypot(dx, dy, dz) + 1e-9;
+            let score = -l / spacing;
+            const pj = parent[j];
+            if (pj >= 0) {
+                const ex = pos[j * 3] - pos[pj * 3], ey = pos[j * 3 + 1] - pos[pj * 3 + 1], ez = pos[j * 3 + 2] - pos[pj * 3 + 2];
+                const el = Math.hypot(ex, ey, ez) + 1e-9;
+                score += 0.8 * (dx * ex + dy * ey + dz * ez) / (l * el);
+            }
+            if (score > bestScore) {
+                bestScore = score;
+                best = j;
+            }
+        }
+        parent[s] = best;
+        addSite(s);
+        if (pos[s * 3] * rx + pos[s * 3 + 1] * ry + pos[s * 3 + 2] * rz < LB_REACH)
+            reached = true;
+    }
+    // subtree sizes (reverse growth order) and depths (forward)
+    const sub = new Float32Array(n);
+    const depth = new Float32Array(n);
+    let maxDepth = 1;
+    for (let g = 1; g < grown; g++) {
+        const s = order[g];
+        depth[s] = depth[parent[s]] + 1;
+        if (depth[s] > maxDepth)
+            maxDepth = depth[s];
+    }
+    for (let g = grown - 1; g >= 0; g--) {
+        const s = order[g];
+        sub[s] += 1;
+        if (parent[s] >= 0)
+            sub[parent[s]] += sub[s];
+    }
+    return { n, pos, order, parent, sub, depth, grown, maxDepth, spacing, root };
+}
+/** One ribbon per tree edge: endpoints, growth time, log subtree weight, path length, seed. */
+function buildLichtenbergGeometry(tree) {
+    const m = tree.grown - 1;
+    const a = new Float32Array(m * 3);
+    const b = new Float32Array(m * 3);
+    const data = new Float32Array(m * 4);
+    const logMax = Math.log(1 + tree.grown);
+    for (let g = 1; g <= m; g++) {
+        const s = tree.order[g];
+        const p = tree.parent[s];
+        const i = g - 1;
+        a[i * 3] = tree.pos[p * 3];
+        a[i * 3 + 1] = tree.pos[p * 3 + 1];
+        a[i * 3 + 2] = tree.pos[p * 3 + 2];
+        b[i * 3] = tree.pos[s * 3];
+        b[i * 3 + 1] = tree.pos[s * 3 + 1];
+        b[i * 3 + 2] = tree.pos[s * 3 + 2];
+        data[i * 4] = g / tree.grown;
+        data[i * 4 + 1] = Math.log(1 + tree.sub[s]) / logMax;
+        data[i * 4 + 2] = tree.depth[s] * tree.spacing;
+        // the parent's weight, so the ribbon starts exactly as wide as the channel it leaves
+        data[i * 4 + 3] = Math.log(1 + tree.sub[p]) / logMax;
+    }
+    const geo = new THREE.InstancedBufferGeometry();
+    // quad: x = 0..1 along the edge, y = -1..1 across
+    geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array([0, -1, 0, 1, -1, 0, 1, 1, 0, 0, 1, 0]), 3));
+    geo.setIndex([0, 1, 2, 0, 2, 3]);
+    geo.setAttribute('aA', new THREE.InstancedBufferAttribute(a, 3));
+    geo.setAttribute('aB', new THREE.InstancedBufferAttribute(b, 3));
+    geo.setAttribute('aData', new THREE.InstancedBufferAttribute(data, 4));
+    geo.instanceCount = m;
+    return geo;
+}
+const ribbonVert = /* glsl */ `
+  attribute vec3 aA;
+  attribute vec3 aB;
+  attribute vec4 aData;     // growth time 0..1, log subtree weight 0..1, path length, parent weight
+  uniform float uBound;
+  uniform float uGrowth;    // reveal front, 0..1 in growth order
+  uniform float uSteps;     // number of grown sites
+  uniform float uLineWidth;
+  varying vec2 vQuad;       // x along 0..1, y across -1..1
+  varying float vWeight;
+  varying float vAge;
+  varying float vPath;
+  varying float vFacing;
+  varying float vCoreFrac;
+  varying float vSeed;
+  varying float vAlong;
+  varying float vLenCore;
+
+  void main(){
+    float birth = aData.x;
+    // each edge takes a few growth steps to extend from its parent
+    float prog = clamp((uGrowth - birth) * uSteps / 3.0, 0.0, 1.0);
+    vAge = (uGrowth - birth) * uSteps;
+    // taper from the parent's thickness to this edge's own, so joins line up
+    vWeight = mix(min(aData.w, aData.y + 0.18), aData.y, position.x);
+    vPath = aData.z;
+    vSeed = fract(birth * 91.7 + aData.z * 13.3);
+    vec3 A = aA * uBound * 1.01;
+    vec3 B = mix(aA, aB, prog) * uBound * 1.01;
+    vec4 a = modelViewMatrix * vec4(A, 1.0);
+    vec4 b = modelViewMatrix * vec4(B, 1.0);
+    vec3 dir = b.xyz - a.xyz;
+    vec4 p = mix(a, b, position.x);
+    // camera-facing ribbon, width constant in angle (a fraction of the screen height).
+    // The quad is as wide as the glow; the hot core is a thinner line inside it.
+    vec3 side = normalize(cross(dir + vec3(1e-7), p.xyz));
+    float glowW = uLineWidth * (0.0055 + 0.026 * vWeight * vWeight);
+    float coreW = uLineWidth * (0.0011 + 0.0024 * vWeight);
+    vCoreFrac = coreW / glowW;
+    float halfW = glowW * max(-p.z, 0.01);
+    p.xyz += side * position.y * halfW * (prog > 0.0 ? 1.0 : 0.0);
+    // position along the edge, measured in core half-widths: used to cross-fade the
+    // ends so two ribbons meeting at a node add up to one continuous channel
+    float lenCore = length(dir) / max(coreW * max(-p.z, 0.01), 1e-6);
+    vAlong = position.x * lenCore;
+    vLenCore = lenCore;
+    // how much the edge faces the viewer: standalone, the far side of the ball is dimmer
+    vec3 nrm = normalize(mat3(modelViewMatrix) * normalize(aA + aB));
+    vFacing = dot(nrm, normalize(-p.xyz));
+    vQuad = vec2(position.x, position.y);
+    gl_Position = projectionMatrix * p;
+  }
+`;
+const ribbonFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uCoreColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform float uFade;
+  uniform float uTime;
+  uniform float uPulse;
+  uniform float uHasHost;
+  varying vec2 vQuad;
+  varying float vWeight;
+  varying float vAge;
+  varying float vPath;
+  varying float vFacing;
+  varying float vCoreFrac;
+  varying float vSeed;
+  varying float vAlong;
+  varying float vLenCore;
+
+  void main(){
+    if (vAge <= 0.0) discard;
+    float d = abs(vQuad.y);
+    float aa = fwidth(vQuad.y);
+    // hot core: a thin gaussian line inside the ribbon (soft, so square ribbon
+    // corners never show at a bend), never thinner than one pixel
+    float cw = max(vCoreFrac, aa * 0.8);
+    float core = exp(-(d * d) / (cw * cw) * 1.3);
+    // half strength at each end, so a pair of ribbons sums to one at their node
+    float endFade = 0.5 + 0.5 * clamp(min(vAlong, vLenCore - vAlong) / 1.3, 0.0, 1.0);
+    // glow: a tight inner halo plus a wide soft one, fading to zero at the ribbon edge
+    float glow = (exp(-d / max(vCoreFrac, 0.05) * 0.9) * 0.8 + exp(-d * d * 3.5) * 0.55) * (1.0 - smoothstep(0.5, 1.0, d));
+    // the freshly broken-down tip flashes, then settles
+    float flash = 1.0 + 2.0 * exp(-vAge / 14.0);
+    // slow pulses running outward along the channels (path length from the root)
+    float g = fract(uTime * 0.16 - vPath * 0.55);
+    float wave = exp(-g * 7.0) * smoothstep(0.0, 0.04, g);
+    float pulse = 1.0 + uPulse * 1.8 * wave * (0.25 + vWeight);
+    // gentle per-channel breathing, very slow
+    float breath = 0.85 + 0.15 * sin(uTime * 0.4 + vSeed * 6.2831);
+    float bright = flash * pulse * breath * endFade;
+    float facing = mix(mix(0.25, 1.0, smoothstep(-0.6, 0.4, vFacing)), mix(0.5, 1.0, smoothstep(0.0, 0.35, vFacing)), uHasHost);
+    vec3 col = uColor * glow * (0.2 + 1.5 * vWeight) * bright
+             + uCoreColor * core * (0.35 + 1.2 * vWeight * vWeight) * bright;
+    col *= facing * uFade * uIntensity * uOpacity;
+    gl_FragColor = vec4(col, 1.0);
+  }
+`;
+// a soft flare where the discharge enters the surface
+const rootVert = /* glsl */ `
+  uniform float uBound;
+  uniform vec3 uRoot;
+  varying vec2 vUv;
+  varying float vFacing;
+  void main(){
+    vUv = position.xy;
+    vec4 mv = modelViewMatrix * vec4(uRoot * uBound * 1.012, 1.0);
+    vec3 nrm = normalize(mat3(modelViewMatrix) * uRoot);
+    vFacing = dot(nrm, normalize(-mv.xyz));
+    mv.xy += position.xy * uBound * 0.32;
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const rootFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uCoreColor;
+  uniform float uIntensity;
+  uniform float uOpacity;
+  uniform float uFade;
+  uniform float uGrowth;
+  uniform float uHasHost;
+  varying vec2 vUv;
+  varying float vFacing;
+  void main(){
+    float d = length(vUv);
+    if (d > 1.0) discard;
+    float g = exp(-d * d * 9.0) * 0.55 + exp(-d * 45.0) * 1.4;
+    g *= 1.0 - smoothstep(0.7, 1.0, d);
+    float vis = mix(mix(0.3, 1.0, smoothstep(-0.5, 0.3, vFacing)), smoothstep(-0.1, 0.25, vFacing), uHasHost);
+    float live = uFade * smoothstep(0.0, 0.02, uGrowth);
+    vec3 col = mix(uColor, uCoreColor, exp(-d * 10.0)) * g * vis * live * uIntensity * uOpacity;
+    gl_FragColor = vec4(col, 1.0);
+  }
+`;
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uCoreColor: { value: new THREE.Color() },
+        uGrowthTime: { value: 9 },
+        uLineWidth: { value: 1 },
+        uPulse: { value: 0.6 },
+        uBound: { value: 1 },
+        uHasHost: { value: 1 },
+        uGrowth: { value: 0 },
+        uFade: { value: 1 },
+        uSteps: { value: 1 },
+        uRoot: { value: new THREE.Vector3(0, 1, 0) },
+    };
+}
+function applyConfig(u, c, bound, env) {
+    u.uSpeed.value = c.speed;
+    u.uIntensity.value = c.intensity;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uCoreColor.value.set(c.coreColor);
+    u.uGrowthTime.value = c.growthTime;
+    u.uLineWidth.value = c.lineWidth;
+    u.uPulse.value = c.pulse;
+    u.uBound.value = bound;
+    u.uHasHost.value = env && env.hasHost ? 1 : 0;
+}
+function build(u, c, bound, env) {
+    const tree = growLichtenberg(c.nodeCount, c.branching);
+    const geo = buildLichtenbergGeometry(tree);
+    u.uSteps.value = tree.grown;
+    u.uRoot.value.set(tree.pos[tree.root * 3], tree.pos[tree.root * 3 + 1], tree.pos[tree.root * 3 + 2]);
+    const add = { uniforms: u, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending };
+    const mat = new THREE.ShaderMaterial({ vertexShader: ribbonVert, fragmentShader: ribbonFrag, side: THREE.DoubleSide, ...add });
+    const rootMat = new THREE.ShaderMaterial({ vertexShader: rootVert, fragmentShader: rootFrag, ...add });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    const quad = new THREE.PlaneGeometry(2, 2);
+    const flare = new THREE.Mesh(quad, rootMat);
+    flare.frustumCulled = false;
+    flare.renderOrder = 1;
+    const spin = new THREE.Group();
+    spin.add(mesh, flare);
+    const group = new THREE.Group();
+    group.add(spin);
+    const axis = new THREE.Vector3();
+    let cycle = -1;
+    return {
+        object: group,
+        materials: [mat, rootMat],
+        apply(c2) { },
+        update(dt, camera) {
+            u.uTime.value += dt * u.uSpeed.value;
+            // grow (55%), hold (25%), fade (20%), then regrow in a new orientation
+            const period = Math.max(u.uGrowthTime.value, 0.5);
+            const cyc = u.uTime.value / period;
+            const k = Math.floor(cyc);
+            const ph = cyc - k;
+            const gp = Math.min(ph / 0.55, 1);
+            // the leader creeps out, then the breakdown accelerates
+            u.uGrowth.value = Math.pow(gp, 1.25);
+            u.uFade.value = ph < 0.8 ? 1 : 1 - (ph - 0.8) / 0.2 * ((ph - 0.8) / 0.2) * (3 - 2 * ((ph - 0.8) / 0.2));
+            if (k !== cycle) {
+                cycle = k;
+                // golden-angle turns about a tilted axis: every cycle lands somewhere new
+                axis.set(Math.sin(k * 1.3), 1.6, Math.cos(k * 2.1)).normalize();
+                spin.quaternion.setFromAxisAngle(axis, k * 2.39996);
+            }
+        },
+        dispose() { geo.dispose(); quad.dispose(); mat.dispose(); rootMat.dispose(); },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#6f9dff',
+    opacity: 1,
+    nodeCount: 3200,
+    branching: 2.2,
+    growthTime: 9,
+    lineWidth: 1,
+    pulse: 0.6,
+    coreColor: '#f2f6ff',
+};
+const LichtenbergEffect = ({ boundingRadius, config, animations, hasHost = false, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    // a standalone effect gets boundingRadius 1
+    const b = boundingRadius > 0 ? boundingRadius : 1;
+    const cfg = useMemo(() => ({ ...DEFAULTS, ...config }), [config]);
+    const env = useMemo(() => ({ hasHost: hasHost }), [hasHost]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when the host size or a structural knob changes
+    const instance = useMemo(() => build(uniforms, { ...DEFAULTS, ...config }, b, env), [uniforms, b, env, cfg.nodeCount, cfg.branching]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, b, env);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, b, env]);
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera);
+        if (animations?.length)
+            applyGenerativeAnimations(instance.materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default LichtenbergEffect;

package/dist/components/effects/MoleculesEffect.d.ts

@@ -1,7 +1,7 @@
-import type { MoleculesConfig, AnimationOptions } from '@3driseai/3drise-core';
-import React from "react";
+import React from 'react';
+import type { AnimationOptions, MoleculesConfig } from '@3driseai/3drise-core';
 import type { ObjectReadyProps } from '../../types/objectReady';
-interface MoleculesEffectProps extends ObjectReadyProps {
+export interface MoleculesEffectProps extends ObjectReadyProps {
     boundingRadius: number;
     config: MoleculesConfig;
     animations?: AnimationOptions[];

package/dist/components/effects/MoleculesEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MoleculesEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/MoleculesEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,UAAU,oBAAqB,SAAQ,gBAAgB;IACnD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AA+CD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA2HnD,CAAC;AACF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"MoleculesEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/MoleculesEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAG/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC1D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;IACxB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAgQD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA8FnD,CAAC;AAEF,eAAe,eAAe,CAAC"}