@3driseai/3drise-viewer 0.1.16 → 0.1.17

package/dist/components/effects/ShockwaveEffect.js

@@ -1,162 +1,558 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRef, useMemo, useEffect } from 'react';
-import { useFrame } from '@react-three/fiber';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
 import { applyGenerativeAnimations } from '../../utils/handleGenerativeEffectsAnimations.js';
 import { useObjectReady } from '../../hooks/useObjectReady.js';
-// Ring vertex — organic warp + vertical ripple
-const vertexShader = /* glsl */ `
-  uniform float uProgress;
-  uniform float uExpansionScale;
-
-  void main() {
-    vec3 pos = position;
-    float expansion = 1.0 + uProgress * uExpansionScale;
-    pos.x *= expansion;
-    pos.y *= expansion;
-
-    // Organic warp: slight Z ripple based on angle along the torus
-    float angle = atan(pos.y, pos.x);
-    float warp = sin(angle * 8.0 + uProgress * 18.0) * 0.018 * (1.0 - uProgress);
-    pos.z += warp;
+/**
+ * A Sedov–Taylor blast wave: a razor-bright front over a compressed shell that bursts out, slows and cools, raising dust and a brief condensation dome. Use for explosions, impacts, sci-fi pulses.
+ *
+ * R ∝ t^(2/5) · ρ₂/ρ₁ = (γ+1)/(γ−1) = 4 · ρ(r) ≈ 4(r/R)^9 · front heat ∝ Ṙ² · grain kick at t₀ = R⁻¹(r₀)
+ */
+const NOISE3 = /* glsl */ `
+  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;
+  }
+`;
+// ---------------------------------------------------------------------------
+// Sedov–Taylor blast wave.
+// A point explosion of energy E in gas of density rho has only one length
+// scale, R = (E t^2 / rho)^(1/5), so the front bursts out fast and then
+// coasts: R ~ t^(2/5), speed dR/dt ~ t^(-3/5). The front is a strong shock:
+// the gas jumps to (gamma+1)/(gamma-1) = 4 times its density (gamma = 5/3)
+// and nearly all swept-up mass sits in a thin shell, rho(r) ~ 4 (r/R)^9,
+// leaving a hot rarefied interior. Post-shock temperature goes as the front
+// speed squared, so the front starts blue-white and cools as it slows. A thin
+// decelerating shell is overstable (Vishniac): low-order lobes grow with age.
+// Every slot carries (tau, R/Rmax, dR/dtau, fade) and (seed, flash, heat, life)
+// from the CPU clock, so the shaders only draw the state.
+// ---------------------------------------------------------------------------
+const waveCommon = /* glsl */ `
+  uniform float uTime;
+  uniform float uBound;
+  uniform float uExpansionRadius;
+  uniform float uThickness;
+  uniform float uInstability;
+  uniform float uDeceleration;
+  uniform float uShape;
+  uniform vec4 uWaveA[4];   // tau (0..1), R / Rmax, dR/dtau, fade
+  uniform vec4 uWaveB[4];   // seed, birth flash, heat (0..1), life in seconds
+  ${NOISE3}
 
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
+  // Vishniac lobes on a ring: azimuthal modes l = 3..6, amplitude growing with age
+  float ringLobes(float th, float seed, float tau){
+    float s = 0.0;
+    for (int l = 3; l <= 6; l++){
+      float fl = float(l);
+      s += sin(fl * th + seed * fl * 2.39 + uTime * 0.04 * (7.0 - fl)) / (fl - 1.5);
+    }
+    return s * uInstability * 0.1 * pow(tau, 1.3);
+  }
+  // the same on a sphere: low-frequency noise on the direction
+  float shellLobes(vec3 dir, float seed, float tau){
+    float n = vnoise(dir * 1.7 + vec3(seed * 17.0, seed * 5.0 + uTime * 0.03, 3.0));
+    n += 0.5 * vnoise(dir * 3.1 + vec3(seed * 9.0, 7.0, uTime * 0.02));
+    return (n - 0.75) * uInstability * 0.16 * pow(tau, 1.3);
+  }
+  // hot front colour: blue-white while the shock is strong, cooling to the rim colour
+  vec3 frontColour(vec3 rim, float heat){
+    return mix(rim, vec3(0.8, 0.9, 1.0), heat) * (0.55 + 2.1 * heat * heat);
   }
 `;
-const fragmentShader = /* glsl */ `
-  uniform float uProgress;
-  uniform vec3  uColor;
-  uniform vec3  uRimColor;
+// Ground mode: one disc in the XZ plane that sums all slots.
+const discVert = /* glsl */ `
+  uniform float uExpansionRadius;
+  uniform float uBound;
+  varying vec3 vLocal;
+  void main(){
+    vec3 p = vec3(position.x, 0.0, -position.y) * uExpansionRadius * uBound * 1.25;
+    vLocal = p;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4(p, 1.0);
+  }
+`;
+const discFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uRimColor;
+  uniform float uIntensity;
   uniform float uOpacity;
-  uniform float u_time;
-
-  // Cheap 1D noise for surface texture
-  float hash(float n){ return fract(sin(n) * 43758.5453); }
-
-  void main() {
-    // Core fade
-    float fade   = 1.0 - uProgress;
-
-    // Leading-edge corona: ultra-bright blast front
-    float corona = exp(-uProgress * 6.0) * 2.5;
-
-    // High-frequency energy shimmer on the ring surface
-    float shimmer = 0.75 + 0.25 * hash(uProgress * 40.0 + u_time * 7.0);
-
-    // Rim glow (raised power = tighter, brighter rim)
-    float rim     = pow(max(0.0, 1.0 - uProgress), 4.0);
-
-    // Chromatic split — push rim color toward white at the leading edge
-    vec3 rimBoosted = mix(uRimColor, vec3(1.4, 1.4, 1.6), corona * 0.5);
-    vec3 finalColor  = mix(uColor, rimBoosted, rim + corona * 0.4);
-    finalColor      += rimBoosted * corona * 0.6;
-
-    float alpha = fade * uOpacity * shimmer;
-    if (alpha < 0.005) discard;
-
-    gl_FragColor = vec4(finalColor, alpha);
+  ${waveCommon}
+  varying vec3 vLocal;
+  void main(){
+    float r = length(vLocal.xz);
+    float th = atan(vLocal.z, vLocal.x);
+    float Rmax = uExpansionRadius * uBound;
+    float aa = fwidth(r);
+    vec3 col = vec3(0.0);
+    for (int i = 0; i < 4; i++){
+      vec4 A = uWaveA[i];
+      if (A.w <= 0.0) continue;
+      vec4 B = uWaveB[i];
+      float Re = A.y * Rmax * (1.0 + ringLobes(th, B.x, A.x));
+      float d = r - Re;
+      float w = max(uThickness * uBound * 0.5, aa * 0.8);
+      // front: razor leading edge (the gas ahead is untouched), slightly softer behind the jump
+      float lead = exp(-d * d / (w * w * 0.45));
+      float trail = exp(-d * d / (w * w * 2.2));
+      float front = mix(trail, lead, smoothstep(-aa, aa, d));
+      float behind = 1.0 - smoothstep(-w, w * 0.5, d);
+      // compressed shell rho/4 = (r/R)^9 and the rarefied hot interior
+      float x = clamp(r / max(Re, 1e-4), 0.0, 1.0);
+      float shell = pow(x, 9.0) * behind;
+      float interior = x * x * behind;
+      // filaments along the front, fixed to the gas (they only change with age)
+      float fil = 0.7 + 0.6 * vnoise(vec3(cos(th) * 6.0, sin(th) * 6.0, B.x * 13.0 + A.x * 1.2));
+      vec3 hot = frontColour(uRimColor, B.z);
+      vec3 c = hot * front * fil;
+      c += mix(uRimColor, hot, 0.5) * shell * (0.3 + 0.7 * B.z) * fil;
+      c += mix(uRimColor, uColor, 0.5) * interior * 0.05 * B.z;
+      // birth flash: the front and a ground glow burn in the flash colour
+      c += uColor * B.y * (front * 2.5 + 1.1 * exp(-r * r / (uBound * uBound * 1.6)));
+      col += c * A.w;
+    }
+    col *= uIntensity * uOpacity;
+    if (max(col.r, max(col.g, col.b)) < 0.002) discard;
+    gl_FragColor = vec4(col, 1.0);
+  }
+`;
+// Sphere mode (and the condensation dome): an instanced unit sphere per slot.
+const sphereVert = /* glsl */ `
+  attribute float aSlot;
+  uniform float uHaze;
+  ${waveCommon}
+  varying vec3 vN;
+  varying vec3 vView;
+  varying vec3 vDir;
+  varying vec4 vA;
+  varying vec4 vB;
+  void main(){
+    int i = int(aSlot + 0.5);
+    vA = uWaveA[i];
+    vB = uWaveB[i];
+    vec3 dir = normalize(position);
+    vDir = dir;
+    float R = vA.y * uExpansionRadius * uBound * mix(1.0, 0.86, uHaze);
+    vec3 p = dir * R * (1.0 + shellLobes(dir, vB.x, vA.x));
+    if (vA.w <= 0.0) p = vec3(0.0);
+    vec4 wp = modelMatrix * vec4(p, 1.0);
+    vN = normalize(mat3(modelMatrix) * dir);
+    vView = cameraPosition - wp.xyz;
+    gl_Position = projectionMatrix * viewMatrix * wp;
   }
 `;
-// Flash disc at ring birth — bright flat burst that fades in ~0.2 progress
-const flashFrag = /* glsl */ `
-  uniform float uProgress;
-  uniform vec3  uColor;
+// Emission of a thin spherical shell seen at impact parameter b: the chord through
+// the shell between radii Ri and Ro. It peaks just inside the silhouette, which is
+// the physically exact version of a Fresnel edge.
+const shellFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform vec3 uRimColor;
+  uniform float uIntensity;
   uniform float uOpacity;
-
-  varying vec2 vUv;
-
-  void main() {
-    vec2 c = vUv * 2.0 - 1.0;
-    float dist = length(c);
-    if (dist > 1.0) discard;
-    float fade = exp(-uProgress * 12.0);
-    float radial = 1.0 - smoothstep(0.4, 1.0, dist);
-    float alpha = fade * radial * uOpacity * 0.9;
-    if (alpha < 0.005) discard;
-    gl_FragColor = vec4(uColor * 2.0, alpha);
+  uniform float uExpansionRadius;
+  uniform float uBound;
+  uniform float uThickness;
+  varying vec3 vN;
+  varying vec3 vView;
+  varying vec3 vDir;
+  varying vec4 vA;
+  varying vec4 vB;
+  ${NOISE3}
+  float chord(float ro, float ri, float b){
+    return 2.0 * (sqrt(max(ro * ro - b * b, 0.0)) - sqrt(max(ri * ri - b * b, 0.0)));
+  }
+  void main(){
+    if (vA.w <= 0.0) discard;
+    float mu = clamp(abs(dot(normalize(vN), normalize(vView))), 0.0, 1.0);
+    float R = max(vA.y * uExpansionRadius * uBound, 1e-3);
+    float b = R * sqrt(1.0 - mu * mu);
+    // no fwidth here: the chord profile is already smooth in b, and fwidth(b)
+    // diverges at the centre of the disc where b = R*sqrt(1 - mu*mu)
+    float w = clamp(uThickness * uBound * 0.5, R * 0.002, R * 0.2);
+    float front = chord(R, R - w, b) / (2.0 * sqrt(2.0 * R * w - w * w));
+    // compressed shell rho/4 ~ (r/R)^9: three thin slabs, weighted by that profile
+    float r1 = R * 0.965, r2 = R * 0.9, r3 = R * 0.8;
+    float shell = 0.35 * chord(R - w, r1, b) / (2.0 * sqrt(max(R * R - r1 * r1, 1e-6)))
+                + 0.09 * chord(r1, r2, b) / (2.0 * sqrt(max(R * R - r2 * r2, 1e-6)))
+                + 0.02 * chord(r2, r3, b) / (2.0 * sqrt(max(R * R - r3 * r3, 1e-6)));
+    // filaments fixed to the gas: they only change with age, never per frame
+    float fil = 0.7 + 0.6 * vnoise(vDir * 4.5 + vec3(vB.x * 13.0, vA.x * 1.2, 2.0));
+    vec3 hot = mix(uRimColor, vec3(0.8, 0.9, 1.0), vB.z) * (0.55 + 2.1 * vB.z * vB.z);
+    // a hot plasma radiates as density squared (emission measure), so square the
+    // integrated chords: the limb keeps its value and the disc goes dark
+    vec3 c = hot * front * front * 2.4 * fil;
+    c += mix(uRimColor, hot, 0.5) * shell * shell * (0.9 + 2.5 * vB.z) * fil;
+    // birth flash: the young fireball glows through
+    c += uColor * vB.y * (front * 2.5 + 0.9 * mu * mu);
+    c *= vA.w * uIntensity * uOpacity;
+    if (max(c.r, max(c.g, c.b)) < 0.002) discard;
+    gl_FragColor = vec4(c, 1.0);
   }
 `;
-const flashVert = /* glsl */ `
-  varying vec2 vUv;
-  void main() {
-    vUv = uv;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+// Wilson cloud: the rarefaction behind the front cools humid air below its dew point
+// for a moment. The haze forms just behind the shock, then evaporates from the thin
+// parts first (rising coverage threshold) as the pressure recovers.
+const hazeFrag = /* glsl */ `
+  uniform vec3 uColor;
+  uniform float uOpacity;
+  uniform float uCondensation;
+  uniform float uShape;
+  varying vec3 vN;
+  varying vec3 vView;
+  varying vec3 vDir;
+  varying vec4 vA;
+  varying vec4 vB;
+  ${NOISE3}
+  void main(){
+    float tau = vA.x;
+    float life = uCondensation * smoothstep(0.02, 0.09, tau) * (1.0 - smoothstep(0.14, 0.42, tau));
+    if (vA.w <= 0.0 || life < 0.002) discard;
+    float ground = 1.0 - step(0.5, uShape);
+    if (ground > 0.5 && vDir.y < -0.01) discard;
+    float n = fbm3(vDir * 2.3 + vec3(vB.x * 11.0, 1.0, vB.x * 5.0), 3);
+    float th = mix(0.3, 0.62, smoothstep(0.06, 0.42, tau));
+    float dens = smoothstep(th, th + 0.2, n);
+    float mu = clamp(abs(dot(normalize(vN), normalize(vView))), 0.0, 1.0);
+    float limb = min(1.0 / max(mu, 0.2), 3.0) * mix(0.45, 0.3, step(0.5, uShape));
+    float a = life * dens * limb * 0.3 * uOpacity * vA.w;
+    // the dome sits on the ground: fade its skirt in over a short height
+    a *= mix(1.0, smoothstep(-0.01, 0.12, vDir.y), ground);
+    if (a < 0.003) discard;
+    vec3 col = vec3(0.8, 0.84, 0.9) * (0.55 + 0.45 * clamp(vDir.y, 0.0, 1.0)) + uColor * vB.y * 0.6;
+    gl_FragColor = vec4(col * a, a);
   }
 `;
-const ShockwaveEffect = ({ boundingRadius, config, animations, onObjectReady, onObjectDispose }) => {
-    const { ringCount, expansionRadius, thickness, intervalSeconds, color, rimColor, opacity, speed, intensity } = config;
-    const startValuesCacheRef = useRef({});
-    const rootRef = useRef(null);
-    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
-    const meshRefs = useRef([]);
-    const flashRefs = useRef([]);
-    const makeRingStates = (count, interval) => Array.from({ length: count }, (_, i) => ({
-        progress: 0,
-        cooldown: (i / Math.max(count, 1)) * interval,
-    }));
-    const ringStates = useRef(makeRingStates(ringCount, intervalSeconds));
-    useEffect(() => {
-        ringStates.current = makeRingStates(ringCount, intervalSeconds);
-    }, [ringCount, intervalSeconds]);
-    const colorVec = useMemo(() => { const c = new THREE.Color(color); return new THREE.Vector3(c.r, c.g, c.b); }, [color]);
-    const rimColorVec = useMemo(() => { const c = new THREE.Color(rimColor); return new THREE.Vector3(c.r, c.g, c.b); }, [rimColor]);
-    const materials = useMemo(() => Array.from({ length: ringCount }, () => new THREE.ShaderMaterial({
-        vertexShader,
-        fragmentShader,
-        uniforms: {
-            uProgress: { value: 0 },
-            uExpansionScale: { value: (expansionRadius - 1) * intensity },
-            uColor: { value: colorVec },
-            uRimColor: { value: rimColorVec },
-            uOpacity: { value: opacity },
-            u_time: { value: 0 },
-        },
-        transparent: true,
-        depthWrite: false,
-        blending: THREE.AdditiveBlending,
-        side: THREE.DoubleSide,
-    })), [ringCount, expansionRadius, intensity, colorVec, rimColorVec, opacity]);
-    const flashMaterials = useMemo(() => Array.from({ length: ringCount }, () => new THREE.ShaderMaterial({
-        vertexShader: flashVert,
-        fragmentShader: flashFrag,
-        uniforms: {
-            uProgress: { value: 0 },
-            uColor: { value: colorVec },
-            uOpacity: { value: opacity },
+// Dust skirt: a grain at r0 is hit when R(t0) = r0, i.e. tau0 = r0^(1/p). It is thrown
+// up and out with a velocity proportional to the front speed at that moment, then
+// follows a ballistic path with linear drag and settles; fine grains hang longer.
+const dustVert = /* glsl */ `
+  attribute vec4 aDust;    // slot, r0 (0..1), azimuth, visibility rank
+  attribute vec4 aDust2;   // rand, rand, cos(polar), fine (0/1)
+  uniform float uDust;
+  uniform vec3 uRimColor;
+  ${waveCommon}
+  varying float vAlpha;
+  varying vec3 vCol;
+  varying float vSoft;
+  void main(){
+    int i = int(aDust.x + 0.5);
+    vec4 A = uWaveA[i];
+    vec4 B = uWaveB[i];
+    float p = mix(1.0, 0.4, uDeceleration);
+    float Rmax = uExpansionRadius * uBound;
+    float r0min = min(1.05 / max(uExpansionRadius, 1.1), 0.9);
+    float r0 = sqrt(mix(r0min * r0min, 0.94, aDust.y));
+    float tau0 = pow(r0, 1.0 / p);
+    float L = max(B.w, 0.1);
+    float s = (A.x - tau0) * L;
+    float fine = aDust2.w;
+    float v0 = min(p * pow(max(tau0, 1e-3), p - 1.0), 3.0) * Rmax / L;
+    float az = aDust.z;
+    vec3 pos;
+    if (uShape < 0.5){
+      float k = mix(1.4, 2.6, fine);
+      float g = mix(2.0, 0.4, fine) * uBound;
+      float vx = v0 * (0.12 + 0.3 * aDust2.x);
+      float vy = v0 * (0.3 + 1.0 * aDust2.y * aDust2.y) * mix(1.0, 0.7, fine);
+      float e = (1.0 - exp(-k * max(s, 0.0))) / k;
+      float rh = r0 * Rmax + vx * e;
+      float y = max((vy + g / k) * e - g * max(s, 0.0) / k, 0.0);
+      pos = vec3(cos(az) * rh, y, sin(az) * rh);
+    } else {
+      // snowplough: the grain is swept into the shell and rides just behind the front
+      float R = A.y * Rmax;
+      float sp = sqrt(max(1.0 - aDust2.z * aDust2.z, 0.0));
+      vec3 dir = vec3(sp * cos(az), aDust2.z, sp * sin(az));
+      float rr = max(r0 * Rmax, R * (0.8 + 0.14 * aDust2.x));
+      pos = dir * rr;
+    }
+    float on = step(0.0, s) * step(aDust.w, uDust) * A.w;
+    float fade = smoothstep(0.0, 0.1, s) * exp(-s / (L * mix(0.2, 0.36, fine)));
+    vAlpha = on * fade * mix(0.55, 0.26, fine) * (0.5 + 0.5 * uDust);
+    vSoft = fine;
+    // dusty brown, lit for a moment by the hot gas that just passed
+    vec3 dustC = mix(vec3(0.54, 0.42, 0.31), vec3(0.66, 0.58, 0.5), fine * 0.6 + aDust2.x * 0.3);
+    vCol = dustC + uRimColor * exp(-s * 4.0) * B.z * 1.2;
+    vec4 mv = modelViewMatrix * vec4(pos, 1.0);
+    float size = mix(0.9 + 1.1 * aDust2.y, 6.0 + 5.0 * aDust2.x, fine) * (1.0 + 0.8 * fine * min(s / L, 1.0));
+    gl_PointSize = vAlpha > 0.001 ? size * (18.0 * uBound / max(-mv.z, 0.05)) : 0.0;
+    gl_Position = projectionMatrix * mv;
+  }
+`;
+const dustFrag = /* glsl */ `
+  uniform float uOpacity;
+  varying float vAlpha;
+  varying vec3 vCol;
+  varying float vSoft;
+  void main(){
+    float d = length(gl_PointCoord - 0.5) * 2.0;
+    if (d > 1.0 || vAlpha < 0.001) discard;
+    float g = mix(exp(-d * d * 5.0), exp(-d * d * 2.5) * (1.0 - d), vSoft) * (1.0 - smoothstep(0.75, 1.0, d));
+    float a = g * vAlpha * uOpacity;
+    if (a < 0.002) discard;
+    gl_FragColor = vec4(vCol * a, a);
+  }
+`;
+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 smooth01(e0, e1, x) {
+    const t = Math.min(Math.max((x - e0) / (e1 - e0), 0), 1);
+    return t * t * (3 - 2 * t);
+}
+const DUST_PER_SLOT = 1600;
+function buildDustGeometry() {
+    const n = DUST_PER_SLOT * 4;
+    const rand = mulberry32(31);
+    const a1 = new Float32Array(n * 4);
+    const a2 = new Float32Array(n * 4);
+    for (let i = 0; i < n; i++) {
+        a1[i * 4] = i % 4;
+        a1[i * 4 + 1] = rand();
+        a1[i * 4 + 2] = rand() * Math.PI * 2;
+        a1[i * 4 + 3] = rand() * 0.999;
+        a2[i * 4] = rand();
+        a2[i * 4 + 1] = rand();
+        a2[i * 4 + 2] = rand() * 2 - 1;
+        a2[i * 4 + 3] = rand() < 0.55 ? 1 : 0;
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(n * 3), 3));
+    geo.setAttribute('aDust', new THREE.BufferAttribute(a1, 4));
+    geo.setAttribute('aDust2', new THREE.BufferAttribute(a2, 4));
+    return geo;
+}
+function buildShellGeometry() {
+    const sph = new THREE.SphereGeometry(1, 72, 48);
+    const geo = new THREE.InstancedBufferGeometry();
+    geo.setIndex(sph.getIndex());
+    geo.setAttribute('position', sph.getAttribute('position'));
+    geo.setAttribute('normal', sph.getAttribute('normal'));
+    geo.setAttribute('aSlot', new THREE.InstancedBufferAttribute(new Float32Array([0, 1, 2, 3]), 1));
+    geo.instanceCount = 4;
+    sph.dispose();
+    return geo;
+}
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSpeed: { value: 1 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 0.8 },
+        uColor: { value: new THREE.Color('#ffffff') },
+        uRimColor: { value: new THREE.Color('#88ccff') },
+        uRingCount: { value: 2 },
+        uExpansionRadius: { value: 3 },
+        uThickness: { value: 0.04 },
+        uIntervalSeconds: { value: 2 },
+        uShape: { value: 0 },
+        uDeceleration: { value: 0.85 },
+        uInstability: { value: 0.4 },
+        uDust: { value: 0.5 },
+        uCondensation: { value: 0.3 },
+        uBound: { value: 1 },
+        uWaveA: { value: [new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4()] },
+        uWaveB: { value: [new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4()] },
+    };
+}
+function applyConfig(u, c, bound, env) {
+    u.uSpeed.value = c.speed;
+    u.uIntensity.value = c.intensity;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uRimColor.value.set(c.rimColor);
+    u.uRingCount.value = c.ringCount;
+    u.uExpansionRadius.value = c.expansionRadius;
+    u.uThickness.value = c.thickness;
+    u.uIntervalSeconds.value = c.intervalSeconds;
+    u.uShape.value = c.shape;
+    u.uDeceleration.value = c.deceleration;
+    u.uInstability.value = c.instability;
+    u.uDust.value = c.dust;
+    u.uCondensation.value = c.condensation;
+    u.uBound.value = bound;
+}
+function build(u, c, bound, env) {
+    const add = { transparent: true, depthWrite: false, blending: THREE.AdditiveBlending };
+    const premul = { transparent: true, depthWrite: false, blending: THREE.NormalBlending, premultipliedAlpha: true };
+    const discMat = new THREE.ShaderMaterial({ vertexShader: discVert, fragmentShader: discFrag, uniforms: u, side: THREE.DoubleSide, ...add });
+    const shellU = { ...u, uHaze: { value: 0 } };
+    const hazeU = { ...u, uHaze: { value: 1 } };
+    const shellMat = new THREE.ShaderMaterial({ vertexShader: sphereVert, fragmentShader: shellFrag, uniforms: shellU, ...add });
+    const hazeMat = new THREE.ShaderMaterial({ vertexShader: sphereVert, fragmentShader: hazeFrag, uniforms: hazeU, ...premul });
+    const dustMat = new THREE.ShaderMaterial({ vertexShader: dustVert, fragmentShader: dustFrag, uniforms: u, ...premul });
+    const quad = new THREE.PlaneGeometry(2, 2);
+    const shellGeo = buildShellGeometry();
+    const dustGeo = buildDustGeometry();
+    const disc = new THREE.Mesh(quad, discMat);
+    const shell = new THREE.Mesh(shellGeo, shellMat);
+    const haze = new THREE.Mesh(shellGeo, hazeMat);
+    const dust = new THREE.Points(dustGeo, dustMat);
+    disc.frustumCulled = false;
+    shell.frustumCulled = false;
+    haze.frustumCulled = false;
+    dust.frustumCulled = false;
+    disc.renderOrder = 0;
+    shell.renderOrder = 0;
+    haze.renderOrder = 1;
+    dust.renderOrder = 2;
+    const group = new THREE.Group();
+    group.add(disc, shell, haze, dust);
+    // CPU clock: one launch every intervalSeconds, each front lives ringCount intervals
+    const ages = new Float32Array(4);
+    const seeds = new Float32Array(4);
+    const alive = [false, false, false, false];
+    let clock = 0;
+    let first = true;
+    let launches = 0;
+    function setVisibility() {
+        const sphere = u.uShape.value >= 0.5;
+        disc.visible = !sphere;
+        shell.visible = sphere;
+        haze.visible = u.uCondensation.value > 0.001;
+        dust.visible = u.uDust.value > 0.001;
+    }
+    return {
+        object: group,
+        materials: [discMat, shellMat, hazeMat, dustMat],
+        apply(c2) {
+            setVisibility();
         },
-        transparent: true,
-        depthWrite: false,
-        blending: THREE.AdditiveBlending,
-        side: THREE.DoubleSide,
-    })), [ringCount, colorVec, opacity]);
-    const radius = boundingRadius;
-    useFrame((state, delta) => {
-        const t = state.clock.getElapsedTime();
-        for (let i = 0; i < ringCount; i++) {
-            const state_ = ringStates.current[i];
-            const mat = materials[i];
-            const fMat = flashMaterials[i];
-            mat.uniforms.u_time.value = t;
-            if (state_.cooldown > 0) {
-                state_.cooldown -= delta;
-                mat.uniforms.uProgress.value = 1;
-                fMat.uniforms.uProgress.value = 1;
-                continue;
+        update(dt, camera) {
+            const dts = dt * u.uSpeed.value;
+            u.uTime.value += dts;
+            const n = Math.min(Math.max(Math.round(u.uRingCount.value), 1), 4);
+            const interval = Math.max(0.05, u.uIntervalSeconds.value);
+            const life = interval * n;
+            const p = 1 - 0.6 * Math.min(Math.max(u.uDeceleration.value, 0), 1);
+            for (let i = 0; i < 4; i++) {
+                if (!alive[i])
+                    continue;
+                ages[i] += dts;
+                if (ages[i] >= life || i >= n)
+                    alive[i] = false;
             }
-            state_.progress += delta * speed;
-            const p = Math.min(state_.progress, 1);
-            mat.uniforms.uProgress.value = p;
-            fMat.uniforms.uProgress.value = p;
-            if (state_.progress >= 1) {
-                state_.progress = 0;
-                state_.cooldown = intervalSeconds / speed;
+            clock += dts;
+            if (first || clock >= interval) {
+                clock = first ? 0 : Math.min(clock - interval, interval);
+                first = false;
+                let slot = -1;
+                for (let i = 0; i < n && slot < 0; i++)
+                    if (!alive[i])
+                        slot = i;
+                if (slot < 0) {
+                    slot = 0;
+                    for (let i = 1; i < n; i++)
+                        if (ages[i] > ages[slot])
+                            slot = i;
+                }
+                alive[slot] = true;
+                ages[slot] = 0;
+                seeds[slot] = (launches * 0.6180339887 + 0.137) % 1;
+                launches++;
             }
-        }
-        if (animations?.length) {
-            applyGenerativeAnimations([...materials, ...flashMaterials], animations, startValuesCacheRef.current, Date.now(), false);
-        }
+            for (let i = 0; i < 4; i++) {
+                const A = u.uWaveA.value[i];
+                const B = u.uWaveB.value[i];
+                if (!alive[i]) {
+                    A.set(0, 0, 0, 0);
+                    B.set(0, 0, 0, life);
+                    continue;
+                }
+                const tau = Math.min(ages[i] / life, 1);
+                const f = Math.pow(tau, p);
+                const v = Math.min(p * Math.pow(Math.max(tau, 1e-3), p - 1), 6);
+                const heat = (v * v) / (v * v + 1.2);
+                const fade = 1 - smooth01(0.55, 1, tau);
+                const flash = Math.exp(-ages[i] / 0.16);
+                A.set(tau, f, v, fade);
+                B.set(seeds[i], flash, heat, life);
+            }
+            setVisibility();
+        },
+        dispose() {
+            quad.dispose();
+            shellGeo.dispose();
+            dustGeo.dispose();
+            discMat.dispose();
+            shellMat.dispose();
+            hazeMat.dispose();
+            dustMat.dispose();
+        },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders. */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    color: '#ffffff',
+    opacity: 0.8,
+    ringCount: 2,
+    expansionRadius: 3,
+    thickness: 0.04,
+    intervalSeconds: 2,
+    rimColor: '#88ccff',
+    shape: 0,
+    deceleration: 0.85,
+    instability: 0.4,
+    dust: 0.5,
+    condensation: 0.3,
+};
+const ShockwaveEffect = ({ boundingRadius, config, animations, hasHost = false, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    // a standalone effect gets boundingRadius 1
+    const b = boundingRadius > 0 ? boundingRadius : 1;
+    const cfg = useMemo(() => ({ ...DEFAULTS, ...config }), [config]);
+    const env = useMemo(() => ({ hasHost: hasHost }), [hasHost]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when the host size or a structural knob changes
+    const instance = useMemo(() => build(uniforms, { ...DEFAULTS, ...config }, b, env), [uniforms, b, env]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, b, env);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, b, env]);
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera);
+        if (animations?.length)
+            applyGenerativeAnimations(instance.materials, animations, animCache.current, Date.now(), false);
     });
-    const flashR = radius * 1.05;
-    return (_jsx("group", { ref: rootRef, children: Array.from({ length: ringCount }, (_, i) => (_jsxs("group", { children: [_jsx("mesh", { ref: el => { meshRefs.current[i] = el; }, material: materials[i], rotation: [-Math.PI / 2, 0, 0], children: _jsx("torusGeometry", { args: [radius, thickness * intensity, 10, 80] }) }), _jsx("mesh", { ref: el => { flashRefs.current[i] = el; }, material: flashMaterials[i], rotation: [-Math.PI / 2, 0, 0], children: _jsx("circleGeometry", { args: [flashR, 48] }) })] }, i))) }));
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
 };
 export default ShockwaveEffect;