@3driseai/3drise-viewer 0.1.16 → 0.1.18

package/dist/components/effects/PortalEffect.js

@@ -1,194 +1,271 @@
 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';
-// Multi-layer vortex disc
-const discVertShader = /* glsl */ `
-  varying vec2 vUv;
-  void main() {
-    vUv = uv;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+/**
+ * A wormhole portal lying under the host.
+ *
+ * The disc is bent into Flamm's paraboloid (depth ~ sqrt(r - r_t)) so it
+ * funnels down to a throat. Through the throat you see another universe,
+ * lensed into an Einstein ring at its edge. The funnel swirls with Keplerian
+ * shear (omega ~ r^-1.5), using a two-phase flow map so the spiral never winds
+ * up, and matter falls in along log spirals, heating and blueshifting.
+ */
+const PRE_NORMAL = { transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true };
+const PRE_ADD = { transparent: true, depthWrite: false, blending: THREE.AdditiveBlending, premultipliedAlpha: true };
+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 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;
+}
+function buildInfall(count) {
+    const n = Math.round(Math.min(Math.max(count, 0), 400));
+    return { count: n, aSeed: seedTriples(n, 31) };
+}
+const portalVert = /* glsl */ `
+  uniform float uThroatSize;
+  uniform float uFunnelDepth;
+  uniform float uRadius;
+  uniform float uBound;
+  varying vec2 vP;
+  void main(){
+    // Normalised disc coordinates; the geometry is a unit disc scaled by uRadius.
+    vP = position.xy;
+    float r = length(position.xy);
+    // Flamm's paraboloid, the embedding of a Schwarzschild throat:
+    // depth falls as sqrt(r - r_throat), flat inside the throat.
+    float rt = uThroatSize;
+    float s = clamp((r - rt) / max(1.0 - rt, 1e-3), 0.0, 1.0);
+    float depth = uFunnelDepth * (1.0 - sqrt(s));
+    float Rw = uRadius * uBound;
+    vec3 pos = vec3(position.xy * Rw, -depth * Rw);
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
   }
 `;
-const discFragShader = /* glsl */ `
-  uniform float u_time;
-  uniform float uSpiralTurns;
+const portalFrag = /* glsl */ `
+  uniform float uTime;
   uniform float uRotationSpeed;
-  uniform vec3  uInnerColor;
-  uniform vec3  uOuterColor;
+  uniform float uSpiralTurns;
+  uniform float uThroatSize;
+  uniform vec3  uInnerGlowColor;
+  uniform vec3  uOuterGlowColor;
+  uniform vec3  uOtherSideColor;
   uniform float uOpacity;
   uniform float uIntensity;
+  varying vec2 vP;
 
-  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;
+  }
 
-  float hash(vec2 p){ return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
 
-  void main() {
-    vec2  centered = vUv * 2.0 - 1.0;
-    float dist     = length(centered);
-    if (dist > 1.0) discard;
+  vec3 otherSide(vec3 dir, float t){
+    // the far universe: a slow nebula and a static star field
+    float c = cos(t * 0.02), s = sin(t * 0.02);
+    dir.xz = mat2(c, -s, s, c) * dir.xz;
+    vec3 w = vec3(fbm3(dir * 1.8, 3), fbm3(dir * 1.8 + 7.1, 3), 0.0);
+    float neb = fbm3(dir * 2.6 + w * 1.5, 4);
+    vec3 col = uOtherSideColor * smoothstep(0.35, 0.8, neb) * 1.2
+             + uInnerGlowColor * smoothstep(0.55, 0.9, fbm3(dir * 4.0 + 3.0, 3)) * 0.35;
+    vec3 sp = dir * 42.0;
+    vec3 id = floor(sp);
+    vec3 f = fract(sp) - 0.5;
+    float hs = hash13(id);
+    vec3 o = (vec3(hash13(id + 1.7), hash13(id + 3.1), hash13(id + 5.3)) - 0.5) * 0.5;
+    float star = step(0.94, hs) * smoothstep(0.1, 0.0, length(f - o)) * (hs - 0.94) * 16.0;
+    return col + vec3(star);
+  }
 
-    float angle = atan(centered.y, centered.x);
+  void main(){
     const float TAU = 6.28318530718;
-    float t     = u_time * uRotationSpeed;
-
-    // Three counter-rotating spiral layers
-    float s1 = fract(dist * uSpiralTurns        - angle / TAU + t);
-    float s2 = fract(dist * uSpiralTurns * 0.6  + angle / TAU - t * 1.4);
-    float s3 = fract(dist * uSpiralTurns * 2.2  - angle / TAU * 1.5 + t * 2.1);
-
-    float w3    = pow(1.0 - dist, 2.0);
-    float vortex = s1 * 0.45 + s2 * 0.30 * (1.0 - w3) + s3 * 0.60 * w3;
-
-    // Gravitational lensing rim
-    float rimRing = exp(-pow((dist - 0.92) / 0.04, 2.0)) * 3.0;
-    float rim     = pow(smoothstep(0.85, 1.0, dist), 0.7) * 1.5;
+    float r = length(vP);
+    if (r > 1.0) discard;
+    float theta = atan(vP.y, vP.x);
+    float rt = uThroatSize;
+    float t = uTime * uRotationSpeed;
+    float aa = fwidth(r) * 1.5;
 
-    // Singularity core
-    float core        = exp(-dist * dist * 22.0) * 4.0;
-    float singularity = exp(-dist * dist * 90.0) * 8.0;
+    // ---- throat: the other side, compressed toward the rim like a fisheye.
+    // Near the throat edge light is bent hardest, so the view squeezes into
+    // a thin bright Einstein ring.
+    float s = clamp(r / rt, 0.0, 1.0);
+    float psi = pow(s, 0.55) * 1.45;
+    vec3 dir = normalize(vec3(vP / max(r, 1e-4) * sin(psi), cos(psi)));
+    vec3 inside = otherSide(dir, t) * (0.5 + 0.5 * (1.0 - s * s));
+    float throat = 1.0 - smoothstep(rt - aa, rt + aa, r);
+    float einstein = exp(-pow((r - rt) / (0.018 + aa), 2.0));
 
-    float edgeFade = 1.0 - smoothstep(0.72, 1.0, dist);
-    float noise    = hash(vec2(dist * 8.0 + t * 0.3, angle));
-    float flux     = 0.85 + 0.15 * noise;
+    // ---- funnel: swirling matter on logarithmic spiral arms with Keplerian
+    // shear (Omega ~ r^-1.5), crossfaded between two phases so it never winds tight.
+    float x = (r - rt) / max(1.0 - rt, 1e-3);
+    float omega = pow(max(r, 0.05) / 0.5, -1.5);
+    float ph = t / 6.0;
+    float f0 = fract(ph), f1 = fract(ph + 0.5);
+    float wgt = 1.0 - abs(2.0 * f0 - 1.0);
+    float th0 = theta + omega * f0 * 6.0 * 0.8;
+    float th1 = theta + omega * f1 * 6.0 * 0.8;
+    float n0 = fbm3(vec3(cos(th0) * r * 3.0, sin(th0) * r * 3.0, floor(ph) * 3.1), 4);
+    float n1 = fbm3(vec3(cos(th1) * r * 3.0, sin(th1) * r * 3.0, floor(ph + 0.5) * 3.1 + 9.0), 4);
+    float n = n0 * wgt + n1 * (1.0 - wgt);
+    float arms = 0.5 + 0.5 * sin(uSpiralTurns * log(max(r, 0.02)) * 2.2 - 2.0 * (theta + omega * t * 0.12) + n * 3.0);
+    float swirl = (smoothstep(0.25, 1.0, arms) * 0.7 + n * 0.8);
+    float bright = pow(1.0 - x, 2.2) * 1.6 + 0.08;
+    vec3 grad = mix(uOuterGlowColor, uInnerGlowColor, pow(1.0 - x, 1.8));
+    float outer = (1.0 - throat) * (1.0 - smoothstep(0.82, 1.0, r));
+    vec3 funnel = grad * swirl * bright * outer;
 
-    vec3 rimLight = mix(uOuterColor * 2.0, vec3(1.0, 0.9, 0.7), rimRing * 0.5);
-    vec3 col      = mix(rimLight, uInnerColor, vortex * 0.7 + core * 0.3) * flux;
-    col += vec3(1.0, 0.95, 0.85) * (singularity + core * 0.4);
-    col += uOuterColor * rim * 0.8;
-
-    float alpha = (vortex * 0.5 + edgeFade * 0.25 + core * 0.5 + rim * 0.4 + singularity * 0.3)
-                  * uOpacity * uIntensity;
-    if (alpha < 0.008) discard;
-    gl_FragColor = vec4(col, alpha);
+    vec3 col = inside * throat + funnel + mix(uInnerGlowColor, vec3(1.0), 0.6) * einstein * 1.4;
+    float alpha = clamp(throat + (swirl * bright * 0.8) * outer + einstein, 0.0, 1.0) * uOpacity;
+    gl_FragColor = vec4(col * uIntensity * uOpacity, alpha);
   }
 `;
-// ── Event-horizon dust — GPU animated, all motion in vertex shader ────────────
-// Each particle orbits independently at a slightly perturbed radius, height, and speed.
-const dustVertShader = /* glsl */ `
-  attribute float aAngle;     // initial angle 0..TAU
-  attribute float aRadiusOff; // -0.12..+0.12 (fractional deviation from rim radius)
-  attribute float aHeightOff; // -0.08..+0.08 relative height deviation
-  attribute float aSpeed;     // orbit speed multiplier 0.3..1.7
-  attribute float aPhase;     // twinkle phase
-
-  uniform float u_time;
+const infallVert = /* glsl */ `
+  attribute vec3 aSeed;           // x: start angle, y: phase, z: random
+  uniform float uTime;
+  uniform float uRotationSpeed;
+  uniform float uThroatSize;
+  uniform float uFunnelDepth;
   uniform float uRadius;
-  uniform float uPointSize;
-  uniform float u_speed;
-
-  varying float vAlpha;
-
-  void main() {
-    const float TAU = 6.28318530718;
-
-    float angle = aAngle + u_time * u_speed * aSpeed;
-    float r     = uRadius * (1.0 + aRadiusOff);
-    float y     = uRadius * aHeightOff * sin(angle * 2.3 + aPhase + u_time * 0.7);
-
-    vec3 pos = vec3(cos(angle) * r, y, sin(angle) * r);
-
-    // Subtle twinkle — most dust is nearly invisible, occasionally flickers bright
-    float twinkle = pow(max(0.0, sin(u_time * 1.8 + aPhase)), 6.0); // sharp spikes
-    float base    = 0.08 + 0.12 * (0.5 + 0.5 * sin(aPhase + u_time * 0.4));
-    vAlpha        = base + twinkle * 0.7;
-
-    vec4 mv      = modelViewMatrix * vec4(pos, 1.0);
-    gl_PointSize = uPointSize * (0.4 + twinkle * 1.6) * (180.0 / -mv.z);
-    gl_Position  = projectionMatrix * mv;
+  uniform float uBound;
+  uniform float uIntensity;
+  varying float vHeat;
+  varying float vFade;
+  void main(){
+    // Matter spirals in on r = r0 exp(-k tau) with Keplerian angular speed;
+    // the angle is the closed-form integral of Omega = Omega0 r^-1.5.
+    float life = fract(aSeed.y + uTime * uRotationSpeed * 0.05 * (0.7 + 0.6 * aSeed.z));
+    float r0 = 0.95;
+    float rt = uThroatSize;
+    float k = log(r0 / rt);
+    float r = r0 * exp(-k * life);
+    float om0 = 0.35;
+    float phi = aSeed.x * 6.2832 + om0 / (1.5 * k) * (pow(r / 0.5, -1.5) - pow(r0 / 0.5, -1.5)) * 3.0;
+    float s = clamp((r - rt) / max(1.0 - rt, 1e-3), 0.0, 1.0);
+    float depth = uFunnelDepth * (1.0 - sqrt(s));
+    vec3 pos = vec3(cos(phi) * r, sin(phi) * r, -depth + 0.01) * (uRadius * uBound);
+    vHeat = pow(1.0 - s, 1.5);
+    vFade = smoothstep(0.0, 0.1, life) * (1.0 - smoothstep(0.85, 1.0, life));
+    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
+    gl_PointSize = (1.2 + 3.5 * vHeat) * uIntensity * (4.0 * uRadius * uBound / max(-mv.z, 1e-3));
+    gl_Position = projectionMatrix * mv;
   }
 `;
-const dustFragShader = /* glsl */ `
-  uniform vec3  uColor;
+const infallFrag = /* glsl */ `
+  uniform vec3  uInnerGlowColor;
+  uniform vec3  uOuterGlowColor;
   uniform float uOpacity;
-  varying float vAlpha;
-
-  void main() {
-    vec2  coord = gl_PointCoord - 0.5;
-    float dist  = length(coord);
-    if (dist > 0.5) discard;
-    float glow  = exp(-dist * dist * 9.0);
-    gl_FragColor = vec4(uColor, vAlpha * uOpacity * glow);
+  varying float vHeat;
+  varying float vFade;
+  void main(){
+    float d = length(gl_PointCoord - 0.5);
+    if (d > 0.5) discard;
+    float core = smoothstep(0.5, 0.0, d);
+    // infalling matter heats up and blueshifts toward the throat
+    vec3 col = mix(uOuterGlowColor, mix(uInnerGlowColor, vec3(0.85, 0.92, 1.0), vHeat), vHeat);
+    float a = core * core * vFade * (0.3 + 0.9 * vHeat) * uOpacity;
+    gl_FragColor = vec4(col * a, a);
   }
 `;
 const PortalEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
-    const { radius, spiralTurns, innerGlowColor, outerGlowColor, rotationSpeed, particleRingEnabled, particleCount, opacity, speed, intensity } = config;
-    const startValuesCacheRef = useRef({});
+    const { intensity = 1, speed = 1, opacity = 0.95, radius = 1.5, spiralTurns = 6, innerGlowColor = '#e9e4ff', outerGlowColor = '#8800ff', rotationSpeed = 1.2, particleRingEnabled = true, particleCount = 160, throatSize = 0.38, funnelDepth = 0.6, otherSideColor = '#2a6bff', } = config;
     const rootRef = useRef(null);
+    const animCache = useRef({});
     useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
-    const r = boundingRadius * radius;
-    const innerColorVec = useMemo(() => { const c = new THREE.Color(innerGlowColor); return new THREE.Vector3(c.r, c.g, c.b); }, [innerGlowColor]);
-    const outerColorVec = useMemo(() => { const c = new THREE.Color(outerGlowColor); return new THREE.Vector3(c.r, c.g, c.b); }, [outerGlowColor]);
-    const discMaterial = useMemo(() => new THREE.ShaderMaterial({
-        vertexShader: discVertShader,
-        fragmentShader: discFragShader,
-        uniforms: {
-            u_time: { value: 0 },
-            uSpiralTurns: { value: spiralTurns },
-            uRotationSpeed: { value: rotationSpeed * speed },
-            uInnerColor: { value: innerColorVec },
-            uOuterColor: { value: outerColorVec },
-            uOpacity: { value: opacity },
-            uIntensity: { value: intensity },
-        },
-        transparent: true,
-        depthWrite: false,
-        blending: THREE.AdditiveBlending,
-        side: THREE.DoubleSide,
-    }), [spiralTurns, rotationSpeed, speed, innerColorVec, outerColorVec, opacity, intensity]);
-    // ── Event-horizon dust ──────────────────────────────────────────────────────
-    const { dustGeo, dustMat } = useMemo(() => {
-        const count = particleCount;
-        const angles = new Float32Array(count);
-        const radOffsets = new Float32Array(count);
-        const heightOffs = new Float32Array(count);
-        const speeds = new Float32Array(count);
-        const phases = new Float32Array(count);
-        for (let i = 0; i < count; i++) {
-            angles[i] = (i / count) * Math.PI * 2 + Math.random() * 0.2;
-            radOffsets[i] = (Math.random() - 0.5) * 0.24;
-            heightOffs[i] = (Math.random() - 0.5) * 0.16;
-            speeds[i] = 0.3 + Math.random() * 1.4; // wide speed spread
-            phases[i] = Math.random() * Math.PI * 2;
-        }
-        const geo = new THREE.BufferGeometry();
-        // Positions are computed entirely in vertex shader; use dummy zero positions
-        geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(count * 3), 3));
-        geo.setAttribute('aAngle', new THREE.BufferAttribute(angles, 1));
-        geo.setAttribute('aRadiusOff', new THREE.BufferAttribute(radOffsets, 1));
-        geo.setAttribute('aHeightOff', new THREE.BufferAttribute(heightOffs, 1));
-        geo.setAttribute('aSpeed', new THREE.BufferAttribute(speeds, 1));
-        geo.setAttribute('aPhase', new THREE.BufferAttribute(phases, 1));
-        // Dust color: mostly white, very slightly tinted toward innerGlowColor
-        const dustCol = new THREE.Color(innerGlowColor).lerp(new THREE.Color('#ffffff'), 0.75);
-        const dustColVec = new THREE.Vector3(dustCol.r, dustCol.g, dustCol.b);
-        const mat = new THREE.ShaderMaterial({
-            vertexShader: dustVertShader,
-            fragmentShader: dustFragShader,
-            uniforms: {
-                u_time: { value: 0 },
-                uRadius: { value: r },
-                uPointSize: { value: 5 * intensity },
-                u_speed: { value: speed * 0.5 },
-                uColor: { value: dustColVec },
-                uOpacity: { value: opacity * 0.6 },
-            },
-            transparent: true,
-            depthWrite: false,
-            blending: THREE.AdditiveBlending,
-        });
-        return { dustGeo: geo, dustMat: mat };
-    }, [particleCount, r, innerGlowColor, intensity, speed, opacity]);
-    useFrame((state) => {
-        const t = state.clock.getElapsedTime();
-        discMaterial.uniforms.u_time.value = t;
-        dustMat.uniforms.u_time.value = t;
-        if (animations?.length) {
-            applyGenerativeAnimations([discMaterial, dustMat], animations, startValuesCacheRef.current, Date.now(), false);
-        }
+    // 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 },
+        uRadius: { value: 1.5 },
+        uSpiralTurns: { value: 6 },
+        uRotationSpeed: { value: 1.2 },
+        uThroatSize: { value: 0.38 },
+        uFunnelDepth: { value: 0.6 },
+        uInnerGlowColor: { value: new THREE.Color() },
+        uOuterGlowColor: { value: new THREE.Color() },
+        uOtherSideColor: { value: new THREE.Color() },
+    }), []);
+    const materials = useMemo(() => [
+        new THREE.ShaderMaterial({ vertexShader: portalVert, fragmentShader: portalFrag, uniforms, ...PRE_NORMAL, side: THREE.DoubleSide }),
+        new THREE.ShaderMaterial({ vertexShader: infallVert, fragmentShader: infallFrag, uniforms, ...PRE_ADD }),
+    ], [uniforms]);
+    useEffect(() => () => materials.forEach((m) => m.dispose()), [materials]);
+    // a unit disc; the vertex shader scales it and bends it into the funnel
+    const discGeometry = useMemo(() => new THREE.RingGeometry(0.0005, 1, 128, 64), []);
+    useEffect(() => () => discGeometry.dispose(), [discGeometry]);
+    const infallGeometry = useMemo(() => {
+        const inf = buildInfall(particleCount);
+        const g = new THREE.BufferGeometry();
+        g.setAttribute('position', new THREE.BufferAttribute(new Float32Array(inf.count * 3), 3));
+        g.setAttribute('aSeed', new THREE.BufferAttribute(inf.aSeed, 3));
+        return g;
+    }, [particleCount]);
+    useEffect(() => () => infallGeometry.dispose(), [infallGeometry]);
+    useLayoutEffect(() => {
+        uniforms.uSpeed.value = speed;
+        uniforms.uBound.value = b;
+        uniforms.uIntensity.value = intensity;
+        uniforms.uOpacity.value = opacity;
+        uniforms.uRadius.value = radius;
+        uniforms.uSpiralTurns.value = spiralTurns;
+        uniforms.uRotationSpeed.value = rotationSpeed;
+        uniforms.uThroatSize.value = throatSize;
+        uniforms.uFunnelDepth.value = funnelDepth;
+        uniforms.uInnerGlowColor.value.set(innerGlowColor);
+        uniforms.uOuterGlowColor.value.set(outerGlowColor);
+        uniforms.uOtherSideColor.value.set(otherSideColor);
+    }, [uniforms, speed, b, intensity, opacity, radius, spiralTurns, rotationSpeed, throatSize, funnelDepth, innerGlowColor, outerGlowColor, otherSideColor]);
+    useFrame((_, delta) => {
+        uniforms.uTime.value += delta * uniforms.uSpeed.value;
+        if (animations?.length)
+            applyGenerativeAnimations(materials, animations, animCache.current, Date.now(), false);
     });
-    return (_jsxs("group", { ref: rootRef, rotation: [-Math.PI / 2, 0, 0], position: [0, -boundingRadius * 0.75, 0], children: [_jsx("mesh", { material: discMaterial, children: _jsx("circleGeometry", { args: [r, 80] }) }), particleRingEnabled && (_jsx("points", { geometry: dustGeo, material: dustMat }))] }));
+    return (_jsx("group", { ref: rootRef, children: _jsxs("group", { rotation: [-Math.PI / 2, 0, 0], position: [0, -b * 0.75, 0], children: [_jsx("mesh", { geometry: discGeometry, material: materials[0], frustumCulled: false }), _jsx("points", { geometry: infallGeometry, material: materials[1], visible: particleRingEnabled, frustumCulled: false })] }) }));
 };
 export default PortalEffect;

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

@@ -1,10 +1,12 @@
-import React from "react";
-import type { ShockwaveConfig, AnimationOptions } from "@3driseai/3drise-core";
+import React from 'react';
+import type { AnimationOptions, ShockwaveConfig } from '@3driseai/3drise-core';
 import type { ObjectReadyProps } from '../../types/objectReady';
-interface ShockwaveEffectProps extends ObjectReadyProps {
+export interface ShockwaveEffectProps extends ObjectReadyProps {
     boundingRadius: number;
     config: ShockwaveConfig;
     animations?: AnimationOptions[];
+    /** True when the effect is attached to an object, so it can react to the host. */
+    hasHost?: boolean;
 }
 declare const ShockwaveEffect: React.FC<ShockwaveEffectProps>;
 export default ShockwaveEffect;

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

@@ -1 +1 @@
-{"version":3,"file":"ShockwaveEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/ShockwaveEffect.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE/E,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;AAkFD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA2EnD,CAAC;AACF,eAAe,eAAe,CAAC"}
+{"version":3,"file":"ShockwaveEffect.d.ts","sourceRoot":"","sources":["../../../src/components/effects/ShockwaveEffect.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;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AA4hBD,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CA+BnD,CAAC;AAEF,eAAe,eAAe,CAAC"}