@3driseai/3drise-viewer 0.1.17 → 0.1.18

package/dist/components/particles/TidalStreamParticles.js

@@ -0,0 +1,788 @@
+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 { createPointerUniforms, stepPointerField, usePointerField } from '../../utils/pointerField.js';
+import { createTrailUniforms, applyTrailConfig, createCpuTrail } from '../../utils/particleTrails.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+/**
+ * Tidal Stream — A spiral galaxy shredding dwarf satellites into tidal streams: symplectic orbits, density-wave arms, Doppler-shifted blackbody stars; the cursor is a subhalo, black hole or spectroscope. Use for space scenes.
+ */
+// Tidal Stream — a spiral galaxy cannibalising its dwarf satellites.
+// Movement: (1) Host disc + bulge on circular orbits in the halo's rotation curve, with a
+//           Lin–Shu density wave: epicyclic displacement dR = eps R cos(psi) crowds stars into
+//           log-spiral arms that rotate at a fixed pattern speed. Analytic, in the vertex shader.
+//           (2) Up to three dwarf satellites on different orbits (long arcs, radial shells, a polar
+//           ring), each a Plummer cluster whose stars are integrated with kick-drift-kick leapfrog
+//           in halo + own-satellite potential and torn into leading/trailing tidal tails.
+// Colour:   every star is a blackbody. Disc: old stars 3.4–6.2 kK, young stars born at the arm
+//           crest that fade downstream, H-alpha knots at the crest, rotation Doppler. Streams: the
+//           observed temperature is Doppler-shifted, T_obs = T (1 + beta).
+// Mouse (pointerMode):
+//   subhalo      — a dark-matter clump: a softened point mass in the integration (sweeps carve
+//                  stream gaps, fling dwarfs) + point-lens optics (Einstein ring behind the cursor).
+//   blackHole    — a spinning black hole: weaker pull plus Lense–Thirring frame dragging (the
+//                  velocity rotates about the spin axis, applied as an exact rotation), stars near it
+//                  gravitationally redshifted and dimmed by sqrt(1 - rs/r), a lensed view and a
+//                  Doppler-beamed photon ring.
+//   spectroscope — an instrument, not a mass: a loupe that magnifies the sky under the cursor
+//                  (conformal-style map, x M at the centre, compressing into a rim) and multiplies
+//                  the Doppler shift inside it, so hidden velocity structure pops out.
+// Trails (trailMode): streak = long-exposure star trails, comet = history tails, echo = stardust
+//           afterglow. Stream stars use the shared CPU trails; disc stars trail analytically by
+//           evaluating their orbit at earlier times, so arcs are exact.
+//
+// Generated from the approved lab module (particle lab, round 3). Sim units = object-local / size.
+/** mulberry32 — seeded PRNG, returns a function giving floats in [0,1). */
+function mulberry32(seed) {
+    let a = seed >>> 0;
+    return function () {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Standard normal from a uniform PRNG (Box–Muller, one value per call). */
+function gauss(rng) {
+    const u = Math.max(rng(), 1e-9);
+    const v = rng();
+    return Math.sqrt(-2 * Math.log(u)) * Math.cos(6.283185307 * v);
+}
+/** Soft sprite: gaussian core + wide halo, alpha-discarded at the rim. */
+const SPRITE_GLSL = /* glsl */ `
+float spriteAlpha(vec2 pc) {
+  vec2 d = pc * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) return 0.0;
+  float core = exp(-r2 * 9.0);
+  float halo = exp(-r2 * 3.2) * 0.35;
+  return (core + halo) * (1.0 - r2);
+}
+`;
+/** Viewport-height hook so point sizes are pixel-correct at any canvas size. */
+function attachViewH(obj, u) {
+    const scratch = new THREE.Vector2();
+    obj.onBeforeRender = (renderer) => {
+        renderer.getDrawingBufferSize(scratch);
+        u.uViewH.value = scratch.y;
+    };
+}
+function colorUniform(hex) {
+    return { value: new THREE.Color(hex) };
+}
+/** Tanner Helland blackbody fit, t in kelvin -> linear-ish RGB. */
+const BLACKBODY_GLSL = /* glsl */ `
+vec3 blackbody(float tK) {
+  float t = clamp(tK, 1000.0, 40000.0) / 100.0;
+  float r = t <= 66.0 ? 1.0 : clamp(1.29293618606 * pow(t - 60.0, -0.1332047592), 0.0, 1.0);
+  float g = t <= 66.0 ? clamp(0.39008157876 * log(t) - 0.63184144378, 0.0, 1.0)
+                      : clamp(1.12989086089 * pow(t - 60.0, -0.0755148492), 0.0, 1.0);
+  float b = t >= 66.0 ? 1.0 : (t <= 19.0 ? 0.0 : clamp(0.54320678911 * log(t - 10.0) - 1.19625408914, 0.0, 1.0));
+  return pow(vec3(r, g, b), vec3(2.2));
+}
+`;
+const POINTER_MODES = ['subhalo', 'blackHole', 'spectroscope'];
+const RC = 0.12; // halo core radius (v0 = 1)
+const Q = 0.9; // vertical flattening of the halo
+const PLUMMER_B = 0.03; // dwarf scale radius
+const H_MAX = 0.008; // largest runtime leapfrog step
+const H_WARM = 0.016; // pre-warm step (dwarf crossing time ~1.3 -> >80 steps per internal orbit)
+const TIME_SCALE = 0.15; // sim time per second: a stream orbit takes ~40 s, the inner disc ~13 s
+const PATTERN_SPEED = 1.1; // density-wave pattern speed (corotation just outside the disc)
+const PITCH = 0.32; // tan(pitch angle) of the log spirals (~18 deg)
+const WAVE_EPS = 0.07; // epicyclic amplitude of the density wave
+const PERTURBER_MASS = 0.12;
+const HOLE_MASS = 0.07;
+const HOLE_SPIN = 0.018; // Lense–Thirring J (sim units) at strength 1
+const DISC_TRAIL_SHARE = 0.35; // disc stars trail at this fraction of trailShare
+// orbit families: [apocentre radius, inclination, node angle, eccentricity offset, mass factor]
+const ORBITS = [
+    [1.05, 0.28, 0.0, 0.0, 1.0], // main dwarf: long arcs
+    [1.15, 1.05, 2.1, 0.42, 0.7], // near-radial: shells / umbrella
+    [0.85, 1.35, 4.0, -0.35, 0.8], // near-circular, polar ring
+];
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSimT: { value: 0 },
+        uSize: { value: 1 },
+        uViewH: { value: 800 },
+        uIntensity: { value: 1 },
+        uSpeed: { value: 1 },
+        uOpacity: { value: 0.9 },
+        uColor: colorUniform('#ffffff'),
+        uParticleCount: { value: 0 },
+        uSatelliteCount: { value: 2 },
+        uSatelliteMass: { value: 0.0005 },
+        uOrbitEccentricity: { value: 0.5 },
+        uStreamAge: { value: 2.2 },
+        uDopplerScale: { value: 2 },
+        uRedshiftColor: colorUniform('#ffffff'),
+        uDiscStars: { value: 0 },
+        uArmCount: { value: 2 },
+        uNebulaColor: colorUniform('#ffffff'),
+        uStarSize: { value: 1 },
+        uPointerMode: { value: 0 },
+        uPointerStrength: { value: 1 },
+        uPointerRadius: { value: 1 },
+        uPointerColor: colorUniform('#ffffff'),
+        ...createPointerUniforms(),
+        ...createTrailUniforms(),
+    };
+}
+function applyConfig(u, c, size) {
+    u.uSize.value = size;
+    u.uIntensity.value = c.intensity;
+    u.uSpeed.value = c.speed;
+    u.uOpacity.value = c.opacity;
+    u.uColor.value.set(c.color);
+    u.uParticleCount.value = c.particleCount;
+    u.uSatelliteCount.value = c.satelliteCount;
+    u.uSatelliteMass.value = c.satelliteMass;
+    u.uOrbitEccentricity.value = c.orbitEccentricity;
+    u.uStreamAge.value = c.streamAge;
+    u.uDopplerScale.value = c.dopplerScale;
+    u.uRedshiftColor.value.set(c.redshiftColor);
+    u.uDiscStars.value = c.discStars;
+    u.uArmCount.value = c.armCount;
+    u.uNebulaColor.value.set(c.nebulaColor);
+    u.uStarSize.value = c.starSize;
+    u.uPointerMode.value = POINTER_MODES.indexOf(c.pointerMode); // -1 = 'none' (off)
+    u.uPointerStrength.value = c.pointerStrength;
+    u.uPointerRadius.value = c.pointerRadius;
+    u.uPointerColor.value.set(c.pointerColor);
+    applyTrailConfig(u, c);
+}
+// Cursor optics, shared by every material (needs uSize declared by the including shader).
+const POINTER_GLSL = /* glsl */ `
+uniform vec3 uPointer, uPointerColor;
+uniform float uPointerActive, uPointerStrength, uPointerRadius, uPointerMode;
+float pointerOn() { return uPointerActive * step(0.001, uPointerStrength); }
+vec3 pointerViewPos() { return (viewMatrix * modelMatrix * vec4(uPointer * uSize, 1.0)).xyz; }
+// 1 inside the spectroscope loupe (angular), 0 outside or in other modes
+float loupeWeight(vec3 mv) {
+  if (uPointerMode < 1.5) return 0.0;
+  vec3 pv = pointerViewPos();
+  float R = 0.16 * uPointerRadius;
+  float b = length(mv.xy / -mv.z - pv.xy / -pv.z);
+  return pointerOn() * (1.0 - smoothstep(R * 0.8, R, b));
+}
+// gravitational redshift / dimming near the black hole: sqrt(1 - rs / r)
+float horizonFactor(vec3 pSim) {
+  if (uPointerMode < 0.5 || uPointerMode > 1.5) return 1.0;
+  float rs = 0.05 * uPointerRadius * uPointerStrength * uPointerActive;
+  return sqrt(clamp(1.0 - rs / max(length(pSim - uPointer), 1e-4), 0.0, 1.0));
+}
+// View-space warp of a source: point-lens major image (subhalo, black hole) or loupe (spectroscope)
+vec3 pointerView(vec3 mv, out float mag) {
+  mag = 1.0;
+  float act = pointerOn();
+  if (act < 0.001) return mv;
+  vec3 pv = pointerViewPos();
+  float Dl = -pv.z, Ds = -mv.z;
+  if (Dl <= 0.0) return mv;
+  vec2 c = pv.xy / Dl;
+  vec2 th = mv.xy / Ds - c;
+  float b = length(th);
+  vec2 dir = b > 1e-6 ? th / b : vec2(1.0, 0.0);
+  if (uPointerMode > 1.5) {
+    float R = 0.16 * uPointerRadius;
+    if (b >= R) return mv;
+    float M = 1.0 + 1.3 * min(uPointerStrength, 2.5) * act;
+    float x = b / R;
+    float bp = R * (M * x) / (1.0 + (M - 1.0) * x);  // slope M at the centre, rim fixed
+    mag = 1.0 + 0.25 * (M - 1.0);
+    return vec3((c + dir * bp) * Ds, mv.z);
+  }
+  if (Ds <= Dl) return mv;                               // only sources behind the lens
+  float thetaE = (uPointerMode > 0.5 ? 0.06 : 0.085) * uPointerRadius * sqrt(max(uPointerStrength, 0.0)) * act;
+  thetaE *= sqrt(clamp((Ds - Dl) / Ds * 6.0, 0.0, 1.0));
+  float bp = 0.5 * (b + sqrt(b * b + 4.0 * thetaE * thetaE));
+  float uu = b / max(thetaE, 1e-6);
+  mag = clamp((uu * uu + 2.0) / (max(uu, 1e-3) * sqrt(uu * uu + 4.0)), 1.0, 5.0);
+  return vec3((c + dir * bp) * Ds, mv.z);
+}
+`;
+const streamVertex = /* glsl */ `
+uniform float uSize, uViewH, uIntensity, uOpacity, uDopplerScale, uStarSize;
+uniform vec3 uColor, uRedshiftColor;
+attribute vec3 aVel;
+attribute vec2 aSeed; // x: luminosity seed, y: temperature seed
+varying vec3 vCol;
+varying float vA;
+varying float vSoft;
+${BLACKBODY_GLSL}
+${POINTER_GLSL}
+void main() {
+  vec4 wp = modelMatrix * vec4(position * uSize, 1.0);
+  vec3 mv0 = (viewMatrix * wp).xyz;
+  vec3 toCam = normalize(cameraPosition - wp.xyz);
+  float vr = dot(mat3(modelMatrix) * aVel, toCam);      // + approaching
+  float boost = 1.0 + 3.0 * loupeWeight(mv0);             // spectroscope exaggerates Doppler
+  float beta = clamp(vr * uDopplerScale * 0.35 * boost, -0.75, 0.75);
+  float hz = horizonFactor(position);
+  float T = mix(3600.0, 7800.0, aSeed.y);
+  vec3 col = blackbody(T * (1.0 + beta) * hz);
+  float s = clamp(beta / 0.7, -1.0, 1.0);
+  col *= s > 0.0 ? mix(vec3(1.0), uColor * 1.4, s) : mix(vec3(1.0), uRedshiftColor * 1.4, -s);
+  float lum = (0.3 + 2.2 * pow(aSeed.x, 9.0)) * hz * hz;
+  float mag;
+  vec3 mv = pointerView(mv0, mag);
+  vCol = col * lum * uIntensity * mag;
+  vA = uOpacity;
+  vSoft = 0.0;
+  gl_PointSize = clamp(uStarSize * uSize * uViewH * 0.0095 * (0.7 + 1.0 * pow(aSeed.x, 5.0)) * sqrt(mag) / -mv.z, 1.0, 48.0);
+  gl_Position = projectionMatrix * vec4(mv, 1.0);
+}
+`;
+// Disc star at time t (analytic): position, blackbody colour, luminosity, softness, velocity.
+const DISC_GLSL = /* glsl */ `
+uniform float uArmCount;
+uniform vec3 uNebulaColor;
+attribute vec4 aOrb; // R0, theta0, height, luminosity seed
+attribute vec4 aPop; // population (0 old, 1 young, 2 nebula, 3 bulge), temperature seed, arm offset, size seed
+void discStar(float t, out vec3 p, out vec3 col, out float lum, out float soft, out vec3 vel) {
+  float pop = aPop.x;
+  float R0 = aOrb.x;
+  float vc = R0 / sqrt(R0 * R0 + ${(RC * RC).toFixed(4)});
+  float om = vc / max(R0, 1e-3);
+  float bulge = step(2.5, pop);
+  om *= mix(1.0, 0.35, bulge);
+  float th = aOrb.y + om * t;
+  float psi = uArmCount * (th - ${PATTERN_SPEED.toFixed(3)} * t) + log(max(R0, 0.02)) / ${PITCH.toFixed(3)};
+  float R = R0 * (1.0 + (1.0 - bulge) * ${WAVE_EPS.toFixed(3)} * cos(psi));
+  if (bulge > 0.5) {
+    float c = cos(om * t), s = sin(om * t);
+    vec3 q = vec3(R0 * cos(aOrb.y), aOrb.z, R0 * sin(aOrb.y));
+    p = vec3(c * q.x - s * q.z, q.y, s * q.x + c * q.z);
+  } else {
+    p = vec3(R * cos(th), aOrb.z, R * sin(th));
+  }
+  vel = (1.0 - bulge) * vc * vec3(-sin(th), 0.0, cos(th));
+  float since = fract((psi - aPop.z) / 6.2831853);
+  lum = 0.25 + 1.6 * pow(aOrb.w, 8.0);
+  soft = 0.0;
+  if (pop < 0.5) {
+    col = blackbody(mix(3400.0, 6200.0, aPop.y));
+  } else if (pop < 1.5) {
+    col = blackbody(mix(12000.0, 26000.0, aPop.y));
+    lum = (0.5 + 2.5 * pow(aOrb.w, 6.0)) * 2.2 * exp(-3.5 * since);
+  } else if (pop < 2.5) {
+    lum = 1.3 * exp(-14.0 * since);
+    col = uNebulaColor;
+    soft = 1.0;
+  } else {
+    col = blackbody(mix(3200.0, 5200.0, aPop.y));
+    lum *= 1.2;
+  }
+}
+`;
+const discVertex = /* glsl */ `
+uniform float uSize, uViewH, uIntensity, uOpacity, uDopplerScale, uStarSize, uSimT, uDiscStars;
+uniform vec3 uColor, uRedshiftColor;
+varying vec3 vCol;
+varying float vA;
+varying float vSoft;
+${BLACKBODY_GLSL}
+${POINTER_GLSL}
+${DISC_GLSL}
+void main() {
+  vec3 p, col, vel; float lum, soft;
+  discStar(uSimT, p, col, lum, soft, vel);
+  vec4 wp = modelMatrix * vec4(p * uSize, 1.0);
+  vec3 mv0 = (viewMatrix * wp).xyz;
+  float vr = dot(mat3(modelMatrix) * vel, normalize(cameraPosition - wp.xyz));
+  float sgn = clamp(vr * uDopplerScale * 0.25 * (1.0 + 3.0 * loupeWeight(mv0)), -1.0, 1.0);
+  col *= sgn > 0.0 ? mix(vec3(1.0), uColor * 1.3, sgn * 0.6) : mix(vec3(1.0), uRedshiftColor * 1.3, -sgn * 0.6);
+  float hz = horizonFactor(p);
+  float mag;
+  vec3 mv = pointerView(mv0, mag);
+  float crowd = clamp(70000.0 / max(uDiscStars, 1.0), 0.4, 3.0);
+  vSoft = soft;
+  vCol = col * lum * uIntensity * mag * hz * hz;
+  vA = uOpacity * mix(0.55, 0.22, soft) * crowd;
+  float px = mix(0.0075 * (0.7 + 0.8 * aPop.w), 0.05, soft);
+  gl_PointSize = clamp(uStarSize * uSize * uViewH * px * sqrt(mag) / -mv.z, 1.0, 64.0);
+  gl_Position = projectionMatrix * vec4(mv, 1.0);
+}
+`;
+// Analytic disc trails: the same orbit evaluated at earlier times (template x = sample fraction).
+function discTrailVertex(mode) {
+    const profile = {
+        streak: 'float tau = f * uTrailLength * uVelScale * 1.2; float fade = pow(1.0 - f, 1.2) * 0.8;',
+        comet: 'float tau = f * uTrailLength * uVelScale * 3.0; float fade = pow(1.0 - f, 1.8) * 0.5;',
+        echo: 'float tau = f * uTrailLength * uVelScale * 2.5; float fade = pow(1.0 - f, 2.0) * 0.8;',
+    }[mode];
+    return /* glsl */ `
+uniform float uSize, uViewH, uIntensity, uOpacity, uStarSize, uSimT, uDiscStars;
+uniform float uTrailLength, uTrailOpacity, uVelScale;
+uniform vec3 uTrailColor;
+varying vec3 vCol;
+varying float vA;
+varying float vSoft;
+${BLACKBODY_GLSL}
+${POINTER_GLSL}
+${DISC_GLSL}
+void main() {
+  float f = position.x;
+  ${profile}
+  vec3 p, col, vel; float lum, soft;
+  discStar(uSimT - tau, p, col, lum, soft, vel);
+  float mag;
+  vec3 mv = pointerView((modelViewMatrix * vec4(p * uSize, 1.0)).xyz, mag);
+  vSoft = ${mode === 'echo' ? '0.6' : '0.0'};
+  vCol = col * mix(vec3(1.0), uTrailColor * 1.3, smoothstep(0.0, 0.8, f)) * lum * uIntensity * mag * horizonFactor(p);
+  vA = uOpacity * uTrailOpacity * fade * (1.0 - soft) * step(0.001, f);
+  gl_PointSize = clamp(uStarSize * uSize * uViewH * 0.006 * ${mode === 'echo' ? '(1.0 + 1.5 * f)' : '(1.0 - 0.5 * f)'} / -mv.z, 1.0, 32.0);
+  gl_Position = projectionMatrix * vec4(mv, 1.0);
+}
+`;
+}
+const fragment = /* glsl */ `
+varying vec3 vCol;
+varying float vA;
+varying float vSoft;
+${SPRITE_GLSL}
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  float soft = exp(-r2 * 2.5) * (1.0 - r2);
+  float a = mix(spriteAlpha(gl_PointCoord), soft, vSoft) * vA;
+  if (a < 0.003 || r2 > 1.0) discard;
+  gl_FragColor = vec4(vCol, a);
+}
+`;
+// The cursor made visible: faint Einstein ring (subhalo), Doppler-beamed photon ring (black hole),
+// reticle (spectroscope). Sized from the same angular radii the optics use.
+const glyphVertex = /* glsl */ `
+uniform float uSize, uViewH, uTime;
+varying float vMode;
+${POINTER_GLSL}
+void main() {
+  vec4 mv = modelViewMatrix * vec4(uPointer * uSize, 1.0);
+  float ang = uPointerMode > 1.5 ? 0.16 * uPointerRadius
+            : (uPointerMode > 0.5 ? 0.06 : 0.085) * uPointerRadius * sqrt(max(uPointerStrength, 0.0)) * 0.55;
+  float px = ang * projectionMatrix[1][1] * uViewH * 0.5;   // angular radius -> pixels
+  gl_PointSize = clamp(px * 2.0 * 1.35, 0.0, 900.0) * step(0.02, pointerOn());
+  vMode = uPointerMode;
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const glyphFragment = /* glsl */ `
+uniform float uTime, uOpacity;
+uniform vec3 uPointerColor;
+uniform float uPointerActive, uPointerStrength;
+varying float vMode;
+void main() {
+  vec2 d = (gl_PointCoord * 2.0 - 1.0) * vec2(1.0, -1.0) * 1.35;
+  float r = length(d);
+  float a = 0.0;
+  vec3 col = uPointerColor;
+  if (vMode < 0.5) {
+    a = 0.12 * exp(-pow((r - 1.0) / 0.05, 2.0));                    // faint Einstein ring
+  } else if (vMode < 1.5) {
+    // photon ring at ~1.0 plus a dim inner glow; the approaching side is Doppler-beamed
+    float ang = atan(d.y, d.x) + uTime * 1.2;
+    float beam = 0.55 + 0.45 * cos(ang);
+    a = (exp(-pow((r - 0.62) / 0.035, 2.0)) * (0.35 + 0.9 * beam * beam) + 0.12 * exp(-pow((r - 0.62) / 0.18, 2.0)));
+    col = mix(uPointerColor, vec3(1.0, 0.95, 0.9), 0.3 * beam);
+  } else {
+    float ring = exp(-pow((r - 1.0) / 0.012, 2.0));
+    float ticks = step(0.985, cos(atan(d.y, d.x) * 12.0)) * smoothstep(0.93, 0.97, r) * (1.0 - smoothstep(1.0, 1.04, r));
+    float cross = (1.0 - smoothstep(0.004, 0.012, abs(d.x))) * step(0.08, abs(d.y)) * step(abs(d.y), 0.18)
+                + (1.0 - smoothstep(0.004, 0.012, abs(d.y))) * step(0.08, abs(d.x)) * step(abs(d.x), 0.18);
+    a = 0.45 * ring + 0.5 * ticks + 0.35 * cross;
+  }
+  a *= uPointerActive * uOpacity * min(uPointerStrength, 1.0);
+  if (a < 0.003 || r > 1.3) discard;
+  gl_FragColor = vec4(col, a);
+}
+`;
+/** Halo acceleration (flattened cored log potential, v0 = 1). */
+function hostAccel(x, y, z, out) {
+    const r2 = x * x + z * z + (y * y) / (Q * Q) + RC * RC;
+    out[0] = -x / r2;
+    out[1] = -y / (Q * Q * r2);
+    out[2] = -z / r2;
+}
+function build(u, c, size) {
+    const n = Math.max(1, Math.round(c.particleCount));
+    const ns = Math.min(3, Math.max(1, Math.round(c.satelliteCount)));
+    const rng = mulberry32(0x7d15a1);
+    // ---- satellites ----
+    const sat = new Float64Array(ns * 6);
+    const satMass = new Float64Array(ns);
+    for (let k = 0; k < ns; k++) {
+        const [ra, inc, node, eOff, mf] = ORBITS[k];
+        const e = Math.min(Math.max(c.orbitEccentricity + eOff, 0.02), 0.92);
+        const vc = ra / Math.sqrt(ra * ra + RC * RC);
+        const vt = vc * (1 - 0.66 * e);
+        const ci = Math.cos(inc), si = Math.sin(inc), cn = Math.cos(node), sn = Math.sin(node);
+        const vy = vt * si, vz = -vt * ci;
+        sat[k * 6] = cn * ra;
+        sat[k * 6 + 1] = 0;
+        sat[k * 6 + 2] = -sn * ra;
+        sat[k * 6 + 3] = sn * vz;
+        sat[k * 6 + 4] = vy;
+        sat[k * 6 + 5] = cn * vz;
+        satMass[k] = mf;
+    }
+    // ---- stream stars: Plummer spheres around their dwarf ----
+    const pos = new Float32Array(n * 3);
+    const vel = new Float32Array(n * 3);
+    const seed = new Float32Array(n * 2);
+    const owner = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+        const k = i % ns;
+        owner[i] = k;
+        const m = u.uSatelliteMass.value * satMass[k];
+        const sigma = Math.sqrt(m / (6 * PLUMMER_B)) * 0.85;
+        let r;
+        do {
+            r = PLUMMER_B / Math.sqrt(Math.pow(Math.max(rng(), 1e-6), -2 / 3) - 1);
+        } while (r > 4 * PLUMMER_B);
+        const ct = 2 * rng() - 1, ph = 6.283185307 * rng(), st = Math.sqrt(1 - ct * ct);
+        pos[i * 3] = sat[k * 6] + r * st * Math.cos(ph);
+        pos[i * 3 + 1] = sat[k * 6 + 1] + r * ct;
+        pos[i * 3 + 2] = sat[k * 6 + 2] + r * st * Math.sin(ph);
+        vel[i * 3] = sat[k * 6 + 3] + sigma * gauss(rng);
+        vel[i * 3 + 1] = sat[k * 6 + 4] + sigma * gauss(rng);
+        vel[i * 3 + 2] = sat[k * 6 + 5] + sigma * gauss(rng);
+        seed[i * 2] = rng();
+        seed[i * 2 + 1] = rng();
+    }
+    const a = new Float64Array(3);
+    const sPrev = new Float64Array(ns * 3);
+    // Frame dragging as an exact rotation of v about the spin axis by angle 2 |Omega| dt, with
+    // Omega = J / (r^2 + eps^2)^(3/2) (gravitomagnetic field of a spinning mass, softened).
+    const rot = (j, ax, ay, az, ang, arr) => {
+        const vx = arr[j], vy = arr[j + 1], vz = arr[j + 2];
+        const cs = Math.cos(ang), sn = Math.sin(ang), dot = ax * vx + ay * vy + az * vz;
+        arr[j] = vx * cs + (ay * vz - az * vy) * sn + ax * dot * (1 - cs);
+        arr[j + 1] = vy * cs + (az * vx - ax * vz) * sn + ay * dot * (1 - cs);
+        arr[j + 2] = vz * cs + (ax * vy - ay * vx) * sn + az * dot * (1 - cs);
+    };
+    const sv = new Float64Array(3);
+    // P: pointer (sim units), mp: mass, ep2: softening^2, J: spin, (sx,sy,sz): spin axis
+    function step(h, mp, ep2, P, J, spin) {
+        const hh = h * 0.5;
+        const baseM = u.uSatelliteMass.value;
+        const usePtr = mp > 1e-6;
+        const useSpin = J > 1e-7;
+        const px = P.x, py = P.y, pz = P.z;
+        for (let k = 0; k < ns; k++) {
+            const o = k * 6;
+            sPrev[k * 3] = sat[o];
+            sPrev[k * 3 + 1] = sat[o + 1];
+            sPrev[k * 3 + 2] = sat[o + 2];
+            for (let half = 0; half < 2; half++) {
+                hostAccel(sat[o], sat[o + 1], sat[o + 2], a);
+                if (usePtr) {
+                    const dx = sat[o] - px, dy = sat[o + 1] - py, dz = sat[o + 2] - pz;
+                    const d2 = dx * dx + dy * dy + dz * dz + ep2, f = mp / (d2 * Math.sqrt(d2));
+                    a[0] -= dx * f;
+                    a[1] -= dy * f;
+                    a[2] -= dz * f;
+                }
+                sat[o + 3] += a[0] * hh;
+                sat[o + 4] += a[1] * hh;
+                sat[o + 5] += a[2] * hh;
+                if (half === 0) {
+                    sat[o] += sat[o + 3] * h;
+                    sat[o + 1] += sat[o + 4] * h;
+                    sat[o + 2] += sat[o + 5] * h;
+                }
+            }
+        }
+        const b2 = PLUMMER_B * PLUMMER_B;
+        for (let i = 0, j = 0; i < n; i++, j += 3) {
+            const k = owner[i];
+            const m = baseM * satMass[k];
+            let x = pos[j], y = pos[j + 1], z = pos[j + 2];
+            for (let half = 0; half < 2; half++) {
+                const sx = half === 0 ? sPrev[k * 3] : sat[k * 6];
+                const sy = half === 0 ? sPrev[k * 3 + 1] : sat[k * 6 + 1];
+                const sz = half === 0 ? sPrev[k * 3 + 2] : sat[k * 6 + 2];
+                const r2 = x * x + z * z + (y * y) / (Q * Q) + RC * RC;
+                let ax = -x / r2, ay = -y / (Q * Q * r2), az = -z / r2;
+                let dx = x - sx, dy = y - sy, dz = z - sz;
+                let d2 = dx * dx + dy * dy + dz * dz + b2, f = m / (d2 * Math.sqrt(d2));
+                ax -= dx * f;
+                ay -= dy * f;
+                az -= dz * f;
+                if (usePtr) {
+                    dx = x - px;
+                    dy = y - py;
+                    dz = z - pz;
+                    d2 = dx * dx + dy * dy + dz * dz + ep2;
+                    f = mp / (d2 * Math.sqrt(d2));
+                    ax -= dx * f;
+                    ay -= dy * f;
+                    az -= dz * f;
+                    if (useSpin) {
+                        const ang = Math.min((2 * J * hh) / (d2 * Math.sqrt(d2)), 0.5);
+                        if (ang > 2e-5)
+                            rot(j, spin[0], spin[1], spin[2], ang, vel); // negligible far away
+                    }
+                }
+                vel[j] += ax * hh;
+                vel[j + 1] += ay * hh;
+                vel[j + 2] += az * hh;
+                if (half === 0) {
+                    x += vel[j] * h;
+                    y += vel[j + 1] * h;
+                    z += vel[j + 2] * h;
+                }
+            }
+            pos[j] = x;
+            pos[j + 1] = y;
+            pos[j + 2] = z;
+        }
+    }
+    const P0 = new THREE.Vector3();
+    const warmT = Math.max(0, c.streamAge) * 6.2832;
+    const warmSteps = Math.ceil(warmT / H_WARM);
+    for (let s = 0; s < warmSteps; s++)
+        step(warmT / warmSteps, 0, 1, P0, 0, sv);
+    let simT = warmT;
+    u.uSimT.value = simT;
+    // ---- stream points ----
+    const geo = new THREE.BufferGeometry();
+    const posAttr = new THREE.BufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+    const velAttr = new THREE.BufferAttribute(vel, 3).setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('position', posAttr);
+    geo.setAttribute('aVel', velAttr);
+    geo.setAttribute('aSeed', new THREE.BufferAttribute(seed, 2));
+    const mat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: streamVertex, fragmentShader: fragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const streams = new THREE.Points(geo, mat);
+    streams.frustumCulled = false;
+    attachViewH(streams, u);
+    // ---- host galaxy (analytic) ----
+    const nd = Math.max(0, Math.round(c.discStars));
+    const drng = mulberry32(0x9a1a);
+    const orb = new Float32Array(Math.max(nd, 1) * 4);
+    const popA = new Float32Array(Math.max(nd, 1) * 4);
+    for (let i = 0; i < nd; i++) {
+        const t = drng();
+        let pop, R, z;
+        if (t < 0.16) {
+            pop = 3; // Hernquist bulge, a = 0.06, sampled by its cumulative mass
+            const m = drng() * 0.96;
+            let r = (0.06 * Math.sqrt(m)) / (1 - Math.sqrt(m));
+            r = Math.min(r, 0.35);
+            z = (drng() * 2 - 1) * r * 0.75;
+            R = Math.sqrt(Math.max(r * r - z * z, 0));
+        }
+        else {
+            pop = t < 0.6 ? 0 : t < 0.97 ? 1 : 2;
+            do {
+                R = -0.18 * Math.log(Math.max(drng() * drng(), 1e-9));
+            } while (R > 0.8);
+            R = Math.max(R, 0.03);
+            const hz = pop === 0 ? 0.022 : 0.008;
+            z = hz * Math.log(Math.max(drng(), 1e-6)) * (drng() < 0.5 ? -1 : 1) * 0.5;
+        }
+        orb[i * 4] = R;
+        orb[i * 4 + 1] = drng() * 6.2831853;
+        orb[i * 4 + 2] = z;
+        orb[i * 4 + 3] = drng();
+        popA[i * 4] = pop;
+        popA[i * 4 + 1] = drng();
+        popA[i * 4 + 2] = (drng() - 0.5) * 0.8;
+        popA[i * 4 + 3] = drng();
+    }
+    const dgeo = new THREE.BufferGeometry();
+    dgeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(Math.max(nd, 1) * 3), 3));
+    dgeo.setAttribute('aOrb', new THREE.BufferAttribute(orb, 4));
+    dgeo.setAttribute('aPop', new THREE.BufferAttribute(popA, 4));
+    dgeo.setDrawRange(0, nd);
+    const dmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: discVertex, fragmentShader: fragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const disc = new THREE.Points(dgeo, dmat);
+    disc.frustumCulled = false;
+    // ---- cursor glyph ----
+    const ggeo = new THREE.BufferGeometry();
+    ggeo.setAttribute('position', new THREE.BufferAttribute(new Float32Array(3), 3));
+    const gmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: glyphVertex, fragmentShader: glyphFragment,
+        transparent: true, depthWrite: false, depthTest: false, blending: THREE.AdditiveBlending,
+    });
+    const glyph = new THREE.Points(ggeo, gmat);
+    glyph.frustumCulled = false;
+    glyph.renderOrder = 10;
+    const object = new THREE.Group();
+    object.add(disc, streams, glyph);
+    // ---- trails (rebuilt only when trailMode / trailShare change) ----
+    const trailGLSL = /* glsl */ `
+${POINTER_GLSL}
+vec3 trailShade(vec3 p, float f) { float hz = horizonFactor(p); return vec3(1.0, 0.95, 0.9) * 0.9 * hz * hz; }
+vec3 trailView(vec3 mv, out float mag) { return pointerView(mv, mag); }
+`;
+    let trail = null, discTrail = null, discTrailMat = null, discTrailGeo = null;
+    let trailKey = '';
+    const materials = [mat, dmat, gmat];
+    function buildTrails(mode, share) {
+        const key = mode + ':' + share;
+        if (key === trailKey)
+            return;
+        trailKey = key;
+        if (trail) {
+            object.remove(trail.object);
+            trail.dispose();
+            trail = null;
+        }
+        if (discTrail) {
+            object.remove(discTrail);
+            discTrailGeo.dispose();
+            discTrailMat.dispose();
+            discTrail = null;
+        }
+        materials.length = 3;
+        if (mode === 'none')
+            return;
+        trail = createCpuTrail(mode, { u, n, pos, vel, glsl: trailGLSL, sizePx: 0.0065, spacing: 0.0035 });
+        if (!trail)
+            return;
+        object.add(trail.object);
+        materials.push(...trail.materials);
+        if (nd > 0) {
+            const S = mode === 'echo' ? 6 : mode === 'comet' ? 24 : 16;
+            discTrailGeo = new THREE.InstancedBufferGeometry();
+            const tpl = new Float32Array(S * 3);
+            for (let i = 0; i < S; i++)
+                tpl[i * 3] = i / (S - 1);
+            discTrailGeo.setAttribute('position', new THREE.BufferAttribute(tpl, 3));
+            discTrailGeo.setAttribute('aOrb', new THREE.InstancedBufferAttribute(orb, 4));
+            discTrailGeo.setAttribute('aPop', new THREE.InstancedBufferAttribute(popA, 4));
+            discTrailGeo.instanceCount = Math.max(1, Math.round(nd * Math.min(share, 1) * DISC_TRAIL_SHARE));
+            discTrailMat = new THREE.ShaderMaterial({
+                uniforms: u, vertexShader: discTrailVertex(mode), fragmentShader: fragment,
+                transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+            });
+            discTrail = new THREE.Points(discTrailGeo, discTrailMat);
+            discTrail.frustumCulled = false;
+            object.add(discTrail);
+            materials.push(discTrailMat);
+        }
+    }
+    buildTrails(c.trailMode, c.trailShare);
+    const P = new THREE.Vector3();
+    const spinAxis = new THREE.Vector3();
+    const invQ = new THREE.Quaternion();
+    return {
+        object,
+        materials,
+        apply(cfg) { if (cfg)
+            buildTrails(cfg.trailMode, cfg.trailShare); },
+        update(dt, camera, pointer) {
+            const rdt = Math.min(Math.max(dt, 0), 1 / 20);
+            const d = rdt * u.uSpeed.value;
+            u.uTime.value += d;
+            u.uVelScale.value = TIME_SCALE * u.uSpeed.value;
+            if (pointer && camera)
+                stepPointerField(u, pointer, camera, object, u.uSize.value, rdt);
+            const T = d * TIME_SCALE;
+            if (T > 0) {
+                const mode = u.uPointerMode.value;
+                const act = u.uPointerActive.value * u.uPointerStrength.value;
+                const mp = mode === 0 ? PERTURBER_MASS * act : mode === 1 ? HOLE_MASS * act : 0;
+                const J = mode === 1 ? HOLE_SPIN * act : 0;
+                const ep = (mode === 1 ? 0.035 : 0.05) * u.uPointerRadius.value;
+                if (J > 0 && camera) {
+                    // spin axis = view direction, expressed in the object's frame (swirl in the screen plane)
+                    camera.getWorldDirection(spinAxis);
+                    object.getWorldQuaternion(invQ).invert();
+                    spinAxis.applyQuaternion(invQ).normalize();
+                    sv[0] = spinAxis.x;
+                    sv[1] = spinAxis.y;
+                    sv[2] = spinAxis.z;
+                }
+                P.copy(u.uPointer.value);
+                const steps = Math.min(Math.ceil(T / H_MAX), 6);
+                for (let s = 0; s < steps; s++)
+                    step(T / steps, mp, ep * ep, P, J, sv);
+                simT += T;
+                u.uSimT.value = simT;
+            }
+            posAttr.needsUpdate = true;
+            velAttr.needsUpdate = true;
+            if (trail)
+                trail.update(d);
+        },
+        dispose() {
+            geo.dispose();
+            mat.dispose();
+            dgeo.dispose();
+            dmat.dispose();
+            ggeo.dispose();
+            gmat.dispose();
+            if (trail)
+                trail.dispose();
+            if (discTrail) {
+                discTrailGeo.dispose();
+                discTrailMat.dispose();
+            }
+        },
+        _state: { pos, vel, sat },
+    };
+}
+/** Defaults for every knob, so an older saved config still renders (identical to the catalog entry). */
+const DEFAULTS = {
+    intensity: 1,
+    speed: 1,
+    opacity: 0.9,
+    size: 1,
+    color: '#8cbcff',
+    particleCount: 18000,
+    satelliteCount: 2,
+    satelliteMass: 0.0005,
+    orbitEccentricity: 0.5,
+    streamAge: 2.2,
+    dopplerScale: 2,
+    redshiftColor: '#ffa070',
+    discStars: 70000,
+    armCount: 2,
+    nebulaColor: '#ff5c8a',
+    starSize: 1,
+    pointerMode: 'subhalo',
+    pointerStrength: 1,
+    pointerRadius: 1,
+    pointerColor: '#ffd29a',
+    trailMode: 'comet',
+    trailLength: 1.6,
+    trailOpacity: 0.55,
+    trailColor: '#7fa8ff',
+    trailShare: 0.25,
+};
+const TidalStreamParticles = ({ size, config, animations, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    const animCache = useRef({});
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const s = size > 0 ? size : 1;
+    const cfg = useMemo(() => ({ ...DEFAULTS, ...config }), [config]);
+    // uniforms outlive the objects, so keyframe animations survive a rebuild
+    const uniforms = useMemo(() => createUniforms(), []);
+    // rebuilt only when a structural knob changes (trails rebuild inside apply())
+    const instance = useMemo(() => build(uniforms, cfg, s), [uniforms, cfg.particleCount, cfg.satelliteCount, cfg.orbitEccentricity, cfg.streamAge, cfg.discStars]);
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => {
+        applyConfig(uniforms, cfg, s);
+        instance.apply(cfg);
+    }, [instance, uniforms, cfg, s]);
+    const pointer = usePointerField();
+    useFrame((state, delta) => {
+        instance.update(Math.min(delta, 0.1), state.camera, pointer);
+        if (animations?.length)
+            applyGenerativeAnimations(instance.materials, animations, animCache.current, Date.now(), false);
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default TidalStreamParticles;