@3driseai/3drise-viewer 0.1.16 → 0.1.17

package/dist/components/effects/StrangeAttractorEffect.js

@@ -0,0 +1,229 @@
+import { jsx as _jsx, jsxs as _jsxs } 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';
+/**
+ * Glowing trails of a strange attractor (Lorenz, Aizawa or Thomas), integrated
+ * once on the CPU with RK4. The strands start 0.001 apart and visibly part
+ * company as a hot comet head runs along them: sensitive dependence on
+ * initial conditions, made visible.
+ */
+const ATTRACTOR_SAMPLES = 1400;
+function buildAttractor(system, strands, chaos) {
+    const sys = Math.round(Math.min(Math.max(system, 0), 2));
+    const count = Math.round(Math.min(Math.max(strands, 1), 12));
+    const k = Math.min(Math.max(chaos, 0), 1);
+    let dt, sub, start, zUp, f;
+    if (sys === 0) {
+        // Lorenz; chaos scales rho around the textbook 28
+        const s = 10, r = 28 * (0.85 + 0.3 * k), b = 8 / 3;
+        dt = 0.005;
+        sub = 3;
+        start = [0.1, 0, 20];
+        zUp = true;
+        f = (x, y, z, o) => { o[0] = s * (y - x); o[1] = x * (r - z) - y; o[2] = x * y - b * z; };
+    }
+    else if (sys === 1) {
+        // Aizawa
+        const a = 0.95 * (0.9 + 0.2 * k), b = 0.7, c = 0.6, d = 3.5, e = 0.25, g = 0.1;
+        dt = 0.01;
+        sub = 3;
+        start = [0.1, 0, 0];
+        zUp = true;
+        f = (x, y, z, o) => {
+            o[0] = (z - b) * x - d * y;
+            o[1] = d * x + (z - b) * y;
+            o[2] = c + a * z - (z * z * z) / 3 - (x * x + y * y) * (1 + e * z) + g * z * x * x * x;
+        };
+    }
+    else {
+        // Thomas' cyclically symmetric attractor
+        const b = 0.208186 * (1.15 - 0.3 * k);
+        dt = 0.05;
+        sub = 2;
+        start = [1.1, 1.1, -0.01];
+        zUp = false;
+        f = (x, y, z, o) => { o[0] = Math.sin(y) - b * x; o[1] = Math.sin(z) - b * y; o[2] = Math.sin(x) - b * z; };
+    }
+    const k1 = [0, 0, 0], k2 = [0, 0, 0], k3 = [0, 0, 0], k4 = [0, 0, 0];
+    const rk4 = (p) => {
+        f(p[0], p[1], p[2], k1);
+        f(p[0] + k1[0] * dt / 2, p[1] + k1[1] * dt / 2, p[2] + k1[2] * dt / 2, k2);
+        f(p[0] + k2[0] * dt / 2, p[1] + k2[1] * dt / 2, p[2] + k2[2] * dt / 2, k3);
+        f(p[0] + k3[0] * dt, p[1] + k3[1] * dt, p[2] + k3[2] * dt, k4);
+        for (let i = 0; i < 3; i++)
+            p[i] += (dt / 6) * (k1[i] + 2 * k2[i] + 2 * k3[i] + k4[i]);
+    };
+    // settle onto the attractor first, then fan the strands out from there
+    const settled = start.slice();
+    for (let i = 0; i < 3000; i++)
+        rk4(settled);
+    const N = ATTRACTOR_SAMPLES;
+    const positions = new Float32Array(count * N * 3);
+    const t = new Float32Array(count * N);
+    const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
+    for (let sI = 0; sI < count; sI++) {
+        const p = [settled[0] + sI * 1e-3, settled[1] + sI * 5e-4, settled[2] + sI * 2.5e-4];
+        for (let i = 0; i < N; i++) {
+            for (let j = 0; j < sub; j++)
+                rk4(p);
+            const o = (sI * N + i) * 3;
+            // Lorenz and Aizawa spin about z: stand that axis up as world Y
+            const X = p[0], Y = zUp ? p[2] : p[1], Z = zUp ? p[1] : p[2];
+            positions[o] = X;
+            positions[o + 1] = Y;
+            positions[o + 2] = Z;
+            min[0] = Math.min(min[0], X);
+            max[0] = Math.max(max[0], X);
+            min[1] = Math.min(min[1], Y);
+            max[1] = Math.max(max[1], Y);
+            min[2] = Math.min(min[2], Z);
+            max[2] = Math.max(max[2], Z);
+            t[sI * N + i] = i / (N - 1);
+        }
+    }
+    // normalise into a unit sphere; the shader scales by bound * scale
+    const c = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+    const half = Math.max(max[0] - min[0], max[1] - min[1], max[2] - min[2]) / 2 || 1;
+    for (let i = 0; i < positions.length; i += 3) {
+        positions[i] = (positions[i] - c[0]) / half;
+        positions[i + 1] = (positions[i + 1] - c[1]) / half;
+        positions[i + 2] = (positions[i + 2] - c[2]) / half;
+    }
+    // segments within each strand, never across strands
+    const index = new Uint32Array(count * (N - 1) * 2);
+    let w = 0;
+    for (let sI = 0; sI < count; sI++) {
+        for (let i = 0; i < N - 1; i++) {
+            index[w++] = sI * N + i;
+            index[w++] = sI * N + i + 1;
+        }
+    }
+    const position = new THREE.BufferAttribute(positions, 3);
+    const aT = new THREE.BufferAttribute(t, 1);
+    const points = new THREE.BufferGeometry();
+    points.setAttribute('position', position);
+    points.setAttribute('aT', aT);
+    const lines = new THREE.BufferGeometry();
+    lines.setAttribute('position', position);
+    lines.setAttribute('aT', aT);
+    lines.setIndex(new THREE.BufferAttribute(index, 1));
+    return { points, lines };
+}
+const lineVert = /* glsl */ `
+  attribute float aT;
+  uniform float uTime;
+  uniform float uTrailLength;
+  uniform float uScale;
+  uniform float uBound;
+  varying float vTrail;
+
+  void main(){
+    // every strand's head sits at the same parameter, so strands that started
+    // 0.001 apart visibly part company as the head runs along them
+    float head = fract(uTime * 0.035);
+    float behind = fract(head - aT);
+    vTrail = exp(-behind / max(uTrailLength, 1e-3));
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position * uScale * uBound, 1.0);
+  }
+`;
+const lineFrag = /* glsl */ `
+  uniform vec3  uColor;
+  uniform vec3  uHeadColor;
+  uniform float uOpacity;
+  uniform float uIntensity;
+  uniform float uGhostOpacity;
+  varying float vTrail;
+
+  void main(){
+    // the fresh end of the trail runs hot, the old end cools to the base colour
+    vec3 col = mix(uColor, uHeadColor, smoothstep(0.35, 1.0, vTrail));
+    float a = (uGhostOpacity + vTrail * 0.9) * uOpacity;
+    if (a < 0.003) discard;
+    gl_FragColor = vec4(col * uIntensity * (0.6 + vTrail), a);
+  }
+`;
+const pointVert = /* glsl */ `
+  attribute float aT;
+  uniform float uTime;
+  uniform float uTrailLength;
+  uniform float uScale;
+  uniform float uBound;
+  uniform float uParticleSize;
+  uniform float uIntensity;
+  varying float vTrail;
+
+  void main(){
+    float head = fract(uTime * 0.035);
+    float behind = fract(head - aT);
+    vTrail = exp(-behind / max(uTrailLength, 1e-3));
+    float s = vTrail * vTrail * vTrail;
+    vec4 mv = modelViewMatrix * vec4(position * uScale * uBound, 1.0);
+    gl_PointSize = s < 0.02 ? 0.0 : uParticleSize * uIntensity * s * (12.0 * uBound / max(-mv.z, 1e-3));
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const pointFrag = /* glsl */ `
+  uniform vec3  uHeadColor;
+  uniform float uOpacity;
+  varying float vTrail;
+
+  void main(){
+    float d = length(gl_PointCoord - 0.5);
+    if (d > 0.5) discard;
+    float core = smoothstep(0.5, 0.0, d);
+    gl_FragColor = vec4(uHeadColor, core * core * vTrail * uOpacity);
+  }
+`;
+const StrangeAttractorEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
+    const { intensity, speed, color, opacity, system = 0, strands = 6, chaos = 0.5, trailLength = 0.18, scale = 1.4, ghostOpacity = 0.07, particleSize = 2.5, headColor = '#fff1c9', } = config;
+    const rootRef = useRef(null);
+    const spinRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    // one uniform set, shared by the trails and the head beads
+    const uniforms = useMemo(() => ({
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uHeadColor: { value: new THREE.Color() },
+        uTrailLength: { value: 0.18 },
+        uScale: { value: 1.4 },
+        uBound: { value: 1 },
+        uGhostOpacity: { value: 0.07 },
+        uParticleSize: { value: 2.5 },
+    }), []);
+    const materials = useMemo(() => [
+        new THREE.ShaderMaterial({ vertexShader: lineVert, fragmentShader: lineFrag, uniforms, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending }),
+        new THREE.ShaderMaterial({ vertexShader: pointVert, fragmentShader: pointFrag, uniforms, transparent: true, depthWrite: false, blending: THREE.AdditiveBlending }),
+    ], [uniforms]);
+    useEffect(() => () => materials.forEach((m) => m.dispose()), [materials]);
+    // integration only reruns when the trajectory itself changes
+    const geometry = useMemo(() => buildAttractor(system, strands, chaos), [system, strands, chaos]);
+    useEffect(() => () => { geometry.points.dispose(); geometry.lines.dispose(); }, [geometry]);
+    useLayoutEffect(() => {
+        uniforms.uSpeed.value = speed;
+        uniforms.uIntensity.value = intensity;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uColor.value.set(color);
+        uniforms.uHeadColor.value.set(headColor);
+        uniforms.uTrailLength.value = trailLength;
+        uniforms.uScale.value = scale;
+        uniforms.uBound.value = boundingRadius;
+        uniforms.uGhostOpacity.value = ghostOpacity;
+        uniforms.uParticleSize.value = particleSize;
+    }, [uniforms, speed, intensity, opacity, color, headColor, trailLength, scale, boundingRadius, ghostOpacity, particleSize]);
+    useFrame((_, delta) => {
+        uniforms.uTime.value += delta * uniforms.uSpeed.value;
+        if (spinRef.current)
+            spinRef.current.rotation.y += delta * 0.1 * uniforms.uSpeed.value;
+        if (animations?.length)
+            applyGenerativeAnimations(materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsxs("group", { ref: spinRef, children: [_jsx("lineSegments", { geometry: geometry.lines, material: materials[0], frustumCulled: false }), _jsx("points", { geometry: geometry.points, material: materials[1], frustumCulled: false })] }) }));
+};
+export default StrangeAttractorEffect;

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

@@ -1,10 +1,12 @@
-import React from "react";
-import type { VolumetricFogConfig, AnimationOptions } from "@3driseai/3drise-core";
+import React from 'react';
+import type { AnimationOptions, VolumetricFogConfig } from '@3driseai/3drise-core';
 import type { ObjectReadyProps } from '../../types/objectReady';
-interface VolumetricFogEffectProps extends ObjectReadyProps {
+export interface VolumetricFogEffectProps extends ObjectReadyProps {
     boundingRadius: number;
     config: VolumetricFogConfig;
     animations?: AnimationOptions[];
+    /** True when the fog surrounds a host object; the host's bounding sphere then blocks the fog behind it. */
+    hasHost?: boolean;
 }
 declare const VolumetricFogEffect: React.FC<VolumetricFogEffectProps>;
 export default VolumetricFogEffect;

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

@@ -1 +1 @@
-{"version":3,"file":"VolumetricFogEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/VolumetricFogEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,UAAU,wBAAyB,SAAQ,gBAAgB;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACnC;AAoDD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAyD3D,CAAC;AACF,eAAe,mBAAmB,CAAC"}
+{"version":3,"file":"VolumetricFogEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/VolumetricFogEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,2GAA2G;IAC3G,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAgKD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CAmF3D,CAAC;AAEF,eAAe,mBAAmB,CAAC"}

package/dist/components/effects/VolumetricFogEffect.js

@@ -1,114 +1,232 @@
 import { jsx as _jsx } 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';
-// ── Billboard fog puff — drifts slowly, never rises far ───────────────────────
+/**
+ * Ray-marched ground fog around the host.
+ *
+ * A box proxy is shaded per pixel: the view ray is marched through a
+ * domain-warped fBm density that thins with height, light is attenuated with
+ * Beer-Lambert extinction, each sample casts a short shadow ray toward the
+ * light, and a Henyey-Greenstein phase makes the fog glow when you look
+ * toward the light. Interleaved gradient noise jitters the samples so a few
+ * dozen steps look smooth.
+ *
+ * `particleCount` is kept for compatibility and now sets the quality: the march
+ * takes half that many steps.
+ */
+const PRE_NORMAL = { transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true };
 const fogVert = /* glsl */ `
-  attribute float aT;       // stagger offset 0..1
-  attribute vec3  aCenter;  // resting (x,y,z) position in fog layer
-  attribute float aPhase;
-  attribute float aSize;
-
-  uniform float u_time;
-  uniform float uDrift;    // horizontal drift speed
-  uniform float uFogRadius;
-
-  varying float vAlpha;
-
-  void main() {
-    float t = fract(aT + u_time * 0.05);  // very slow life cycle — fog is persistent
+  varying vec3 vLocal;
+  varying vec3 vCamLocal;
+  void main(){
+    vLocal = position;
+    vCamLocal = (inverse(modelMatrix) * vec4(cameraPosition, 1.0)).xyz;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+  }
+`;
+const fogFrag = /* glsl */ `
+  uniform float uTime;
+  uniform vec3  uBoxMin;
+  uniform vec3  uBoxMax;
+  uniform float uSteps;
+  uniform float uDensity;
+  uniform float uDriftSpeed;
+  uniform float uNoiseScale;
+  uniform float uAnisotropy;
+  uniform vec3  uFogColor;
+  uniform vec3  uColor;           // light colour
+  uniform float uOpacity;
+  uniform float uIntensity;
+  uniform float uHostRadius;     // 0 when there is no host object to hide behind
+  varying vec3 vLocal;
+  varying vec3 vCamLocal;
 
-    // Gentle horizontal drift — fog rolls around the base
-    float dx = sin(u_time * uDrift + aPhase)          * uFogRadius * 0.18;
-    float dz = cos(u_time * uDrift * 0.7 + aPhase * 1.3) * uFogRadius * 0.14;
-    // Slow vertical bob
-    float dy = sin(u_time * 0.25 + aPhase) * uFogRadius * 0.06;
+  
+  float hash13(vec3 p3){
+    p3 = fract(p3 * 0.1031);
+    p3 += dot(p3, p3.zyx + 31.32);
+    return fract((p3.x + p3.y) * p3.z);
+  }
+  float vnoise(vec3 p){
+    vec3 i = floor(p);
+    vec3 f = fract(p);
+    f = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
+    float n000 = hash13(i);
+    float n100 = hash13(i + vec3(1.0, 0.0, 0.0));
+    float n010 = hash13(i + vec3(0.0, 1.0, 0.0));
+    float n110 = hash13(i + vec3(1.0, 1.0, 0.0));
+    float n001 = hash13(i + vec3(0.0, 0.0, 1.0));
+    float n101 = hash13(i + vec3(1.0, 0.0, 1.0));
+    float n011 = hash13(i + vec3(0.0, 1.0, 1.0));
+    float n111 = hash13(i + vec3(1.0, 1.0, 1.0));
+    return mix(mix(mix(n000, n100, f.x), mix(n010, n110, f.x), f.y),
+               mix(mix(n001, n101, f.x), mix(n011, n111, f.x), f.y), f.z);
+  }
+  // low-frequency fBm; the rotation between octaves hides the lattice
+  const mat3 FBM_ROT = mat3(0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64);
+  float fbm3(vec3 p, int octaves){
+    float a = 0.5, s = 0.0;
+    for (int i = 0; i < 5; i++){
+      if (i >= octaves) break;
+      s += a * vnoise(p);
+      p = FBM_ROT * p * 2.02;
+      a *= 0.5;
+    }
+    return s;
+  }
 
-    vec3 pos = aCenter + vec3(dx, dy, dz);
 
-    // Puff fades in/out with its own phase to prevent popping
-    float pulse = 0.55 + 0.45 * sin(u_time * 0.35 + aPhase * 2.1);
-    vAlpha = pulse;
+  float fogDensity(vec3 p){
+    vec3 size = uBoxMax - uBoxMin;
+    float h = clamp((p.y - uBoxMin.y) / size.y, 0.0, 1.0);
+    // exponential height falloff, softened where it meets the ground
+    float layer = exp(-h * 2.4) * smoothstep(0.0, 0.06, h) * (1.0 - smoothstep(0.55, 1.0, h));
+    vec2 qc = (p.xz - 0.5 * (uBoxMin.xz + uBoxMax.xz)) / (0.5 * size.xz);
+    float radial = 1.0 - smoothstep(0.5, 1.0, length(qc));
+    if (layer * radial < 0.001) return 0.0;
+    float t = uTime * uDriftSpeed;
+    vec3 q = vec3(qc.x, h * size.y / (0.5 * size.x), qc.y) * uNoiseScale;
+    // domain warp gives rolling, folded banks instead of blobs
+    vec3 w = vec3(fbm3(q * 0.6 + vec3(t * 0.07, 0.0, 0.0), 2), fbm3(q * 0.6 + vec3(5.2, t * 0.05, 1.3), 2), 0.0);
+    float n = fbm3(q + 1.4 * w + vec3(t * 0.12, -t * 0.03, t * 0.08), 4);
+    return max(n - 0.26, 0.0) * 7.0 * layer * radial * uDensity;
+  }
 
-    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
-    gl_PointSize = aSize * (220.0 / -mv.z);
-    gl_Position  = projectionMatrix * mv;
+  float phaseHG(float cosT, float g){
+    float g2 = g * g;
+    return (1.0 - g2) / (12.566 * pow(1.0 + g2 - 2.0 * g * cosT, 1.5));
   }
-`;
-const fogFrag = /* glsl */ `
-  uniform vec3  uFogColor;
-  uniform float uDensity;
-  varying float vAlpha;
 
-  void main() {
-    vec2  c = gl_PointCoord - 0.5;
-    float d = length(c);
-    if (d > 0.5) discard;
+  void main(){
+    vec3 ro = vCamLocal;
+    vec3 rd = normalize(vLocal - vCamLocal);
+    vec3 inv = 1.0 / rd;
+    vec3 t0 = (uBoxMin - ro) * inv, t1 = (uBoxMax - ro) * inv;
+    vec3 tmn = min(t0, t1), tmx = max(t0, t1);
+    float tn = max(max(max(tmn.x, tmn.y), tmn.z), 0.0);
+    float tf = min(min(tmx.x, tmx.y), tmx.z);
+    // The host sits inside the fog; stop each ray where it meets the host's
+    // bounding sphere so fog behind the object isn't painted over it.
+    if (uHostRadius > 0.0){
+      float b = dot(ro, rd);
+      float c = dot(ro, ro) - uHostRadius * uHostRadius;
+      float disc = b * b - c;
+      if (disc > 0.0){
+        float th = -b - sqrt(disc);
+        if (th > 0.0) tf = min(tf, th);
+      }
+    }
+    if (tf <= tn) discard;
 
-    // Very soft — almost no hard edge at all
-    float g = exp(-d * d * 2.2);
+    float steps = clamp(floor(uSteps + 0.5), 12.0, 64.0);
+    float dt = (tf - tn) / steps;
+    // static interleaved-gradient dither: smooth banding without flicker
+    float jitter = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
+    float t = tn + dt * jitter;
 
-    gl_FragColor = vec4(uFogColor, g * vAlpha * uDensity);
+    vec3 L = normalize(vec3(0.45, 1.0, 0.3));
+    float phase = phaseHG(dot(rd, L), uAnisotropy);
+    float sigma = 5.0 / max(uBoxMax.x - uBoxMin.x, 1e-3);   // extinction scaled to the box
+    float shadowLen = (uBoxMax.y - uBoxMin.y) * 0.3;
+
+    vec3 col = vec3(0.0);
+    float T = 1.0;
+    for (int i = 0; i < 64; i++){
+      if (float(i) >= steps) break;
+      vec3 p = ro + rd * t;
+      float dens = fogDensity(p);
+      if (dens > 0.002){
+        // one shadow tap toward the light; Beer-Lambert for both paths
+        float dl = fogDensity(p + L * shadowLen);
+        float lightT = exp(-dl * sigma * shadowLen * 1.5);
+        vec3 S = uFogColor * (0.55 + uColor * lightT * phase * 9.0);
+        float ext = dens * sigma * dt;
+        float att = exp(-ext);
+        col += T * S * (1.0 - att);
+        T *= att;
+        if (T < 0.02) break;
+      }
+      t += dt;
+    }
+    float alpha = (1.0 - T) * uOpacity;
+    gl_FragColor = vec4(col * uIntensity * uOpacity, alpha);
   }
 `;
-const VolumetricFogEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
-    const { particleCount, fogRadius, driftSpeed, fogColor, density, opacity, intensity } = config;
-    const startValuesCacheRef = useRef({});
+const _inv = new THREE.Matrix4();
+const _cam = new THREE.Vector3();
+const VolumetricFogEffect = ({ boundingRadius, config, animations, hasHost = false, onObjectReady, onObjectDispose }) => {
+    const { intensity = 1, speed = 0.4, color = '#fff1dc', opacity = 0.9, particleCount = 60, fogRadius = 1.8, driftSpeed = 0.3, fogColor = '#c9d2dc', density = 1, layerHeight = 1.2, anisotropy = 0.55, noiseScale = 1.5, } = config;
     const rootRef = useRef(null);
+    const meshRef = useRef(null);
+    const insideRef = useRef(false);
+    const animCache = useRef({});
     useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
-    const r = boundingRadius * fogRadius;
-    const { geo, mat } = useMemo(() => {
-        const N = Math.max(20, Math.min(particleCount, 200));
-        const aT = new Float32Array(N);
-        const aCenter = new Float32Array(N * 3);
-        const aPhase = new Float32Array(N);
-        const aSize = new Float32Array(N);
-        for (let i = 0; i < N; i++) {
-            aT[i] = i / N;
-            // Distribute puffs in a disc with vertical variation at base level
-            const angle = Math.random() * Math.PI * 2;
-            const rad = Math.sqrt(Math.random()) * r;
-            const yOff = (Math.random() - 0.3) * boundingRadius * 0.35; // mostly at base, slight spread
-            aCenter[i * 3] = Math.cos(angle) * rad;
-            aCenter[i * 3 + 1] = yOff - boundingRadius * 0.3; // sit at/below object base
-            aCenter[i * 3 + 2] = Math.sin(angle) * rad;
-            aPhase[i] = Math.random() * Math.PI * 2;
-            // Large puffs — fog is billowy
-            aSize[i] = (50 + Math.random() * 70) * intensity;
-        }
-        const g = new THREE.BufferGeometry();
-        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(N * 3), 3));
-        g.setAttribute('aT', new THREE.BufferAttribute(aT, 1));
-        g.setAttribute('aCenter', new THREE.BufferAttribute(aCenter, 3));
-        g.setAttribute('aPhase', new THREE.BufferAttribute(aPhase, 1));
-        g.setAttribute('aSize', new THREE.BufferAttribute(aSize, 1));
-        g.frustumCulled = false;
-        const fc = new THREE.Color(fogColor);
-        const m = new THREE.ShaderMaterial({
-            vertexShader: fogVert,
-            fragmentShader: fogFrag,
-            uniforms: {
-                u_time: { value: 0 },
-                uDrift: { value: driftSpeed },
-                uFogRadius: { value: r },
-                uFogColor: { value: new THREE.Vector3(fc.r, fc.g, fc.b) },
-                uDensity: { value: density * opacity },
-            },
-            transparent: true,
-            depthWrite: false,
-            blending: THREE.NormalBlending,
-        });
-        return { geo: g, mat: m };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [particleCount, r, fogColor, density, driftSpeed, opacity, intensity, boundingRadius]);
-    useFrame((state) => {
-        mat.uniforms.u_time.value = state.clock.getElapsedTime();
-        if (animations?.length) {
-            applyGenerativeAnimations([mat], animations, startValuesCacheRef.current, Date.now(), false);
+    // a standalone effect gets boundingRadius 1; guard against an empty host
+    const b = boundingRadius > 0 ? boundingRadius : 1;
+    const R = b * fogRadius;
+    const H = b * layerHeight;
+    const y0 = -b;
+    const uniforms = useMemo(() => ({
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uFogColor: { value: new THREE.Color() },
+        uDensity: { value: 1 },
+        uDriftSpeed: { value: 0.3 },
+        uNoiseScale: { value: 1.5 },
+        uAnisotropy: { value: 0.55 },
+        uSteps: { value: 30 },
+        uBoxMin: { value: new THREE.Vector3() },
+        uBoxMax: { value: new THREE.Vector3() },
+        uHostRadius: { value: 0 },
+    }), []);
+    const materials = useMemo(() => [
+        new THREE.ShaderMaterial({ vertexShader: fogVert, fragmentShader: fogFrag, uniforms, ...PRE_NORMAL }),
+    ], [uniforms]);
+    useEffect(() => () => materials.forEach((m) => m.dispose()), [materials]);
+    const geometry = useMemo(() => {
+        const g = new THREE.BoxGeometry(2 * R, H, 2 * R);
+        g.translate(0, y0 + H / 2, 0);
+        return g;
+    }, [R, H, y0]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    const box = useMemo(() => new THREE.Box3(new THREE.Vector3(-R, y0, -R), new THREE.Vector3(R, y0 + H, R)), [R, H, y0]);
+    useLayoutEffect(() => {
+        uniforms.uSpeed.value = speed;
+        uniforms.uIntensity.value = intensity;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uColor.value.set(color);
+        uniforms.uFogColor.value.set(fogColor);
+        uniforms.uDensity.value = density;
+        uniforms.uDriftSpeed.value = driftSpeed;
+        uniforms.uNoiseScale.value = noiseScale;
+        uniforms.uAnisotropy.value = anisotropy;
+        uniforms.uSteps.value = Math.round(Math.min(Math.max(particleCount, 24), 128) * 0.5);
+        uniforms.uBoxMin.value.copy(box.min);
+        uniforms.uBoxMax.value.copy(box.max);
+        uniforms.uHostRadius.value = hasHost ? b * 0.97 : 0;
+    }, [uniforms, speed, intensity, opacity, color, fogColor, density, driftSpeed, noiseScale, anisotropy, particleCount, box, hasHost, b]);
+    useFrame((state, delta) => {
+        uniforms.uTime.value += delta * uniforms.uSpeed.value * 2.5;
+        const mesh = meshRef.current;
+        if (mesh) {
+            mesh.updateWorldMatrix(true, false);
+            _inv.copy(mesh.matrixWorld).invert();
+            const inside = box.containsPoint(_cam.copy(state.camera.position).applyMatrix4(_inv));
+            if (inside !== insideRef.current) {
+                insideRef.current = inside;
+                materials[0].side = inside ? THREE.BackSide : THREE.FrontSide;
+                materials[0].needsUpdate = true;
+            }
         }
+        if (animations?.length)
+            applyGenerativeAnimations(materials, animations, animCache.current, Date.now(), false);
     });
-    return _jsx("points", { ref: rootRef, geometry: geo, material: mat });
+    return (_jsx("group", { ref: rootRef, children: _jsx("mesh", { ref: meshRef, geometry: geometry, material: materials[0] }) }));
 };
 export default VolumetricFogEffect;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"WaterCausticsEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/WaterCausticsEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAGnF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,wBAAyB,SAAQ,gBAAgB;IAC9D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAkSD,QAAA,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC,wBAAwB,CA+B3D,CAAC;AAEF,eAAe,mBAAmB,CAAC"}