@3driseai/3drise-viewer 0.1.17 → 0.1.18

package/dist/components/particles/ElectronOrbitalsParticles.js

@@ -0,0 +1,944 @@
+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';
+/**
+ * Quantum Orbitals — A hydrogen electron cloud as Bohmian trajectories: a superposition of two orbitals breathing at the Bohr frequency, coloured by quantum phase; the cursor is a photon, a magnet or a detector. Use for science and tech scenes.
+ */
+// Quantum Orbitals — an electron cloud in a hydrogen atom, as Bohmian trajectories.
+// Movement: the state is a superposition psi = cos(chi) psi_A + sin(chi) e^{i delta} psi_B of two
+//           hydrogen eigenstates psi_nlm = R_nl(r) Theta_lm(theta) e^{i m phi} e^{-i E_n t},
+//           E_n = -1/(2 n^2) (atomic units). Each particle follows the de Broglie–Bohm guidance law
+//           v = Im(grad psi / psi). Particles start distributed as |psi|^2 (exact rejection sampling)
+//           and equivariance keeps them so for all time: the cloud breathes and rotates at the Bohr
+//           frequency (E_A - E_B) while every particle circulates along its own current line.
+//           R_nl comes from associated Laguerre polynomials and Theta_lm from associated Legendre
+//           functions, tabulated once and normalised numerically.
+// Colour:   the phase of psi at the particle (arg psi) mapped round a two-colour cycle, brightness
+//           by density; a raymarched |psi|^2 haze shows the probability cloud the particles sample.
+// Mouse (pointerMode):
+//   photon  — a resonant light source: its field drives Rabi oscillations between the two states
+//             (faster the closer it is), so the cloud morphs A -> B -> A while it shines; released,
+//             the atom decays back by spontaneous emission and sheds photons.
+//   magnet  — a magnetic field pointing from the nucleus to the cursor: the Zeeman term makes the
+//             whole cloud precess about the field at the Larmor frequency (exact: a rotation).
+//   measure — a position detector: it clicks at a rate proportional to the probability inside its
+//             window (silent at nodes, busy in lobes); each click localises the ensemble into a
+//             packet at the detected point, which then re-spreads into the stationary cloud.
+// Trails (trailMode): streak = long exposure, comet = Bohm trajectories, echo = afterglow.
+//
+// Generated from the approved lab module (particle lab, batch 2). 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;
+    };
+}
+/** 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) };
+}
+/** Quality levels scale counts, raymarch samples and trail caps. Structural. */
+const QUALITY_SCALE = { low: 0.5, medium: 1, high: 1.6 };
+function qualityScale(q) { return QUALITY_SCALE[q] || 1; }
+/** Mix the object's own base seed with the `seed` knob into a mulberry32 seed. */
+function seedMix(base, seed) {
+    let h = (base ^ Math.imul((Math.round(seed) | 0) + 0x9e37, 0x85ebca6b)) >>> 0;
+    h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35) >>> 0;
+    return (h ^ (h >>> 16)) >>> 0;
+}
+/** Fixed-step clock: the same motion at 30, 60 or 144 Hz. `run(d, step)` advances d sim-seconds
+ *  in steps of exactly H (at most maxSteps per call; a longer backlog is dropped, not caught up). */
+function createFixedStep(H, maxSteps) {
+    let acc = 0;
+    return {
+        H,
+        run(d, step) {
+            acc += Math.max(d, 0);
+            let k = 0;
+            while (acc >= H && k < maxSteps) {
+                step(H);
+                acc -= H;
+                k++;
+            }
+            if (k === maxSteps)
+                acc = Math.min(acc, H);
+            return acc / H; // leftover fraction, for render interpolation
+        },
+        reset() { acc = 0; },
+    };
+}
+/** Selection bounds: an invisible sphere the editor can pick, frame and size (never rendered,
+ *  still raycastable and counted by Box3.setFromObject). */
+function createPickProxy(center, radius) {
+    const geo = new THREE.SphereGeometry(1, 16, 10);
+    const mat = new THREE.MeshBasicMaterial({ visible: false });
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.name = 'pickProxy';
+    mesh.position.set(center[0], center[1], center[2]);
+    mesh.scale.setScalar(radius);
+    return { mesh, dispose() { geo.dispose(); mat.dispose(); } };
+}
+const _frustum = new THREE.Frustum();
+const _pm = new THREE.Matrix4();
+const _sphere = new THREE.Sphere();
+/** Off-screen test: false when the object's bounding sphere is outside the camera frustum. */
+function inView(object, camera, center, radius, size) {
+    if (!camera || !camera.projectionMatrix)
+        return true;
+    object.updateWorldMatrix(true, false);
+    _sphere.center.set(center[0], center[1], center[2]).multiplyScalar(size).applyMatrix4(object.matrixWorld);
+    _sphere.radius = radius * size * object.matrixWorld.getMaxScaleOnAxis();
+    _pm.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+    _frustum.setFromProjectionMatrix(_pm);
+    return _frustum.intersectsSphere(_sphere);
+}
+const POINTER_MODES = ['photon', 'magnet', 'measure'];
+const STATES = ['1s', '2s', '2p0', '2p+1', '3s', '3p0', '3p+1', '3d0', '3d+1', '3d+2', '4s', '4p+1', '4d+1', '4d+2', '4f0', '4f+1', '4f+2', '4f+3'];
+const L_OF = { s: 0, p: 1, d: 2, f: 3 };
+const stateLabel = (k) => `${k.slice(0, 2)} (m = ${k.slice(2)})`;
+const stateOptions = () => Object.fromEntries(STATES.map((k) => [stateLabel(k), k]));
+const NR = 1024, NT = 512;
+const TS = 12; // atomic time units per second at timeScale 1
+const H_STEP = 1 / 45;
+const BOUNDS = { center: [0, 0, 0], radius: 1.2 };
+const MAX_PHOT = 24;
+function parseState(k) {
+    const n = +k[0], l = L_OF[k[1]], m = +(k.slice(2).replace('+', '')) || 0;
+    return { n, l, m: Math.abs(m) };
+}
+// Hydrogen radial function tables R(r), R'(r) on [0, rmax], normalised: int R^2 r^2 dr = 1.
+function radialTable(n, l, rmax) {
+    const R = new Float64Array(NR), dR = new Float64Array(NR);
+    const k = n - l - 1, alpha = 2 * l + 1;
+    for (let i = 0; i < NR; i++) {
+        const r = (i / (NR - 1)) * rmax;
+        const x = (2 * r) / n;
+        let L0 = 1, L1 = 1 + alpha - x, Lk = k === 0 ? 1 : L1;
+        for (let j = 1; j < k; j++) {
+            const L2 = ((2 * j + 1 + alpha - x) * L1 - (j + alpha) * L0) / (j + 1);
+            L0 = L1;
+            L1 = L2;
+            Lk = L2;
+        }
+        R[i] = Math.pow(x, l) * Math.exp(-x / 2) * Lk;
+    }
+    let norm = 0;
+    const dr = rmax / (NR - 1);
+    for (let i = 0; i < NR; i++) {
+        const r = i * dr;
+        norm += R[i] * R[i] * r * r * dr;
+    }
+    const s = 1 / Math.sqrt(norm);
+    for (let i = 0; i < NR; i++)
+        R[i] *= s;
+    for (let i = 0; i < NR; i++)
+        dR[i] = (R[Math.min(i + 1, NR - 1)] - R[Math.max(i - 1, 0)]) / (dr * (i === 0 || i === NR - 1 ? 1 : 2));
+    return { R, dR };
+}
+// Theta_lm(theta) ~ P_l^m(cos theta), normalised so int Theta^2 sin(theta) dtheta = 1 / (2 pi).
+function angularTable(l, m) {
+    const T = new Float64Array(NT), dT = new Float64Array(NT);
+    for (let i = 0; i < NT; i++) {
+        const th = (i / (NT - 1)) * Math.PI;
+        const x = Math.cos(th), sx = Math.sin(th);
+        let pmm = 1;
+        for (let j = 1; j <= m; j++)
+            pmm *= -(2 * j - 1) * sx;
+        let val;
+        if (l === m)
+            val = pmm;
+        else {
+            let pm1 = x * (2 * m + 1) * pmm;
+            if (l === m + 1)
+                val = pm1;
+            else {
+                let p0 = pmm;
+                for (let ll = m + 2; ll <= l; ll++) {
+                    const p2 = (x * (2 * ll - 1) * pm1 - (ll + m - 1) * p0) / (ll - m);
+                    p0 = pm1;
+                    pm1 = p2;
+                }
+                val = pm1;
+            }
+        }
+        T[i] = val;
+    }
+    let norm = 0;
+    const dth = Math.PI / (NT - 1);
+    for (let i = 0; i < NT; i++)
+        norm += T[i] * T[i] * Math.sin(i * dth) * dth;
+    const s = 1 / Math.sqrt(norm * 2 * Math.PI);
+    for (let i = 0; i < NT; i++)
+        T[i] *= s;
+    for (let i = 0; i < NT; i++)
+        dT[i] = (T[Math.min(i + 1, NT - 1)] - T[Math.max(i - 1, 0)]) / (dth * (i === 0 || i === NT - 1 ? 1 : 2));
+    return { T, dT };
+}
+function cdfSample(pdf, rng) {
+    const c = new Float64Array(pdf.length);
+    let acc = 0;
+    for (let i = 0; i < pdf.length; i++) {
+        acc += pdf[i];
+        c[i] = acc;
+    }
+    return () => {
+        const u = rng() * acc;
+        let lo = 0, hi = pdf.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (c[mid] < u)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        const prev = lo > 0 ? c[lo - 1] : 0;
+        return (lo + (u - prev) / Math.max(c[lo] - prev, 1e-30)) / (pdf.length - 1);
+    };
+}
+function createUniforms() {
+    return {
+        uTime: { value: 0 },
+        uSize: { value: 1 },
+        uViewH: { value: 800 },
+        uIntensity: { value: 1 },
+        uSpeed: { value: 1 },
+        uOpacity: { value: 0.9 },
+        uColor: colorUniform('#ffffff'),
+        uParticleCount: { value: 0 },
+        uMix: { value: 0.35 },
+        uTimeScale: { value: 1 },
+        uPhaseColor: colorUniform('#ffffff'),
+        uCloudDensity: { value: 0.6 },
+        uPhaseFronts: { value: 1 },
+        uPointSize: { value: 1 },
+        uPointerMode: { value: 0 },
+        uPointerStrength: { value: 1 },
+        uPointerRadius: { value: 1 },
+        uPointerColor: colorUniform('#ffffff'),
+        // wavefunction state for the haze (set by the simulation)
+        uTables: { value: null },
+        uRS: { value: 20 }, // Bohr radii per sim unit
+        uRMax: { value: 40 },
+        uAmp: { value: new THREE.Vector2(1, 0) }, // cos chi, sin chi
+        uM: { value: new THREE.Vector2(0, 0) }, // m_A, m_B
+        uPhA: { value: new THREE.Vector2(1, 0) }, // e^{-i E_A t}
+        uPhB: { value: new THREE.Vector2(1, 0) }, // e^{-i E_B t + i delta}
+        uFrameInv: { value: new THREE.Matrix3() }, // world -> body (magnet precession)
+        uCollapse: { value: new THREE.Vector4(0, 0, 0, 0) }, // detected point xyz, kappa
+        uCamLocal: { value: new THREE.Vector3(0, 0, 3) },
+        ...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.uMix.value = c.mix;
+    u.uTimeScale.value = c.timeScale;
+    u.uPhaseColor.value.set(c.phaseColor);
+    u.uCloudDensity.value = c.cloudDensity;
+    u.uPhaseFronts.value = c.phaseFronts;
+    u.uPointSize.value = c.pointSize;
+    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);
+}
+const BASE_U = 'uniform float uSize, uViewH, uIntensity, uOpacity;';
+// Phase colour: a cycle through color -> white-ish mid -> phaseColor -> mid -> color.
+const PHASE_GLSL = /* glsl */ `
+uniform vec3 uColor, uPhaseColor;
+vec3 phaseRamp(float c, float s) {
+  float t = 0.5 - 0.5 * c;                       // 0 at phase 0, 1 at phase pi
+  vec3 mid = mix(uColor, uPhaseColor, 0.5) * 0.7 + vec3(0.3) * (0.4 + 0.2 * s);
+  return t < 0.5 ? mix(uColor, mid, t * 2.0) : mix(mid, uPhaseColor, t * 2.0 - 1.0);
+}
+`;
+const partVertex = /* glsl */ `
+${BASE_U}
+${PHASE_GLSL}
+uniform float uPointSize;
+attribute vec2 aPhase;   // cos, sin of arg psi
+attribute float aSeed;
+varying vec3 vCol;
+varying float vA;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position * uSize, 1.0);
+  float px = uSize * uViewH * 0.0042 * uPointSize * (0.8 + 0.4 * aSeed) / -mv.z;
+  vCol = phaseRamp(aPhase.x, aPhase.y) * uIntensity * 0.8;
+  vA = uOpacity;
+  gl_PointSize = clamp(px, 1.0, 48.0);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const partFragment = /* glsl */ `
+varying vec3 vCol;
+varying float vA;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float a = (exp(-r2 * 9.0) + 0.18 * exp(-r2 * 2.5)) * (1.0 - r2) * vA;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(vCol, a);
+}
+`;
+// |psi|^2 haze: raymarch a sphere, evaluating the same superposition from the tables.
+const WAVE_GLSL = /* glsl */ `
+uniform sampler2D uTables;
+uniform float uRS, uRMax;
+uniform vec2 uAmp, uM, uPhA, uPhB;
+uniform mat3 uFrameInv;
+vec2 cmul(vec2 a, vec2 b) { return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x); }
+vec2 cpow(vec2 z, float m) {
+  vec2 r = vec2(1.0, 0.0);
+  if (m > 0.5) r = z;
+  if (m > 1.5) r = cmul(r, z);
+  if (m > 2.5) r = cmul(r, z);
+  return r;
+}
+// psi at a body-frame point (sim units), returns (Re, Im)
+vec2 psiAt(vec3 pb) {
+  vec3 p = pb * uRS;
+  float r = length(p);
+  float th = acos(clamp(p.y / max(r, 1e-5), -1.0, 1.0));
+  float rho = length(p.xz);
+  vec2 z = rho > 1e-5 ? vec2(p.x, p.z) / rho : vec2(1.0, 0.0);
+  vec4 Rr = texture2D(uTables, vec2((r / uRMax) * ${((NR - 1) / NR).toFixed(5)} + ${(0.5 / NR).toFixed(6)}, 0.25));
+  vec4 Tt = texture2D(uTables, vec2((th / 3.14159265) * ${((NR - 1) / NR).toFixed(5)} + ${(0.5 / NR).toFixed(6)}, 0.75));
+  float inside = step(r, uRMax);
+  float F = uAmp.x * Rr.x * Tt.x * inside, G = uAmp.y * Rr.y * Tt.y * inside;
+  vec2 wA = cmul(cpow(z, uM.x), uPhA), wB = cmul(cpow(z, uM.y), uPhB);
+  return F * wA + G * wB;
+}
+`;
+const volVertex = /* glsl */ `
+uniform float uSize;
+varying vec3 vLocal;
+void main() {
+  vLocal = position;
+  gl_Position = projectionMatrix * modelViewMatrix * vec4(position * uSize, 1.0);
+}
+`;
+const volFragment = /* glsl */ `
+${BASE_U}
+${PHASE_GLSL}
+${WAVE_GLSL}
+uniform float uCloudDensity, uPhaseFronts;
+uniform vec4 uCollapse;
+uniform vec3 uCamLocal;
+varying vec3 vLocal;
+void main() {
+  vec3 ro = uCamLocal;
+  vec3 rd = normalize(vLocal - ro);
+  float R = ${BOUNDS.radius.toFixed(2)};
+  float b = dot(ro, rd), cc = dot(ro, ro) - R * R;
+  float disc = b * b - cc;
+  if (disc <= 0.0) discard;
+  float sq = sqrt(disc);
+  float tn = max(-b - sq, 0.0), tf = -b + sq;
+  if (tf <= tn) discard;
+  const int N = 40;
+  float dt = (tf - tn) / float(N);
+  float jit = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
+  vec3 acc = vec3(0.0);
+  for (int i = 0; i < N; i++) {
+    vec3 p = ro + rd * (tn + (float(i) + jit) * dt);
+    vec2 ps = psiAt(uFrameInv * p);
+    float d2 = dot(ps, ps);
+    float mag = sqrt(max(d2, 1e-20));
+    vec2 ph = ps / mag;
+    // phase fronts: the surfaces S = 0 and S = pi (the particles cross them along grad S)
+    float front = pow(abs(ph.x), 40.0);
+    acc += phaseRamp(ph.x, ph.y) * d2 * (0.25 + 3.0 * uPhaseFronts * front);
+  }
+  // density per sim volume = |psi|^2 * RS^3; the collapse empties the stationary cloud a little
+  vec3 rgb = acc * dt * pow(uRS, 3.0) * uCloudDensity * uIntensity * uOpacity * 0.5 * (1.0 - 0.6 * uCollapse.w);
+  float I = max(max(rgb.r, rgb.g), rgb.b);
+  if (I < 0.0008) discard;
+  I = min(I, 1.0);
+  gl_FragColor = vec4(rgb / max(max(max(rgb.r, rgb.g), rgb.b), 1e-4), I);
+}
+`;
+// Glyphs: the atom's own reactions — nucleus, detector clicks, emitted photons (nothing at the cursor).
+const glyphVertex = /* glsl */ `
+uniform float uSize, uViewH;
+attribute vec4 aG; // kind, age, strength, unused
+varying vec4 vG;
+void main() {
+  vec4 mv = modelViewMatrix * vec4(position * uSize, 1.0);
+  float kind = aG.x;
+  float s = kind < 0.5 ? 0.035 : kind < 1.5 ? 0.08 + aG.y * 0.45 : 0.03; // nucleus, click flash, photon
+  vG = aG;
+  gl_PointSize = clamp(uSize * uViewH * s / -mv.z, 0.0, 300.0) * step(0.001, aG.z);
+  gl_Position = projectionMatrix * mv;
+}
+`;
+const glyphFragment = /* glsl */ `
+uniform vec3 uPointerColor;
+uniform float uOpacity, uIntensity;
+varying vec4 vG;
+void main() {
+  vec2 d = gl_PointCoord * 2.0 - 1.0;
+  float r2 = dot(d, d);
+  if (r2 > 1.0) discard;
+  float r = sqrt(r2);
+  float kind = vG.x;
+  float a; vec3 col = uPointerColor;
+  if (kind < 0.5) { a = exp(-r2 * 30.0) * 1.4 + exp(-r2 * 6.0) * 0.2; col = vec3(1.0, 0.93, 0.82); }
+  else if (kind < 1.5) a = (exp(-pow((r - 0.7 * min(vG.y * 2.5, 1.0)) / 0.08, 2.0)) * 1.2 + exp(-r2 * 30.0) * 3.0) * (1.0 - vG.y);
+  else a = exp(-r2 * 20.0) * (1.0 - vG.y);
+  a *= (1.0 - r2) * vG.z * uOpacity;
+  if (a < 0.003) discard;
+  gl_FragColor = vec4(col * uIntensity, a);
+}
+`;
+function build(u, c, size) {
+    const q = qualityScale(c.quality);
+    const n = Math.max(1, Math.round(c.particleCount * q));
+    const rng = mulberry32(seedMix(0xa70b, c.seed));
+    const SA = parseState(STATES.includes(c.stateA) ? c.stateA : '4f+2');
+    const SB = parseState(STATES.includes(c.stateB) ? c.stateB : '3d+1');
+    const nmax = Math.max(SA.n, SB.n);
+    const RS = 2.0 * nmax * nmax + 3; // Bohr radii per sim unit: the cloud fills ~ radius 1
+    const RMAX = RS * BOUNDS.radius;
+    const EA = -0.5 / (SA.n * SA.n), EB = -0.5 / (SB.n * SB.n);
+    const mA = SA.m, mB = SB.m;
+    const radA = radialTable(SA.n, SA.l, RMAX), radB = radialTable(SB.n, SB.l, RMAX);
+    const angA = angularTable(SA.l, SA.m), angB = angularTable(SB.l, SB.m);
+    // interleaved tables for the hot loop: r-table [RA, RA', RB, RB'], theta-table [TA, TA', TB, TB', sin, cos]
+    const RT = new Float64Array(NR * 4), TT = new Float64Array(NT * 6);
+    for (let i = 0; i < NR; i++) {
+        RT[i * 4] = radA.R[i];
+        RT[i * 4 + 1] = radA.dR[i];
+        RT[i * 4 + 2] = radB.R[i];
+        RT[i * 4 + 3] = radB.dR[i];
+    }
+    for (let i = 0; i < NT; i++) {
+        const th = (i / (NT - 1)) * Math.PI;
+        TT[i * 6] = angA.T[i];
+        TT[i * 6 + 1] = angA.dT[i];
+        TT[i * 6 + 2] = angB.T[i];
+        TT[i * 6 + 3] = angB.dT[i];
+        TT[i * 6 + 4] = Math.sin(th);
+        TT[i * 6 + 5] = Math.cos(th);
+    }
+    // GPU tables: row 0 = R_A, R_B over r; row 1 = Theta_A, Theta_B over theta (half floats, linear filtered)
+    const tex = new Uint16Array(NR * 2 * 4);
+    for (let i = 0; i < NR; i++) {
+        tex[i * 4] = THREE.DataUtils.toHalfFloat(radA.R[i]);
+        tex[i * 4 + 1] = THREE.DataUtils.toHalfFloat(radB.R[i]);
+        const ti = Math.min(Math.round((i / (NR - 1)) * (NT - 1)), NT - 1);
+        tex[(NR + i) * 4] = THREE.DataUtils.toHalfFloat(angA.T[ti]);
+        tex[(NR + i) * 4 + 1] = THREE.DataUtils.toHalfFloat(angB.T[ti]);
+    }
+    const tables = new THREE.DataTexture(tex, NR, 2, THREE.RGBAFormat, THREE.HalfFloatType);
+    tables.magFilter = THREE.LinearFilter;
+    tables.minFilter = THREE.LinearFilter;
+    tables.wrapS = THREE.ClampToEdgeWrapping;
+    tables.wrapT = THREE.ClampToEdgeWrapping;
+    tables.needsUpdate = true;
+    u.uTables.value = tables;
+    u.uRS.value = RS;
+    u.uRMax.value = RMAX;
+    u.uM.value.set(mA, mB);
+    // ---- state ----
+    let chi = Math.asin(Math.sqrt(Math.min(Math.max(u.uMix.value, 0), 1)));
+    let delta = 0;
+    let tau = 0;
+    // ---- initial positions: exact |psi(0)|^2 sampling (mixture proposal + interference rejection) ----
+    const rA = cdfSample(Array.from(radA.R, (v, i) => v * v * ((i / (NR - 1)) * RMAX) ** 2), rng);
+    const rB = cdfSample(Array.from(radB.R, (v, i) => v * v * ((i / (NR - 1)) * RMAX) ** 2), rng);
+    const tA = cdfSample(Array.from(angA.T, (v, i) => v * v * Math.sin((i / (NT - 1)) * Math.PI)), rng);
+    const tB = cdfSample(Array.from(angB.T, (v, i) => v * v * Math.sin((i / (NT - 1)) * Math.PI)), rng);
+    const pr = new Float64Array(n), pth = new Float64Array(n), pc = new Float64Array(n), psn = new Float64Array(n);
+    function lookup(r, th) {
+        const fr = Math.min(Math.max(r / RMAX, 0), 1) * (NR - 1);
+        const i0 = Math.min(fr | 0, NR - 2), t = fr - i0;
+        const ft = Math.min(Math.max(th / Math.PI, 0), 1) * (NT - 1);
+        const j0 = Math.min(ft | 0, NT - 2), w = ft - j0;
+        const RA = RT[i0 * 4] + (RT[i0 * 4 + 4] - RT[i0 * 4]) * t;
+        const RB = RT[i0 * 4 + 2] + (RT[i0 * 4 + 6] - RT[i0 * 4 + 2]) * t;
+        const TA = TT[j0 * 6] + (TT[j0 * 6 + 6] - TT[j0 * 6]) * w;
+        const TB = TT[j0 * 6 + 2] + (TT[j0 * 6 + 8] - TT[j0 * 6 + 2]) * w;
+        return [RA * TA, RB * TB];
+    }
+    function sampleAll(chiNow) {
+        const a = Math.cos(chiNow), b = Math.sin(chiNow);
+        for (let i = 0; i < n; i++) {
+            for (let tries = 0; tries < 200; tries++) {
+                const useA = rng() < a * a;
+                const r = (useA ? rA() : rB()) * RMAX;
+                const th = (useA ? tA() : tB()) * Math.PI;
+                const ph = rng() * 6.2831853;
+                const [fa, fb] = lookup(r, th);
+                const F = a * fa, G = b * fb;
+                const dPh = (mA - mB) * ph;
+                const num = F * F + G * G + 2 * F * G * Math.cos(dPh);
+                const den = 2 * (F * F + G * G) + 1e-30;
+                if (rng() * den <= num || tries === 199) {
+                    pr[i] = r;
+                    pth[i] = th;
+                    pc[i] = Math.cos(ph);
+                    psn[i] = Math.sin(ph);
+                    break;
+                }
+            }
+        }
+    }
+    sampleAll(chi);
+    const pos = new Float32Array(n * 3), vel = new Float32Array(n * 3), phase = new Float32Array(n * 2);
+    const seedA = new Float32Array(n);
+    for (let i = 0; i < n; i++)
+        seedA[i] = rng();
+    // ---- pointer state ----
+    const Q = new THREE.Matrix4(); // body -> world rotation (magnet precession)
+    const Qi = new THREE.Matrix3();
+    const axis = new THREE.Vector3(0, 1, 0);
+    const qtmp = new THREE.Matrix4();
+    const col = { x: 0, y: 0, z: 0, k: 0, t: 0 }; // collapse point (world), strength, target
+    const clickRng = mulberry32(seedMix(0xc11c, c.seed));
+    let clickAge = 9, clickX = 0, clickY = 0, clickZ = 0;
+    const PH = new Float32Array(MAX_PHOT * 7); // x,y,z, vx,vy,vz, age
+    for (let k = 0; k < MAX_PHOT; k++)
+        PH[k * 7 + 6] = 9;
+    let phHead = 0, emitAcc = 0;
+    const hp = new THREE.Vector3();
+    function step(h) {
+        const S = u.uPointerStrength.value, act = u.uPointerActive.value, mode = u.uPointerMode.value;
+        const Rr = u.uPointerRadius.value;
+        hp.copy(u.uPointer.value);
+        const dtau = h * TS * u.uTimeScale.value;
+        tau += dtau;
+        // photon: Rabi drive toward the other state while it shines, spontaneous decay back when released
+        const chi0 = Math.asin(Math.sqrt(Math.min(Math.max(u.uMix.value, 0), 1)));
+        if (mode === 0 && S > 0.01) {
+            const dist = hp.length();
+            const reach = 0.9 * Rr;
+            const omega = 0.9 * S * act / (1 + (dist * dist) / (reach * reach));
+            chi += omega * h;
+            if (omega < 0.02) {
+                const before = Math.sin(chi) ** 2;
+                // chi and chi + pi are the same physical state: relax to the nearest copy of chi0
+                const target = chi0 + Math.PI * Math.round((chi - chi0) / Math.PI);
+                chi += (target - chi) * Math.min(1, h * 0.45);
+                const lost = Math.max(before - Math.sin(chi) ** 2, 0);
+                emitAcc += lost * 60; // photons shed as population returns
+            }
+        }
+        else {
+            const target = chi0 + Math.PI * Math.round((chi - chi0) / Math.PI);
+            chi += (target - chi) * Math.min(1, h * 0.8);
+        }
+        // magnet: Larmor precession about the pointer direction
+        if (mode === 1 && S > 0.01 && act > 0.01) {
+            axis.copy(hp);
+            if (axis.lengthSq() > 1e-6) {
+                axis.normalize();
+                qtmp.makeRotationAxis(axis, 0.8 * S * act * h);
+                Q.premultiply(qtmp);
+            }
+        }
+        Qi.setFromMatrix4(Q).transpose();
+        u.uFrameInv.value.copy(Qi);
+        const a = Math.cos(chi), b = Math.sin(chi);
+        u.uAmp.value.set(a, b);
+        const eAc = Math.cos(EA * tau), eAs = -Math.sin(EA * tau);
+        const eBc = Math.cos(-EB * tau + delta), eBs = Math.sin(-EB * tau + delta);
+        u.uPhA.value.set(eAc, eAs);
+        u.uPhB.value.set(eBc, eBs);
+        const qe = Q.elements;
+        const q00 = qe[0], q10 = qe[1], q20 = qe[2], q01 = qe[4], q11 = qe[5], q21 = qe[6], q02 = qe[8], q12 = qe[9], q22 = qe[10];
+        // detector: count probability in the window, click at a Poisson rate, collapse
+        const measuring = mode === 2 && S > 0.01 && act > 0.05;
+        const Rd = 0.14 * Rr, Rd2 = Rd * Rd;
+        let inWin = 0, pick = -1;
+        // the collapse eases in fast (0.12 s) and releases slowly (the packet re-spreads)
+        col.t *= Math.exp(-h / 1.1);
+        col.k += (col.t - col.k) * Math.min(1, h / 0.12);
+        const kap = col.k, cx = col.x, cy = col.y, cz = col.z;
+        const Rc2 = 2 * 0.3 * 0.3 * Rr * Rr;
+        clickAge += h;
+        const RSi = 1 / RS;
+        for (let i = 0; i < n; i++) {
+            let r = pr[i], th = pth[i], cph = pc[i], sph = psn[i];
+            // tables
+            let fr = r * (NR - 1) / RMAX;
+            if (fr > NR - 1.001)
+                fr = NR - 1.001;
+            const i0 = fr | 0, t = fr - i0, o = i0 * 4;
+            let ft = th * (NT - 1) / Math.PI;
+            if (ft < 0)
+                ft = 0;
+            else if (ft > NT - 1.001)
+                ft = NT - 1.001;
+            const j0 = ft | 0, w = ft - j0, p = j0 * 6;
+            const RA = RT[o] + (RT[o + 4] - RT[o]) * t, RAd = RT[o + 1] + (RT[o + 5] - RT[o + 1]) * t;
+            const RB = RT[o + 2] + (RT[o + 6] - RT[o + 2]) * t, RBd = RT[o + 3] + (RT[o + 7] - RT[o + 3]) * t;
+            const TA = TT[p] + (TT[p + 6] - TT[p]) * w, TAd = TT[p + 1] + (TT[p + 7] - TT[p + 1]) * w;
+            const TB = TT[p + 2] + (TT[p + 8] - TT[p + 2]) * w, TBd = TT[p + 3] + (TT[p + 9] - TT[p + 3]) * w;
+            const sT = TT[p + 4] + (TT[p + 10] - TT[p + 4]) * w, cT = TT[p + 5] + (TT[p + 11] - TT[p + 5]) * w;
+            const F = a * RA * TA, Fr = a * RAd * TA, Ft = a * RA * TAd;
+            const G = b * RB * TB, Gr = b * RBd * TB, Gt = b * RB * TBd;
+            // e^{i m phi} by complex powers of (cos phi, sin phi) — no trig per particle
+            let zAc = 1, zAs = 0, zBc = 1, zBs = 0;
+            const z2c = cph * cph - sph * sph, z2s = 2 * cph * sph;
+            if (mA === 1) {
+                zAc = cph;
+                zAs = sph;
+            }
+            else if (mA === 2) {
+                zAc = z2c;
+                zAs = z2s;
+            }
+            else if (mA === 3) {
+                zAc = z2c * cph - z2s * sph;
+                zAs = z2c * sph + z2s * cph;
+            }
+            if (mB === 1) {
+                zBc = cph;
+                zBs = sph;
+            }
+            else if (mB === 2) {
+                zBc = z2c;
+                zBs = z2s;
+            }
+            else if (mB === 3) {
+                zBc = z2c * cph - z2s * sph;
+                zBs = z2c * sph + z2s * cph;
+            }
+            const cA = zAc * eAc - zAs * eAs, sA = zAc * eAs + zAs * eAc;
+            const cB = zBc * eBc - zBs * eBs, sB = zBc * eBs + zBs * eBc;
+            const cD = cA * cB + sA * sB, sD = sA * cB - cA * sB;
+            const rho = F * F + G * G + 2 * F * G * cD + 1e-30;
+            const re = F * cA + G * cB, im = F * sA + G * sB;
+            const mag = Math.sqrt(re * re + im * im) + 1e-30;
+            phase[i * 2] = re / mag;
+            phase[i * 2 + 1] = im / mag;
+            // Bohm guidance v = Im(grad psi / psi) in spherical components
+            const rs = r > 1e-3 ? r : 1e-3;
+            const st = sT > 1e-3 ? sT : 1e-3;
+            let dr = (sD * (Fr * G - Gr * F) / rho) * dtau;
+            let dth = (sD * (Ft * G - Gt * F) / (rho * rs * rs)) * dtau;
+            let dph = ((mA * F * F + mB * G * G + F * G * cD * (mA + mB)) / (rho * rs * rs * st * st)) * dtau;
+            const lim = 0.3 + 0.02 * r;
+            if (dr > lim)
+                dr = lim;
+            else if (dr < -lim)
+                dr = -lim;
+            if (dth > 0.06)
+                dth = 0.06;
+            else if (dth < -0.06)
+                dth = -0.06;
+            if (dph > 0.3)
+                dph = 0.3;
+            else if (dph < -0.3)
+                dph = -0.3;
+            r += dr;
+            th += dth;
+            if (r < 0) {
+                r = -r;
+                th = Math.PI - th;
+                cph = -cph;
+                sph = -sph;
+            }
+            if (r > RMAX * 0.98)
+                r = RMAX * 0.98;
+            if (th < 0) {
+                th = -th;
+                cph = -cph;
+                sph = -sph;
+            }
+            else if (th > Math.PI) {
+                th = 2 * Math.PI - th;
+                cph = -cph;
+                sph = -sph;
+            }
+            // rotate (cos phi, sin phi) by dph (second order) and renormalise
+            const qc = 1 - 0.5 * dph * dph, qs = dph - dph * dph * dph / 6;
+            let nc = cph * qc - sph * qs, ns = sph * qc + cph * qs;
+            const nl = 1 / Math.sqrt(nc * nc + ns * ns);
+            nc *= nl;
+            ns *= nl;
+            pr[i] = r;
+            pth[i] = th;
+            pc[i] = nc;
+            psn[i] = ns;
+            // body -> world (y is the quantisation axis), sim units
+            const rsn = r * sT * RSi;
+            const bx = rsn * nc, by = r * cT * RSi, bz = rsn * ns;
+            let x = q00 * bx + q01 * by + q02 * bz, y = q10 * bx + q11 * by + q12 * bz, z = q20 * bx + q21 * by + q22 * bz;
+            if (measuring) {
+                const ex = x - hp.x, ey = y - hp.y, ez = z - hp.z;
+                if (ex * ex + ey * ey + ez * ez < Rd2) {
+                    inWin++;
+                    if (clickRng() * inWin < 1)
+                        pick = i;
+                }
+            }
+            if (kap > 0.003) {
+                // collapse map: a smooth, invertible contraction toward the detected point
+                const ex = x - cx, ey = y - cy, ez = z - cz;
+                const e2 = ex * ex + ey * ey + ez * ez;
+                if (e2 < 9 * Rc2) {
+                    const f = 1 - kap * Math.exp(-e2 / Rc2);
+                    x = cx + ex * f;
+                    y = cy + ey * f;
+                    z = cz + ez * f;
+                }
+            }
+            const j = i * 3;
+            vel[j] = (x - pos[j]) / h;
+            vel[j + 1] = (y - pos[j + 1]) / h;
+            vel[j + 2] = (z - pos[j + 2]) / h;
+            pos[j] = x;
+            pos[j + 1] = y;
+            pos[j + 2] = z;
+        }
+        // detector click: rate ~ efficiency x probability in the window
+        if (measuring && inWin > 0 && pick >= 0) {
+            const P = inWin / n;
+            const rate = 60 * S * P;
+            if (clickRng() < rate * h && clickAge > 0.25) {
+                const j = pick * 3;
+                col.x = pos[j];
+                col.y = pos[j + 1];
+                col.z = pos[j + 2];
+                col.t = 0.88;
+                clickX = col.x;
+                clickY = col.y;
+                clickZ = col.z;
+                clickAge = 0;
+            }
+        }
+        u.uCollapse.value.set(col.x, col.y, col.z, col.k);
+        // spontaneous-emission photons
+        while (emitAcc >= 1) {
+            emitAcc -= 1;
+            const k = phHead % MAX_PHOT;
+            phHead++;
+            let dx = clickRng() * 2 - 1, dy = clickRng() * 2 - 1, dz = clickRng() * 2 - 1;
+            const l = Math.hypot(dx, dy, dz) || 1;
+            dx /= l;
+            dy /= l;
+            dz /= l;
+            PH[k * 7] = dx * 0.12;
+            PH[k * 7 + 1] = dy * 0.12;
+            PH[k * 7 + 2] = dz * 0.12;
+            PH[k * 7 + 3] = dx * 1.4;
+            PH[k * 7 + 4] = dy * 1.4;
+            PH[k * 7 + 5] = dz * 1.4;
+            PH[k * 7 + 6] = 0;
+        }
+        for (let k = 0; k < MAX_PHOT; k++) {
+            if (PH[k * 7 + 6] > 1.5)
+                continue;
+            PH[k * 7 + 6] += h;
+            PH[k * 7] += PH[k * 7 + 3] * h;
+            PH[k * 7 + 1] += PH[k * 7 + 4] * h;
+            PH[k * 7 + 2] += PH[k * 7 + 5] * h;
+        }
+    }
+    const stepper = createFixedStep(H_STEP, 4);
+    for (let s = 0; s < 3; s++)
+        step(H_STEP); // fill velocities
+    // ---- geometry ----
+    const geo = new THREE.BufferGeometry();
+    const posAttr = new THREE.BufferAttribute(pos, 3).setUsage(THREE.DynamicDrawUsage);
+    const phAttr = new THREE.BufferAttribute(phase, 2).setUsage(THREE.DynamicDrawUsage);
+    geo.setAttribute('position', posAttr);
+    geo.setAttribute('aPhase', phAttr);
+    geo.setAttribute('aSeed', new THREE.BufferAttribute(seedA, 1));
+    const mat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: partVertex, fragmentShader: partFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const parts = new THREE.Points(geo, mat);
+    parts.frustumCulled = false;
+    attachViewH(parts, u);
+    const volGeo = new THREE.SphereGeometry(BOUNDS.radius, 40, 24);
+    const volMat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: volVertex, fragmentShader: volFragment,
+        transparent: true, depthWrite: false, depthTest: false, side: THREE.BackSide, blending: THREE.AdditiveBlending,
+    });
+    const haze = new THREE.Mesh(volGeo, volMat);
+    haze.frustumCulled = false;
+    const NG = 2 + MAX_PHOT;
+    const gp = new Float32Array(NG * 3), ga = new Float32Array(NG * 4);
+    const gpAttr = new THREE.BufferAttribute(gp, 3).setUsage(THREE.DynamicDrawUsage);
+    const gaAttr = new THREE.BufferAttribute(ga, 4).setUsage(THREE.DynamicDrawUsage);
+    const ggeo = new THREE.BufferGeometry();
+    ggeo.setAttribute('position', gpAttr);
+    ggeo.setAttribute('aG', gaAttr);
+    const gmat = new THREE.ShaderMaterial({
+        uniforms: u, vertexShader: glyphVertex, fragmentShader: glyphFragment,
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const glyphs = new THREE.Points(ggeo, gmat);
+    glyphs.frustumCulled = false;
+    const object = new THREE.Group();
+    const proxy = createPickProxy(BOUNDS.center, BOUNDS.radius);
+    object.add(haze, parts, glyphs, proxy.mesh);
+    const anchor = new THREE.Vector3(0, 0, 0);
+    function uploadGlyphs() {
+        ga.set([0, 0, 1, 0], 0); // nucleus
+        gp[3] = clickX;
+        gp[4] = clickY;
+        gp[5] = clickZ; // detector click
+        ga.set([1, Math.min(clickAge / 0.6, 1), clickAge < 0.6 ? 1 : 0, 0], 4);
+        for (let k = 0; k < MAX_PHOT; k++) { // spontaneous-emission photons
+            const g = 2 + k;
+            gp[g * 3] = PH[k * 7];
+            gp[g * 3 + 1] = PH[k * 7 + 1];
+            gp[g * 3 + 2] = PH[k * 7 + 2];
+            const age = PH[k * 7 + 6];
+            ga.set([2, Math.min(age / 1.5, 1), age < 1.5 ? 1 : 0, 0], g * 4);
+        }
+        gpAttr.needsUpdate = true;
+        gaAttr.needsUpdate = true;
+    }
+    // ---- trails ----
+    const trailGLSL = /* glsl */ `
+uniform vec3 uColor;
+vec3 trailShade(vec3 p, float f) { return uColor * 0.7; }
+vec3 trailView(vec3 mv, out float mag) { mag = 1.0; return mv; }
+`;
+    const materials = [mat, volMat, gmat];
+    let trail = null, trailKey = '';
+    function buildTrails(mode, share) {
+        const key = mode + ':' + share;
+        if (key === trailKey)
+            return;
+        trailKey = key;
+        if (trail) {
+            object.remove(trail.object);
+            trail.dispose();
+            trail = null;
+        }
+        materials.length = 3;
+        trail = createCpuTrail(mode, { u, n, pos, vel, glsl: trailGLSL, sizePx: 0.0035, spacing: 0.0025 });
+        if (!trail)
+            return;
+        object.add(trail.object);
+        materials.push(...trail.materials);
+    }
+    buildTrails(c.trailMode, c.trailShare);
+    uploadGlyphs();
+    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);
+            if (camera && !inView(object, camera, BOUNDS.center, BOUNDS.radius, u.uSize.value))
+                return;
+            const d = rdt * u.uSpeed.value;
+            u.uTime.value += d;
+            if (camera) {
+                object.worldToLocal(u.uCamLocal.value.copy(camera.position)).divideScalar(u.uSize.value);
+                if (pointer)
+                    stepPointerField(u, pointer, camera, object, u.uSize.value, rdt, anchor);
+            }
+            u.uVelScale.value = u.uSpeed.value;
+            let simD = 0;
+            stepper.run(d, (hh) => { step(hh); simD += hh; });
+            if (simD > 0) {
+                posAttr.needsUpdate = true;
+                phAttr.needsUpdate = true;
+                uploadGlyphs();
+                if (trail)
+                    trail.update(simD);
+            }
+        },
+        seek(t) { for (let s = 0; s < Math.round(t / H_STEP); s++)
+            step(H_STEP); posAttr.needsUpdate = true; phAttr.needsUpdate = true; },
+        dispose() {
+            geo.dispose();
+            mat.dispose();
+            volGeo.dispose();
+            volMat.dispose();
+            ggeo.dispose();
+            gmat.dispose();
+            tables.dispose();
+            proxy.dispose();
+            if (trail)
+                trail.dispose();
+        },
+        _state: { pos, vel, phase, pr },
+    };
+}
+/** 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: '#6fd6ff',
+    particleCount: 24000,
+    stateA: '4f+2',
+    stateB: '3d+1',
+    mix: 0.35,
+    timeScale: 1,
+    phaseColor: '#ff6ad5',
+    cloudDensity: 0.7,
+    phaseFronts: 1,
+    pointSize: 0.8,
+    seed: 1,
+    quality: 'medium',
+    pointerMode: 'photon',
+    pointerStrength: 1,
+    pointerRadius: 1,
+    pointerColor: '#fff2c4',
+    trailMode: 'comet',
+    trailLength: 2.5,
+    trailOpacity: 0.45,
+    trailColor: '#7a8cff',
+    trailShare: 0.3,
+};
+const ElectronOrbitalsParticles = ({ 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.stateA, cfg.stateB, cfg.seed, cfg.quality]);
+    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 ElectronOrbitalsParticles;