@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/effects/BlackHoleEffect.js

@@ -1,195 +1,325 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRef, useMemo } from 'react';
-import { useFrame } from '@react-three/fiber';
+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';
-// ── Accretion disk shader ─────────────────────────────────────────────────────
-const diskVert = /* glsl */ `
-  varying vec2 vUv;
-  void main() { vUv = uv; gl_Position = projectionMatrix * modelViewMatrix * vec4(position,1.0); }
+/**
+ * A ray-traced Schwarzschild black hole.
+ *
+ * A proxy sphere around the hole is shaded per pixel: each view ray is bent by
+ * the photon geodesic a = -1.5 h^2 x / r^5, so the disk behind the hole is
+ * lensed over and under it and a thin photon ring forms. The disk follows the
+ * Shakura-Sunyaev temperature profile T ~ r^-3/4 (1 - sqrt(r_in/r))^1/4, and
+ * its light is Doppler-beamed and gravitationally redshifted. Two jets leave
+ * along the spin axis.
+ *
+ * Distances in the shader are in units of the horizon radius (uRs).
+ * Flying the camera into the proxy flips it to back faces so the view keeps working.
+ */
+const PRE_NORMAL = { transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true };
+const ADD = { transparent: true, depthWrite: false, blending: THREE.AdditiveBlending };
+const blackHoleVert = /* glsl */ `
+  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 diskFrag = /* glsl */ `
-  uniform float u_time;
-  uniform float uRotSpeed;
-  uniform vec3  uDiskColor;
-  uniform float uOpacity;
+const blackHoleFrag = /* glsl */ `
+  uniform float uTime;
+  uniform float uRs;              // Schwarzschild radius, local units
+  uniform float uOuter;           // disk outer edge and proxy radius, in rs
+  uniform float uLensing;
+  uniform float uBeaming;
+  uniform float uRotationSpeed;
   uniform float uIntensity;
+  uniform float uOpacity;
+  uniform float uInside;          // 1 when the camera is inside the proxy sphere
+  uniform vec3  uDiskColor;
+  uniform vec3  uColor;
+  varying vec3 vLocal;
+  varying vec3 vCamLocal;
 
-  varying vec2 vUv;
+  
+  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 tempColor(float t) {
-    // t=0 outer edge (cool red), t=1 inner edge (blue-white hot)
-    vec3 outer = uDiskColor * 0.4;
-    vec3 mid   = uDiskColor;
-    vec3 inner = vec3(0.85, 0.95, 1.0) * 2.5;
-    if (t < 0.5) return mix(outer, mid,   t * 2.0);
-    else          return mix(mid,  inner, (t - 0.5) * 2.0);
+
+  // Observed temperature (1 = the disk's hottest ring at rest) to colour.
+  vec3 diskRamp(float T){
+    vec3 c0 = uDiskColor * 0.3;
+    vec3 c1 = uDiskColor;
+    vec3 c2 = vec3(1.0, 0.86, 0.66);
+    vec3 c3 = vec3(0.78, 0.87, 1.0) * 1.5;
+    if (T < 0.5) return mix(c0, c1, T * 2.0);
+    if (T < 1.0) return mix(c1, c2, (T - 0.5) * 2.0);
+    return mix(c2, c3, clamp(T - 1.0, 0.0, 1.0));
   }
 
-  float hash(float n) { return fract(sin(n) * 43758.5453); }
+  float diskNoise(float x, float ang, float off){
+    vec3 q = vec3(cos(ang) * x, sin(ang) * x, off) * 0.85;
+    float n = fbm3(q, 4);
+    // faint concentric structure, bent by the noise
+    return n + 0.18 * sin(log(x) * 22.0 + n * 5.0);
+  }
 
-  void main() {
-    // Polar coordinates from ring UV
-    vec2  centered = vUv * 2.0 - 1.0;
-    float dist     = length(centered);
-    if (dist > 1.0 || dist < 0.001) discard;
+  void main(){
+    const float RIN = 3.0;   // innermost stable circular orbit, in rs
+    vec3 ro = vCamLocal / uRs;
+    vec3 rd = normalize(vLocal - vCamLocal);
+    vec3 pos = uInside > 0.5 ? ro : vLocal / uRs;
+    vec3 vel = rd;
 
-    float angle = atan(centered.y, centered.x);
+    // h = |x cross v| is conserved along a photon path; the Schwarzschild
+    // geodesic in these units bends the ray by a = -1.5 h^2 x / r^5.
+    vec3 hv = cross(pos, vel);
+    float h2 = dot(hv, hv);
 
-    // Normalized radial position (0=inner, 1=outer)
-    float t = 1.0 - dist;
+    vec3 col = vec3(0.0);
+    float trans = 1.0;
+    float captured = 0.0;
+    float glow = 0.0;
 
-    // Spiral motion bands
-    float spiral = fract(dist * 6.0 - u_time * uRotSpeed + angle / 6.28318);
-    float bands  = pow(spiral, 2.2) * 0.6 + 0.4;
+    float ph = uTime * uRotationSpeed / 7.0;
+    float f0 = fract(ph), f1 = fract(ph + 0.5);
+    float w0 = 1.0 - abs(2.0 * f0 - 1.0);
+    float off0 = floor(ph) * 7.31, off1 = floor(ph + 0.5) * 7.31 + 3.7;
 
-    // Brightness: peaks near inner edge, falls off to rim
-    float bright = pow(t, 0.7) * bands;
+    for (int i = 0; i < 64; i++){
+      float r2 = dot(pos, pos);
+      float r = sqrt(r2);
+      if (r < 1.0){ captured = 1.0; break; }
+      if (r > uOuter * 1.02 && dot(pos, vel) > 0.0) break;
 
-    // Fine-grained turbulence
-    float noise = 0.85 + 0.15 * sin(angle * 7.0 + dist * 18.0 - u_time * 2.5);
+      float dt = clamp(0.16 * (r - 0.8), 0.03, 0.9);
+      vec3 acc = -1.5 * h2 * pos / (r2 * r2 * r) * uLensing;
+      vec3 prev = pos;
+      vel += acc * dt;
+      pos += vel * dt;
 
-    vec3  col   = tempColor(t) * bright * noise;
-    float alpha = bright * noise * uOpacity * uIntensity * smoothstep(0.0, 0.08, dist);
-    if (alpha < 0.005) discard;
-    gl_FragColor = vec4(col, alpha);
-  }
-`;
-// ── Photon sphere (lensing rim) ───────────────────────────────────────────────
-const lensFrag = /* glsl */ `
-  uniform float u_time;
-  uniform vec3  uDiskColor;
-  uniform float uOpacity;
-  uniform float uIntensity;
-  varying vec3  vNormal;
-
-  void main() {
-    vec3  viewDir = normalize(cameraPosition - vNormal * 100.0);
-    float ndv     = abs(dot(normalize(vNormal), viewDir));
-    float fresnel = pow(1.0 - ndv, 2.2);
-    // Only show a bright equatorial band
-    float equator = exp(-ndv * ndv * 6.0) * 2.5;
-    float alpha   = (fresnel * 0.4 + equator * 0.6) * uOpacity * uIntensity;
-    if (alpha < 0.005) discard;
-    vec3 col = mix(uDiskColor, vec3(1.0, 0.92, 0.8), fresnel * 0.5);
+      // light hugging the photon sphere (r = 1.5) forms the thin photon ring
+      glow += exp(-pow((r - 1.5) * 9.0, 2.0)) * dt;
+
+      // thin disk in the y = 0 plane
+      if (prev.y * pos.y < 0.0){
+        vec3 hit = mix(prev, pos, prev.y / (prev.y - pos.y));
+        float x = length(hit.xz);
+        if (x > RIN && x < uOuter){
+          // Shakura-Sunyaev thin disk: T ~ r^-3/4 (1 - sqrt(rin/r))^1/4, peak ~0.488
+          float T = pow(x / RIN, -0.75) * pow(1.0 - sqrt(RIN / x), 0.25) / 0.488;
+          // Keplerian orbit: Omega = sqrt(GM/r^3) with GM = 1/2 in these units
+          float omega = sqrt(0.5 / (x * x * x));
+          float ang = atan(hit.z, hit.x);
+          float n = diskNoise(x, ang - omega * f0 * 7.0 * 6.0, off0) * w0
+                  + diskNoise(x, ang - omega * f1 * 7.0 * 6.0, off1) * (1.0 - w0);
+          // relativistic Doppler beaming and gravitational redshift
+          vec3 vdir = normalize(vec3(-hit.z, 0.0, hit.x));
+          float beta = min(sqrt(0.5 / max(x - 1.0, 0.5)), 0.7);
+          float cosA = dot(vdir, -normalize(vel));
+          float gam = 1.0 / sqrt(1.0 - beta * beta);
+          float D = 1.0 / (gam * (1.0 - beta * cosA));
+          float g = mix(1.0, D * sqrt(1.0 - 1.0 / x), uBeaming);
+          float Tobs = T * g;
+          float edge = smoothstep(RIN, RIN * 1.15, x) * (1.0 - smoothstep(uOuter * 0.7, uOuter, x));
+          float dens = clamp(0.2 + 1.1 * (n - 0.3), 0.0, 1.0) * edge;
+          float a = clamp(dens * uOpacity * 1.4, 0.0, 1.0);
+          vec3 emit = diskRamp(Tobs) * pow(max(Tobs, 0.0), 2.2) * 1.6 * uIntensity;
+          col += trans * emit * a;
+          trans *= 1.0 - a;
+        }
+      }
+      if (trans < 0.02) break;
+    }
+
+    col += trans * uColor * glow * 0.9 * uIntensity * (1.0 - captured);
+    float alpha = captured > 0.5 ? 1.0 : clamp(1.0 - trans + glow * 0.4, 0.0, 1.0);
     gl_FragColor = vec4(col, alpha);
   }
 `;
-const lensVert = /* glsl */ `
-  varying vec3 vNormal;
-  void main() {
-    vNormal = (modelMatrix * vec4(normal, 0.0)).xyz;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
-  }
-`;
-// ── Jet particle shader ───────────────────────────────────────────────────────
 const jetVert = /* glsl */ `
-  attribute float aT;
-  attribute float aPhase;
-  uniform float   u_time;
-  uniform float   u_speed;
-  uniform float   uLength;
-  uniform float   uDir;    // +1 or -1
-  uniform float   uRadius;
-  varying float   vT;
-  void main() {
-    float t  = fract(aT + u_time * u_speed);
-    vT = t;
-    float r  = uRadius * (1.0 - t * 0.85);
-    float a  = aPhase + t * 4.0;
-    float x  = cos(a) * r;
-    float z  = sin(a) * r;
-    float y  = uDir * t * uLength;
-    vec4  mv = modelViewMatrix * vec4(x, y, z, 1.0);
-    gl_PointSize = (1.0 - t) * 6.0 * (200.0 / -mv.z);
-    gl_Position  = projectionMatrix * mv;
+  varying vec2 vUv;
+  varying vec3 vNormalW;
+  varying vec3 vViewW;
+  varying vec3 vAxisW;
+  void main(){
+    vUv = uv;
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vNormalW = normalize(mat3(modelMatrix) * normal);
+    vViewW = normalize(cameraPosition - wp.xyz);
+    vAxisW = normalize(mat3(modelMatrix) * vec3(0.0, 1.0, 0.0));
+    gl_Position = projectionMatrix * viewMatrix * wp;
   }
 `;
 const jetFrag = /* glsl */ `
+  uniform float uTime;
   uniform vec3  uJetColor;
+  uniform float uIntensity;
   uniform float uOpacity;
-  varying float vT;
-  void main() {
-    vec2  c = gl_PointCoord - 0.5;
-    if (length(c) > 0.5) discard;
-    float g = exp(-dot(c,c) * 6.0);
-    float a = g * uOpacity * (1.0 - vT) * smoothstep(0.0, 0.1, vT);
-    if (a < 0.01) discard;
-    gl_FragColor = vec4(uJetColor, a);
+  varying vec2 vUv;
+  varying vec3 vNormalW;
+  varying vec3 vViewW;
+  varying vec3 vAxisW;
+
+  
+  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;
+  }
+
+
+  void main(){
+    // optical depth is largest through the middle of the cone
+    float ndv = abs(dot(normalize(vNormalW), normalize(vViewW)));
+    float core = pow(ndv, 1.6);
+    float v = vUv.y;                       // 0 at the base, 1 at the tip
+    // knots of plasma flowing outward
+    float knots = fbm3(vec3(vUv.x * 6.2832 * 0.5, v * 5.0 - uTime * 1.2, 0.0), 3);
+    float fall = exp(-v * 2.4) * smoothstep(0.0, 0.06, v);
+    // relativistic beaming: the jet pointing at the camera is brighter
+    float beta = 0.6;
+    float cosT = dot(normalize(vAxisW), normalize(vViewW));
+    float D = 1.0 / (1.25 * (1.0 - beta * cosT));
+    float I = core * fall * (0.35 + knots) * pow(D, 2.0) * uIntensity;
+    gl_FragColor = vec4(uJetColor * I * 1.6 + vec3(I * I * 0.3), clamp(I * uOpacity, 0.0, 1.0));
   }
 `;
+const _inv = new THREE.Matrix4();
+const _cam = new THREE.Vector3();
 const BlackHoleEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
-    const { diskColor, jetEnabled, jetColor, rotationSpeed, tilt, opacity, speed, intensity } = config;
-    const startValuesCacheRef = useRef({});
-    const groupRef = useRef(null);
-    useObjectReady(groupRef, config, onObjectReady, onObjectDispose);
-    const r = boundingRadius;
-    const { diskMat, lensMat, jetMat1, jetMat2, jetGeo } = useMemo(() => {
-        const dc = new THREE.Color(diskColor);
-        const dcv = new THREE.Vector3(dc.r, dc.g, dc.b);
-        const dMat = new THREE.ShaderMaterial({
-            vertexShader: diskVert, fragmentShader: diskFrag,
-            uniforms: {
-                u_time: { value: 0 },
-                uRotSpeed: { value: rotationSpeed },
-                uDiskColor: { value: dcv },
-                uOpacity: { value: opacity },
-                uIntensity: { value: intensity },
-            },
-            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.DoubleSide,
-        });
-        const lMat = new THREE.ShaderMaterial({
-            vertexShader: lensVert, fragmentShader: lensFrag,
-            uniforms: {
-                u_time: { value: 0 },
-                uDiskColor: { value: dcv },
-                uOpacity: { value: opacity },
-                uIntensity: { value: intensity },
-            },
-            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, side: THREE.BackSide,
-        });
-        // Jet geometry (shared, mirrored with uDir ±1)
-        const JN = 80;
-        const jT = new Float32Array(JN);
-        const jPhase = new Float32Array(JN);
-        for (let i = 0; i < JN; i++) {
-            jT[i] = i / JN;
-            jPhase[i] = Math.random() * Math.PI * 2;
-        }
-        const jGeo = new THREE.BufferGeometry();
-        jGeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(JN * 3), 3));
-        jGeo.setAttribute('aT', new THREE.BufferAttribute(jT, 1));
-        jGeo.setAttribute('aPhase', new THREE.BufferAttribute(jPhase, 1));
-        jGeo.frustumCulled = false;
-        const jc = new THREE.Color(jetColor);
-        const makeJetMat = (dir) => new THREE.ShaderMaterial({
-            vertexShader: jetVert, fragmentShader: jetFrag,
-            uniforms: {
-                u_time: { value: 0 },
-                u_speed: { value: speed },
-                uLength: { value: r * 2.2 },
-                uDir: { value: dir },
-                uRadius: { value: r * 0.12 },
-                uJetColor: { value: new THREE.Vector3(jc.r, jc.g, jc.b) },
-                uOpacity: { value: opacity * 0.8 },
-            },
-            transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
-        });
-        return { diskMat: dMat, lensMat: lMat, jetMat1: makeJetMat(1), jetMat2: makeJetMat(-1), jetGeo: jGeo };
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [diskColor, jetColor, rotationSpeed, opacity, intensity, speed, r]);
-    useFrame((state) => {
-        const t = state.clock.getElapsedTime();
-        diskMat.uniforms.u_time.value = t;
-        lensMat.uniforms.u_time.value = t;
-        jetMat1.uniforms.u_time.value = t;
-        jetMat2.uniforms.u_time.value = t;
-        if (animations?.length) {
-            applyGenerativeAnimations([diskMat, lensMat, jetMat1, jetMat2], animations, startValuesCacheRef.current, Date.now(), false);
+    const { intensity = 1.2, speed = 1, color = '#ffd2a0', opacity = 0.95, diskColor = '#ff6600', jetEnabled = true, jetColor = '#88aaff', rotationSpeed = 1, tilt = 15, horizonSize = 0.4, diskOuter = 3, lensing = 1, beaming = 1, } = config;
+    const rootRef = useRef(null);
+    const diskRef = useRef(null);
+    const insideRef = useRef(false);
+    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 Rs = b * horizonSize;
+    // outer edge of the disk, in horizon radii; never inside the photon sphere region
+    const outerRs = Math.max(diskOuter / Math.max(horizonSize, 1e-3), 3.5);
+    const proxyR = Rs * outerRs * 1.03;
+    const uniforms = useMemo(() => ({
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color() },
+        uDiskColor: { value: new THREE.Color() },
+        uJetColor: { value: new THREE.Color() },
+        uRotationSpeed: { value: 1 },
+        uLensing: { value: 1 },
+        uBeaming: { value: 1 },
+        uRs: { value: 1 },
+        uOuter: { value: 7.5 },
+        uInside: { value: 0 },
+    }), []);
+    const materials = useMemo(() => [
+        new THREE.ShaderMaterial({ vertexShader: blackHoleVert, fragmentShader: blackHoleFrag, uniforms, ...PRE_NORMAL }),
+        new THREE.ShaderMaterial({ vertexShader: jetVert, fragmentShader: jetFrag, uniforms, ...ADD, side: THREE.DoubleSide }),
+    ], [uniforms]);
+    useEffect(() => () => materials.forEach((m) => m.dispose()), [materials]);
+    const proxyGeometry = useMemo(() => new THREE.SphereGeometry(proxyR, 64, 40), [proxyR]);
+    const jetGeometry = useMemo(() => {
+        const jetH = b * 2.4;
+        const g = new THREE.CylinderGeometry(Rs * 1.8, Rs * 0.25, jetH, 32, 1, true);
+        g.translate(0, jetH / 2 + Rs * 1.2, 0);
+        return g;
+    }, [b, Rs]);
+    useEffect(() => () => proxyGeometry.dispose(), [proxyGeometry]);
+    useEffect(() => () => jetGeometry.dispose(), [jetGeometry]);
+    useLayoutEffect(() => {
+        uniforms.uSpeed.value = speed;
+        uniforms.uIntensity.value = intensity;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uColor.value.set(color);
+        uniforms.uDiskColor.value.set(diskColor);
+        uniforms.uJetColor.value.set(jetColor);
+        uniforms.uRotationSpeed.value = rotationSpeed;
+        uniforms.uLensing.value = lensing;
+        uniforms.uBeaming.value = beaming;
+        uniforms.uRs.value = Rs;
+        uniforms.uOuter.value = outerRs;
+    }, [uniforms, speed, intensity, opacity, color, diskColor, jetColor, rotationSpeed, lensing, beaming, Rs, outerRs]);
+    useFrame((state, delta) => {
+        uniforms.uTime.value += delta * uniforms.uSpeed.value;
+        const disk = diskRef.current;
+        if (disk) {
+            disk.updateWorldMatrix(true, false);
+            _inv.copy(disk.matrixWorld).invert();
+            const inside = _cam.copy(state.camera.position).applyMatrix4(_inv).length() < proxyR;
+            if (inside !== insideRef.current) {
+                insideRef.current = inside;
+                const mat = materials[0];
+                uniforms.uInside.value = inside ? 1 : 0;
+                mat.side = inside ? THREE.BackSide : THREE.FrontSide;
+                mat.depthTest = !inside;
+                mat.needsUpdate = true;
+            }
         }
+        if (animations?.length)
+            applyGenerativeAnimations(materials, animations, animCache.current, Date.now(), false);
     });
-    const tiltRad = (tilt * Math.PI) / 180;
-    return (_jsxs("group", { ref: groupRef, rotation: [0, 0, tiltRad], children: [_jsx("mesh", { material: lensMat, children: _jsx("sphereGeometry", { args: [r * 0.55, 48, 48] }) }), _jsx("mesh", { material: diskMat, rotation: [Math.PI / 2, 0, 0], children: _jsx("ringGeometry", { args: [r * 0.38, r * 1.15, 72] }) }), jetEnabled && (_jsxs(_Fragment, { children: [_jsx("points", { geometry: jetGeo, material: jetMat1 }), _jsx("points", { geometry: jetGeo, material: jetMat2 })] }))] }));
+    return (_jsx("group", { ref: rootRef, children: _jsxs("group", { rotation: [0, 0, (tilt * Math.PI) / 180], children: [_jsx("mesh", { ref: diskRef, geometry: proxyGeometry, material: materials[0] }), _jsxs("group", { visible: jetEnabled, children: [_jsx("mesh", { geometry: jetGeometry, material: materials[1], frustumCulled: false }), _jsx("mesh", { geometry: jetGeometry, material: materials[1], scale: [1, -1, 1], frustumCulled: false })] })] }) }));
 };
 export default BlackHoleEffect;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DandelionSeedsEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/DandelionSeedsEffect.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAsD,MAAM,OAAO,CAAC;AAG3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,yBAA0B,SAAQ,gBAAgB;IAC/D,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AA6cD,QAAA,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC,yBAAyB,CA+B7D,CAAC;AAEF,eAAe,oBAAoB,CAAC"}