@3driseai/3drise-viewer 0.1.16 → 0.1.17

package/dist/components/effects/IceCrystalsEffect.js

@@ -1,192 +1,312 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRef, useMemo } from 'react';
-import { useFrame } from '@react-three/fiber';
+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';
-// ── Crystal spike shader ──────────────────────────────────────────────────────
-const spikeVert = /* glsl */ `
-  varying vec3 vNormal;
-  varying vec3 vWorldPos;
-  void main() {
-    vNormal   = normalize(normalMatrix * normal);
-    vWorldPos = (modelMatrix * vec4(position, 1.0)).xyz;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+/**
+ * Six-fold snow crystals growing as frost on the host.
+ *
+ * Each crystal is a flat plate, leaned off the surface like hoar frost. The
+ * fragment shader folds the plate into one 30-degree wedge (D6 symmetry) and
+ * draws a hexagonal plate or a dendrite with 60-degree side branches, blended
+ * by `habit`. Crystals grow like diffusion (R ~ sqrt(t)), hold, then
+ * sublimate, each on its own clock. Facets glint as they turn, and a cloud of
+ * diamond dust drifts around the host.
+ */
+const ADD = { transparent: true, depthWrite: false, blending: THREE.AdditiveBlending };
+const DUST_COUNT = 220;
+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;
+    };
+}
+function cross(a, b) { return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; }
+function add(a, b) { return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; }
+function scale(a, s) { return [a[0] * s, a[1] * s, a[2] * s]; }
+function norm(a) { const l = Math.hypot(a[0], a[1], a[2]) || 1; return [a[0] / l, a[1] / l, a[2] / l]; }
+/** Crystal transforms and seeds for n plates on a sphere of radius `bound`. */
+function layoutIceCrystals(count, bound, size) {
+    const n = Math.round(Math.min(Math.max(count, 10), 60));
+    const rand = mulberry32(5);
+    const matrices = new Float32Array(n * 16);
+    const seeds = new Float32Array(n * 3);
+    const golden = Math.PI * (3 - Math.sqrt(5));
+    for (let i = 0; i < n; i++) {
+        const y = 1 - ((i + 0.5) / n) * 2;
+        const rad = Math.sqrt(1 - y * y);
+        const ph = i * golden;
+        const nrm = [Math.cos(ph) * rad, y, Math.sin(ph) * rad];
+        // a random tangent, then lean the plate 35-65 degrees off the surface like hoar frost
+        const up = Math.abs(nrm[1]) > 0.9 ? [1, 0, 0] : [0, 1, 0];
+        let t = cross(up, nrm);
+        t = norm(t);
+        const b = cross(nrm, t);
+        const spin = rand() * Math.PI * 2;
+        const tan = norm(add(scale(t, Math.cos(spin)), scale(b, Math.sin(spin))));
+        const lean = (35 + rand() * 30) * Math.PI / 180;
+        // plate normal: tilt the surface normal toward the tangent
+        const pn = norm(add(scale(nrm, Math.cos(lean)), scale(tan, Math.sin(lean))));
+        const px = norm(cross(pn, tan).map((v) => -v));
+        const py = cross(pn, px);
+        const s = bound * size * 0.32 * (0.6 + 0.8 * rand());
+        const center = add(scale(nrm, bound * 1.01 + s * 0.45 * Math.sin(lean)), scale(tan, s * 0.45 * Math.cos(lean)));
+        const m = [
+            px[0] * s, px[1] * s, px[2] * s, 0,
+            py[0] * s, py[1] * s, py[2] * s, 0,
+            pn[0] * s, pn[1] * s, pn[2] * s, 0,
+            center[0], center[1], center[2], 1,
+        ];
+        matrices.set(m, i * 16);
+        seeds[i * 3] = rand();
+        seeds[i * 3 + 1] = rand();
+        seeds[i * 3 + 2] = rand();
+    }
+    return { count: n, matrices, seeds };
+}
+function seedTriples(count, seed) {
+    const rand = mulberry32(seed);
+    const out = new Float32Array(count * 3);
+    for (let i = 0; i < out.length; i++)
+        out[i] = rand();
+    return out;
+}
+const iceVert = /* glsl */ `
+  attribute vec3 aSeed;           // x: shape seed, y: phase, z: size jitter
+  uniform float uTime;
+  uniform float uPulseSpeed;
+  varying vec2  vUv;
+  varying vec3  vNormalW;
+  varying vec3  vViewW;
+  varying vec3  vTangentW;
+  varying vec3  vSeed;
+  varying float vGrowth;
+  void main(){
+    vUv = uv * 2.0 - 1.0;
+    vSeed = aSeed;
+    // Grow, hold, sublimate. Diffusion-limited growth: radius ~ sqrt(t).
+    float cyc = fract(uTime * uPulseSpeed * 0.06 + aSeed.y);
+    float grow = sqrt(clamp(cyc / 0.55, 0.0, 1.0));
+    float fade = 1.0 - smoothstep(0.82, 1.0, cyc);
+    vGrowth = grow * fade;
+    mat4 m = modelMatrix * instanceMatrix;
+    vec4 wp = m * vec4(position, 1.0);
+    vNormalW = normalize(mat3(m) * vec3(0.0, 0.0, 1.0));
+    vTangentW = normalize(mat3(m) * vec3(1.0, 0.0, 0.0));
+    vViewW = normalize(cameraPosition - wp.xyz);
+    gl_Position = projectionMatrix * viewMatrix * wp;
   }
 `;
-const spikeFrag = /* glsl */ `
+const iceFrag = /* glsl */ `
   uniform vec3  uIceColor;
+  uniform float uHabit;
+  uniform float uBranches;
+  uniform float uSparkle;
   uniform float uOpacity;
   uniform float uIntensity;
-  varying vec3  vNormal;
-  varying vec3  vWorldPos;
+  varying vec2  vUv;
+  varying vec3  vNormalW;
+  varying vec3  vViewW;
+  varying vec3  vTangentW;
+  varying vec3  vSeed;
+  varying float vGrowth;
+
+  const float PI = 3.14159265359;
+
+  float h1(float n){ return fract(sin(n * 12.9898) * 43758.5453); }
+  float sdSeg(vec2 p, vec2 a, vec2 b){
+    vec2 pa = p - a, ba = b - a;
+    float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+    return length(pa - ba * h);
+  }
+  float sdHexagon(vec2 p, float r){
+    const vec3 k = vec3(-0.866025404, 0.5, 0.577350269);
+    p = abs(p);
+    p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
+    p -= vec2(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+  }
+  vec3 hue(float h){ return clamp(abs(mod(h * 6.0 + vec3(0.0, 4.0, 2.0), 6.0) - 3.0) - 1.0, 0.0, 1.0); }
 
-  void main() {
-    vec3 viewDir  = normalize(cameraPosition - vWorldPos);
-    vec3 n        = normalize(vNormal);
+  void main(){
+    float R = vGrowth * 0.92;
+    if (R < 0.01) discard;
+    vec2 p = vUv;
+    float r = length(p);
+    if (r > 1.0) discard;
 
-    // Specular glint — sharp facet reflection
-    vec3 h        = normalize(viewDir + vec3(0.6, 1.0, 0.4));
-    float spec    = pow(max(dot(n, h), 0.0), 38.0) * 2.5;
+    // Six-fold symmetry: fold into a 30 degree wedge with the arm along +x.
+    float a = atan(p.y, p.x);
+    a = abs(mod(a + PI / 6.0, PI / 3.0) - PI / 6.0);
+    vec2 q = r * vec2(cos(a), sin(a));
+    float sector = floor(mod(atan(p.y, p.x) + PI / 6.0, 2.0 * PI) / (PI / 3.0));
 
-    // Fresnel edge glow
-    float fresnel = pow(1.0 - abs(dot(n, viewDir)), 2.0);
+    // Dendrite: a main arm with side branches at 60 degrees. Branches nearer
+    // the centre started earlier and are longer (tip-splitting instability).
+    float d = sdSeg(q, vec2(0.0), vec2(R, 0.0));
+    float nb = clamp(floor(uBranches + 0.5), 0.0, 7.0);
+    for (int i = 0; i < 7; i++){
+      float fi = float(i);
+      if (fi >= nb) break;
+      float xi = R * (0.16 + 0.74 * (fi + 0.5) / max(nb, 1.0)) + (h1(vSeed.x * 7.0 + fi) - 0.5) * 0.04;
+      float li = (R - xi) * uHabit * (0.55 + 0.45 * h1(vSeed.x * 13.0 + fi));
+      vec2 b0 = vec2(xi, 0.0);
+      vec2 b1 = b0 + li * vec2(0.5, 0.8660254);
+      d = min(d, sdSeg(q, b0, b1));
+      // third-order ticks on long branches
+      if (uHabit > 0.5 && li > 0.12){
+        vec2 m = mix(b0, b1, 0.55);
+        d = min(d, sdSeg(q, m, m + li * 0.3 * (uHabit - 0.4) * vec2(1.0, 0.0)));
+      }
+    }
+    // Plate habit: a hexagonal plate with a ridge, shrinking as dendrites take over.
+    float plateR = R * mix(0.62, 0.16, uHabit);
+    float plate = sdHexagon(p, plateR);
+    float ridge = abs(sdHexagon(p, plateR * 0.55));
 
-    // Facet shading: vary brightness by normal orientation
-    float shade   = 0.5 + 0.5 * abs(dot(n, normalize(vec3(1.0, 2.0, 0.5))));
+    float w = R * 0.032 + 0.006;
+    float fw = fwidth(d) + 1e-4;
+    float arms = 1.0 - smoothstep(w - fw, w + fw, d);
+    float fwp = fwidth(plate) + 1e-4;
+    float plateFill = 1.0 - smoothstep(-fwp, fwp, plate);
+    float plateLines = (1.0 - smoothstep(0.0, fwp * 1.5, abs(plate))) + (1.0 - smoothstep(0.0, fwp * 1.5, ridge)) * plateFill;
 
-    vec3  col   = uIceColor * shade + vec3(spec) + vec3(0.6, 0.9, 1.0) * fresnel * 0.5;
-    float alpha = (shade * 0.5 + fresnel * 0.35 + spec * 0.15) * uOpacity * uIntensity;
-    gl_FragColor = vec4(col, clamp(alpha, 0.0, 1.0));
+    float ice = max(arms, plateFill * 0.35);
+    if (ice + plateLines < 0.01) discard;
+
+    // Each sector is a slightly different facet: it glints only when the
+    // reflected light lines up with the eye, so sparkles follow the view.
+    vec3 N = normalize(vNormalW);
+    vec3 T = normalize(vTangentW);
+    vec3 B = cross(N, T);
+    float sa = (h1(vSeed.x * 3.0 + sector) - 0.5) * 0.7;
+    float sb = (h1(vSeed.x * 5.0 + sector) - 0.5) * 0.7;
+    vec3 Nf = normalize(N + T * sa + B * sb);
+    vec3 V = normalize(vViewW);
+    vec3 L = normalize(vec3(0.35, 1.0, 0.45));
+    vec3 H = normalize(L + V);
+    float glint = pow(max(abs(dot(Nf, H)), 0.0), 90.0) * uSparkle * 3.0;
+    float ndv = abs(dot(N, V));
+    float fres = pow(1.0 - ndv, 2.0);
+
+    // thin edges split light into colour
+    float edge = arms * (1.0 - smoothstep(0.0, w, d));
+    vec3 disp = hue(fract(d * 9.0 + ndv * 1.3 + vSeed.x)) * edge * 0.35;
+
+    vec3 col = uIceColor * (0.35 + 0.65 * fres) * ice
+             + uIceColor * plateLines * 0.6
+             + disp
+             + vec3(1.0) * glint * ice;
+    float alpha = clamp((ice * (0.35 + 0.45 * fres) + plateLines * 0.4 + glint) * uOpacity, 0.0, 1.0);
+    gl_FragColor = vec4(col * uIntensity, alpha);
   }
 `;
-// ── Frost particle shader ─────────────────────────────────────────────────────
-const frostVert = /* glsl */ `
-  attribute float aBaseY;
-  attribute float aSize;
-  attribute vec2  aXZ;
-  uniform float   u_time;
-  uniform float   uRange;
-  varying float   vA;
-  void main() {
-    float y  = mod(aBaseY - u_time * 0.35, uRange) - uRange * 0.5;
-    vec3  pos = vec3(aXZ.x, y, aXZ.y);
-    vA = 0.4 + 0.6 * smoothstep(-uRange * 0.5, -uRange * 0.3, y)
-             * smoothstep(uRange * 0.5, uRange * 0.3, y);
-    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
-    gl_PointSize = aSize * (180.0 / -mv.z);
-    gl_Position  = projectionMatrix * mv;
+const dustVert = /* glsl */ `
+  attribute vec3 aSeed;
+  uniform float uTime;
+  uniform float uBound;
+  uniform float uIntensity;
+  varying float vGlint;
+  varying float vFade;
+  void main(){
+    // diamond dust: tiny plates drifting down in a slow spiral
+    float fall = fract(aSeed.x - uTime * 0.018);
+    float y = (fall - 0.5) * 3.2 * uBound;
+    float ang = aSeed.y * 6.2832 + uTime * 0.08;
+    float rad = uBound * (1.15 + 0.9 * aSeed.z);
+    vec3 pos = vec3(cos(ang) * rad, y, sin(ang) * rad);
+    vec4 wp = modelMatrix * vec4(pos, 1.0);
+    // each plate tumbles slowly; it flashes when its face mirrors light into the eye
+    float tum = uTime * 0.35 + aSeed.z * 20.0;
+    vec3 n = normalize(vec3(sin(tum), cos(tum * 0.7 + aSeed.y * 9.0), sin(tum * 0.5 + 1.3)));
+    vec3 V = normalize(cameraPosition - wp.xyz);
+    vec3 L = normalize(vec3(0.35, 1.0, 0.45));
+    vGlint = pow(abs(dot(n, normalize(L + V))), 60.0);
+    vFade = smoothstep(0.0, 0.12, fall) * (1.0 - smoothstep(0.88, 1.0, fall));
+    vec4 mv = viewMatrix * wp;
+    gl_PointSize = (1.5 + 7.0 * vGlint) * uIntensity * (6.0 * uBound / max(-mv.z, 1e-3));
+    gl_Position = projectionMatrix * mv;
   }
 `;
-const frostFrag = /* glsl */ `
+const dustFrag = /* glsl */ `
+  uniform vec3  uIceColor;
   uniform float uOpacity;
-  varying float vA;
-  void main() {
-    vec2  c = gl_PointCoord - 0.5;
-    if (length(c) > 0.5) discard;
-    float g = exp(-dot(c, c) * 6.0);
-    gl_FragColor = vec4(0.85, 0.95, 1.0, g * vA * uOpacity);
+  uniform float uSparkle;
+  varying float vGlint;
+  varying float vFade;
+  void main(){
+    vec2 c = gl_PointCoord - 0.5;
+    float d = length(c);
+    if (d > 0.5) discard;
+    // a soft core plus a faint four-point star when it flashes
+    float core = smoothstep(0.5, 0.0, d);
+    float star = (exp(-abs(c.x) * 30.0) * exp(-c.y * c.y * 40.0) + exp(-abs(c.y) * 30.0) * exp(-c.x * c.x * 40.0)) * vGlint;
+    float a = (core * core * (0.25 + vGlint * uSparkle) + star * uSparkle) * vFade * uOpacity;
+    gl_FragColor = vec4(mix(uIceColor, vec3(1.0), 0.6 + 0.4 * vGlint), a);
   }
 `;
 const IceCrystalsEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
-    const { spikeCount, spikeLength, frostEnabled, iceColor, pulseSpeed, opacity, intensity } = config;
-    const startValuesCacheRef = useRef({});
-    const groupRef = useRef(null);
-    useObjectReady(groupRef, config, onObjectReady, onObjectDispose);
-    const timeRef = useRef(0);
-    const r = boundingRadius;
-    const N = Math.max(10, Math.min(spikeCount, 60));
-    const { spikeMesh, spikeMat, frostGeo, frostMat } = useMemo(() => {
-        const ic = new THREE.Color(iceColor);
-        // ── Spike instanced mesh ─────────────────────────────────────────────
-        const spikeLen = r * spikeLength * 0.55;
-        const spikeBase = r * 0.055 * intensity;
-        const spikeGeo = new THREE.ConeGeometry(spikeBase, spikeLen, 5);
-        // Shift cone so its base is at origin (tip points up in local space)
-        spikeGeo.translate(0, spikeLen / 2, 0);
-        const sMat = new THREE.ShaderMaterial({
-            vertexShader: spikeVert,
-            fragmentShader: spikeFrag,
-            uniforms: {
-                uIceColor: { value: new THREE.Vector3(ic.r, ic.g, ic.b) },
-                uOpacity: { value: opacity },
-                uIntensity: { value: intensity },
-            },
-            transparent: true,
-            depthWrite: false,
-            blending: THREE.AdditiveBlending,
-            side: THREE.DoubleSide,
-        });
-        const mesh = new THREE.InstancedMesh(spikeGeo, sMat, N);
-        mesh.instanceMatrix.setUsage(THREE.DynamicDrawUsage);
-        // Position spikes on Fibonacci sphere, pointing radially outward
-        const tmpPos = new THREE.Vector3();
-        const tmpQuat = new THREE.Quaternion();
-        const tmpMat = new THREE.Matrix4();
-        const UP = new THREE.Vector3(0, 1, 0);
-        const goldenAngle = Math.PI * (3 - Math.sqrt(5));
-        for (let i = 0; i < N; i++) {
-            const y = 1 - (i / (N - 1)) * 2;
-            const rad = Math.sqrt(1 - y * y) * r;
-            const phi = i * goldenAngle;
-            tmpPos.set(Math.cos(phi) * rad, y * r, Math.sin(phi) * rad);
-            // Quaternion: rotate Y-up to radial direction
-            const dir = tmpPos.clone().normalize();
-            tmpQuat.setFromUnitVectors(UP, dir);
-            // Scale Y randomly for variety
-            const scaleY = 0.6 + Math.random() * 0.8;
-            tmpMat.compose(tmpPos, tmpQuat, new THREE.Vector3(1, scaleY, 1));
-            mesh.setMatrixAt(i, tmpMat);
-        }
+    const { intensity = 1, speed = 0.5, opacity = 0.9, spikeCount = 30, spikeLength = 1, frostEnabled = true, iceColor = '#9fd8ff', pulseSpeed = 0.4, habit = 0.8, branches = 5, sparkle = 1, } = config;
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    // a standalone effect gets boundingRadius 1; guard against an empty host
+    const b = boundingRadius > 0 ? boundingRadius : 1;
+    const uniforms = useMemo(() => ({
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uBound: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uIceColor: { value: new THREE.Color() },
+        uPulseSpeed: { value: 0.4 },
+        uHabit: { value: 0.8 },
+        uBranches: { value: 5 },
+        uSparkle: { value: 1 },
+    }), []);
+    const materials = useMemo(() => [
+        new THREE.ShaderMaterial({ vertexShader: iceVert, fragmentShader: iceFrag, uniforms, ...ADD, side: THREE.DoubleSide }),
+        new THREE.ShaderMaterial({ vertexShader: dustVert, fragmentShader: dustFrag, uniforms, ...ADD }),
+    ], [uniforms]);
+    useEffect(() => () => materials.forEach((m) => m.dispose()), [materials]);
+    const crystals = useMemo(() => {
+        const layout = layoutIceCrystals(spikeCount, b, spikeLength);
+        const plate = new THREE.PlaneGeometry(2, 2);
+        plate.setAttribute('aSeed', new THREE.InstancedBufferAttribute(layout.seeds, 3));
+        const mesh = new THREE.InstancedMesh(plate, materials[0], layout.count);
+        mesh.instanceMatrix.array.set(layout.matrices);
         mesh.instanceMatrix.needsUpdate = true;
-        // ── Frost particles ──────────────────────────────────────────────────
-        const FN = 180;
-        const range = r * 2.5;
-        const fBaseY = new Float32Array(FN);
-        const fSize = new Float32Array(FN);
-        const fXZ = new Float32Array(FN * 2);
-        for (let i = 0; i < FN; i++) {
-            fBaseY[i] = Math.random() * range;
-            fSize[i] = 1.5 + Math.random() * 3.0;
-            const a = Math.random() * Math.PI * 2;
-            const fr = (0.9 + Math.random() * 0.8) * r;
-            fXZ[i * 2] = Math.cos(a) * fr;
-            fXZ[i * 2 + 1] = Math.sin(a) * fr;
-        }
-        const fGeo = new THREE.BufferGeometry();
-        fGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(FN * 3), 3));
-        fGeo.setAttribute('aBaseY', new THREE.BufferAttribute(fBaseY, 1));
-        fGeo.setAttribute('aSize', new THREE.BufferAttribute(fSize, 1));
-        fGeo.setAttribute('aXZ', new THREE.BufferAttribute(fXZ, 2));
-        fGeo.frustumCulled = false;
-        const fMat = new THREE.ShaderMaterial({
-            vertexShader: frostVert,
-            fragmentShader: frostFrag,
-            uniforms: {
-                u_time: { value: 0 },
-                uRange: { value: range },
-                uOpacity: { value: opacity * 0.55 },
-            },
-            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
-        });
-        return { spikeMesh: mesh, spikeMat: sMat, frostGeo: fGeo, frostMat: fMat };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [N, r, spikeLength, iceColor, opacity, intensity]);
-    // Pulse scale animation on spikes
-    const pulseMats = useRef([]);
-    useMemo(() => {
-        const tmpMat = new THREE.Matrix4();
-        const tmpPos = new THREE.Vector3();
-        const tmpQuat = new THREE.Quaternion();
-        const tmpScale = new THREE.Vector3();
-        pulseMats.current = Array.from({ length: N }, (_, i) => {
-            spikeMesh.getMatrixAt(i, tmpMat);
-            return tmpMat.clone();
-        });
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [spikeMesh, N]);
-    useFrame((state, delta) => {
-        timeRef.current += delta;
-        const t = timeRef.current;
-        frostMat.uniforms.u_time.value = t;
-        // Subtle spike pulse: scale Y slightly up/down per spike
-        const tmpMat = new THREE.Matrix4();
-        const tmpPos = new THREE.Vector3();
-        const tmpQuat = new THREE.Quaternion();
-        const tmpScale = new THREE.Vector3();
-        for (let i = 0; i < N; i++) {
-            const base = pulseMats.current[i];
-            base.decompose(tmpPos, tmpQuat, tmpScale);
-            const pulse = 0.88 + 0.12 * Math.sin(t * pulseSpeed * 1.8 + i * 0.47);
-            tmpScale.y = pulse;
-            tmpMat.compose(tmpPos, tmpQuat, tmpScale);
-            spikeMesh.setMatrixAt(i, tmpMat);
-        }
-        spikeMesh.instanceMatrix.needsUpdate = true;
-        if (animations?.length) {
-            applyGenerativeAnimations([spikeMat, frostMat], animations, startValuesCacheRef.current, Date.now(), false);
-        }
+        mesh.frustumCulled = false;
+        return mesh;
+    }, [spikeCount, b, spikeLength, materials]);
+    useEffect(() => () => { crystals.geometry.dispose(); crystals.dispose(); }, [crystals]);
+    const dustGeometry = useMemo(() => {
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(DUST_COUNT * 3), 3));
+        g.setAttribute('aSeed', new THREE.BufferAttribute(seedTriples(DUST_COUNT, 9), 3));
+        return g;
+    }, []);
+    useEffect(() => () => dustGeometry.dispose(), [dustGeometry]);
+    useLayoutEffect(() => {
+        uniforms.uSpeed.value = speed;
+        uniforms.uBound.value = b;
+        uniforms.uIntensity.value = intensity;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uIceColor.value.set(iceColor);
+        uniforms.uPulseSpeed.value = pulseSpeed;
+        uniforms.uHabit.value = habit;
+        uniforms.uBranches.value = branches;
+        uniforms.uSparkle.value = sparkle;
+    }, [uniforms, speed, b, intensity, opacity, iceColor, pulseSpeed, habit, branches, sparkle]);
+    useFrame((_, delta) => {
+        uniforms.uTime.value += delta * uniforms.uSpeed.value * 2;
+        if (animations?.length)
+            applyGenerativeAnimations(materials, animations, animCache.current, Date.now(), false);
     });
-    return (_jsxs("group", { ref: groupRef, children: [_jsx("primitive", { object: spikeMesh }), frostEnabled && _jsx("points", { geometry: frostGeo, material: frostMat })] }));
+    return (_jsxs("group", { ref: rootRef, children: [_jsx("primitive", { object: crystals }), _jsx("points", { geometry: dustGeometry, material: materials[1], visible: frostEnabled, frustumCulled: false })] }));
 };
 export default IceCrystalsEffect;

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

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { AnimationOptions, IceHaloConfig } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface IceHaloEffectProps extends ObjectReadyProps {
+    boundingRadius: number;
+    config: IceHaloConfig;
+    animations?: AnimationOptions[];
+    /** True when the effect is attached to an object, so it can react to the host. */
+    hasHost?: boolean;
+}
+declare const IceHaloEffect: React.FC<IceHaloEffectProps>;
+export default IceHaloEffect;
+//# sourceMappingURL=IceHaloEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IceHaloEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/IceHaloEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAG7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,kBAAmB,SAAQ,gBAAgB;IACxD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,aAAa,CAAC;IACtB,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AA4RD,QAAA,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CA+B/C,CAAC;AAEF,eAAe,aAAa,CAAC"}