@3driseai/3drise-viewer 0.1.27 → 0.1.29

package/dist/components/environment/Rainbow.js

@@ -0,0 +1,974 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useFrame } from '@react-three/fiber';
+import { DEFAULT_ENVIRONMENT_OBJECTS, ENVIRONMENT_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { withConfigDefaults } from '../../utils/configAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useConfigDriver } from '../../hooks/useConfigDriver.js';
+import { useCloudSun } from '../../hooks/useCloudSun.js';
+import { stepPointerField, usePointerField } from '../../utils/pointerField.js';
+// Generated from Claude outputs/environment-lab (common.mjs + rainbow.mjs, the approved lab modules)
+// by gen_family.mjs — edit there and regenerate.
+// ---------------------------------------------------------------------------- shared core
+// Shared core of the environment objects (lab). Inlined verbatim into every generated component.
+//
+// Slice volume: continuous media (dust, rain curtains, funnels) are rendered as N view-aligned
+// slices between the camera and the far side of the volume, drawn back to front in one instanced
+// call. Each slice is a full-screen quad at a fixed view depth, depth-tested against the scene,
+// so objects inside the medium are hidden by exactly the medium in front of them — volume
+// rendering without a depth texture. Slices are spaced geometrically (dense near the eye) and
+// every fragment samples at a per-pixel dithered depth inside its slab, which turns slice
+// banding into fine grain.
+//
+// What a slice volume costs is pixels x slices x the work per sample, so the core keeps all three down:
+//   noise     vnoise3 is one trilinear fetch from a small 3-D texture holding the very lattice values
+//             the hash gave (the smoothstep goes into the coordinate), instead of 8 hashes and 7 mixes.
+//   bounds    slices cover the volume's box on screen, not the whole screen.
+//   density   on a dense display (device pixel ratio above 1) neighbouring pixels take turns over the
+//             slices (2 or 4 interleaved sets, each sample standing for the slabs it skips), so the
+//             samples per CSS pixel — what the eye resolves — stay what they are at ratio 1.
+//   reach     near layers (streaks, grains, splashes) are not submitted when the camera is too far
+//             from the volume to see any of them (layerInReach).
+const WIND_MS_COMMON = 8; // m/s per unit of windStrength (Rain's 0..1 range)
+const DEG_C = Math.PI / 180;
+function mulberry32(a) {
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+// ---------------------------------------------------------------------------- noise texture
+// The lattice of vnoise3 as a texture: NOISE_N^3 values of the same hash the shader used to evaluate,
+// for lattice points -NOISE_N/2 .. NOISE_N/2 - 1 on each axis (beyond that it repeats). One per page,
+// shared by every environment object.
+const NOISE_N = 64;
+let _noiseTex = null;
+function noiseTexture() {
+    if (_noiseTex)
+        return _noiseTex;
+    const N = NOISE_N, H = N / 2, f = Math.fround;
+    const fr = (x) => f(x - Math.floor(x));
+    const data = new Uint8Array(N * N * N);
+    let o = 0;
+    for (let z = 0; z < N; z++)
+        for (let y = 0; y < N; y++)
+            for (let x = 0; x < N; x++) {
+                // hash13: p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z);
+                let px = fr(f((x - H) * f(0.1031))), py = fr(f((y - H) * f(0.1031))), pz = fr(f((z - H) * f(0.1031)));
+                const d = f(f(f(px * f(pz + f(31.32))) + f(py * f(py + f(31.32)))) + f(pz * f(px + f(31.32))));
+                px = f(px + d);
+                py = f(py + d);
+                pz = f(pz + d);
+                data[o++] = Math.min(255, Math.round(fr(f(f(px + py) * pz)) * 255));
+            }
+    const tex = new THREE.Data3DTexture(data, N, N, N);
+    tex.format = THREE.RedFormat;
+    tex.type = THREE.UnsignedByteType;
+    tex.minFilter = THREE.LinearFilter;
+    tex.magFilter = THREE.LinearFilter;
+    tex.wrapS = THREE.RepeatWrapping;
+    tex.wrapT = THREE.RepeatWrapping;
+    tex.wrapR = THREE.RepeatWrapping;
+    tex.unpackAlignment = 1;
+    tex.generateMipmaps = false;
+    tex.needsUpdate = true;
+    _noiseTex = tex;
+    return tex;
+}
+function setColor(uniform, v) {
+    if (v === undefined || v === null)
+        return;
+    if (v.isColor)
+        uniform.value.copy(v);
+    else
+        uniform.value.set(v);
+}
+/** Uniforms every environment object has. */
+function createCommonUniforms() {
+    return {
+        uTime: { value: 0 },
+        uWind: { value: new THREE.Vector2() },
+        uWindDir: { value: new THREE.Vector2(0, 1) },
+        uWindStrength: { value: 0.2 },
+        uTurb: { value: 0.3 },
+        uTurbPhase: { value: 0 },
+        uSpeed: { value: 1 },
+        uVolume: { value: new THREE.Vector3(100, 40, 100) },
+        uCam: { value: new THREE.Vector3() },
+        uCamToLocal: { value: new THREE.Matrix4() },
+        uSliceNear: { value: 0.3 },
+        uSliceFar: { value: 200 },
+        uSliceCount: { value: 32 },
+        uSliceRect: { value: new THREE.Vector4(-1.04, -1.04, 1.04, 1.04) },
+        uSkip: { value: 1 },
+        uSkipMax: { value: 4 },
+        uNoise: { value: noiseTexture() },
+        uFollow: { value: 0 },
+        uViewH: { value: 800 },
+        uIntensity: { value: 1 },
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color('#ffffff') },
+        uShadeColor: { value: new THREE.Color('#808080') },
+        uSunDir: { value: new THREE.Vector3(0.35, 0.42, 0.84).normalize() },
+        uSunColor: { value: new THREE.Color(1.0, 0.93, 0.82) },
+        uSkyAmbient: { value: new THREE.Color(0.55, 0.65, 0.85) },
+        uPointer: { value: new THREE.Vector3() },
+        uPointerVel: { value: new THREE.Vector3() },
+        uPointerActive: { value: 0 },
+        uPointerMode: { value: -1 },
+        uPointerStrength: { value: 1 },
+        uPointerRadius: { value: 1 },
+        uPointerColor: { value: new THREE.Color('#ffffff') },
+    };
+}
+/** The base knobs every environment object shares (push point, part 1). */
+function applyCommonConfig(u, c, pointerModes) {
+    if (c.intensity !== undefined)
+        u.uIntensity.value = c.intensity;
+    if (c.speed !== undefined)
+        u.uSpeed.value = c.speed;
+    if (c.opacity !== undefined)
+        u.uOpacity.value = c.opacity;
+    setColor(u.uColor, c.color);
+    setColor(u.uShadeColor, c.shadeColor);
+    setColor(u.uPointerColor, c.pointerColor);
+    if (c.windStrength !== undefined)
+        u.uWindStrength.value = c.windStrength;
+    if (c.windDirection !== undefined)
+        u.uWindDir.value.set(Math.sin(c.windDirection * DEG_C), Math.cos(c.windDirection * DEG_C));
+    if (c.turbulence !== undefined)
+        u.uTurb.value = c.turbulence;
+    if (c.pointerStrength !== undefined)
+        u.uPointerStrength.value = c.pointerStrength;
+    if (c.pointerRadius !== undefined)
+        u.uPointerRadius.value = c.pointerRadius;
+    if (c.pointerMode !== undefined)
+        u.uPointerMode.value = pointerModes.indexOf(c.pointerMode);
+    if (c.followCamera !== undefined)
+        u.uFollow.value = c.followCamera ? 1 : 0;
+}
+const _cs = new THREE.Vector3(), _cc = new THREE.Vector3(), _cq = new THREE.Quaternion(), _csun = new THREE.Vector3();
+const _cinv = new THREE.Matrix4();
+const _corner = new THREE.Vector3();
+const _cview = new THREE.Matrix4();
+/** Per-frame bookkeeping shared by every object: volume, camera, slice range and bounds, sun, phases. */
+function updateCommon(u, object, camera, dt, viewH, sunWorld, dpr) {
+    // the camera may have been moved this frame (controls) without its matrices following yet
+    camera.updateMatrixWorld();
+    object.updateWorldMatrix(true, false);
+    object.getWorldScale(_cs);
+    u.uVolume.value.set(Math.max(_cs.x, 0.01), Math.max(_cs.y, 0.01), Math.max(_cs.z, 0.01));
+    const V = u.uVolume.value;
+    object.worldToLocal(_cc.copy(camera.position));
+    u.uCam.value.set(_cc.x * V.x, _cc.y * V.y, _cc.z * V.z);
+    _cinv.copy(object.matrixWorld).invert();
+    u.uCamToLocal.value.multiplyMatrices(_cinv, camera.matrixWorld);
+    if (viewH)
+        u.uViewH.value = viewH;
+    // slice range: from where the volume starts in front of the eye to its far corner
+    const C = u.uCam.value;
+    const follow = u.uFollow.value > 0.5;
+    const hx = follow ? 1e6 : V.x / 2, hz = follow ? 1e6 : V.z / 2;
+    const dx = Math.max(Math.abs(C.x) - hx, 0), dz = Math.max(Math.abs(C.z) - hz, 0);
+    const dy = Math.max(-C.y, C.y - V.y, 0);
+    const dNear = Math.hypot(dx, dy, dz);
+    let dFar = 0;
+    for (let i = 0; i < 8; i++) {
+        _corner.set((i & 1 ? 1 : -1) * Math.min(hx, 3e3), i & 2 ? V.y : 0, (i & 4 ? 1 : -1) * Math.min(hz, 3e3));
+        dFar = Math.max(dFar, _corner.distanceTo(C));
+    }
+    const far = camera.far !== undefined ? camera.far : 2000;
+    u.uSliceNear.value = Math.max(0.3, dNear * 0.6);
+    u.uSliceFar.value = Math.max(u.uSliceNear.value * 1.5, Math.min(dFar, 600, far * 0.98));
+    // Slice bounds: the volume's box on screen (NDC). Whole screen when the box reaches behind the
+    // eye (the camera is inside or right next to it) or follows the camera.
+    const R = u.uSliceRect.value.set(-1.04, -1.04, 1.04, 1.04);
+    if (!follow && camera.projectionMatrix) {
+        _cview.copy(camera.matrixWorld).invert().multiply(object.matrixWorld);
+        const P = camera.projectionMatrix.elements, nearZ = camera.near !== undefined ? camera.near : 0.1;
+        let x0 = 1e9, y0 = 1e9, x1 = -1e9, y1 = -1e9, ok = true;
+        for (let i = 0; i < 8 && ok; i++) {
+            _corner.set(i & 1 ? 0.5 : -0.5, i & 2 ? 1 : 0, i & 4 ? 0.5 : -0.5).applyMatrix4(_cview);
+            if (_corner.z > -nearZ) {
+                ok = false;
+                break;
+            }
+            const w = -_corner.z, x = (P[0] * _corner.x + P[8] * _corner.z) / w, y = (P[5] * _corner.y + P[9] * _corner.z) / w;
+            if (x < x0)
+                x0 = x;
+            if (x > x1)
+                x1 = x;
+            if (y < y0)
+                y0 = y;
+            if (y > y1)
+                y1 = y;
+        }
+        // the margin covers the depth dither, which slides a sample along its ray but never off its pixel
+        if (ok)
+            R.set(Math.max(x0 - 0.03, -1.04), Math.max(y0 - 0.03, -1.04), Math.min(x1 + 0.03, 1.04), Math.min(y1 + 0.03, 1.04));
+        if (R.z <= R.x || R.w <= R.y)
+            R.set(0, 0, 0, 0); // off screen: nothing to draw
+    }
+    // Interleaved slices on dense displays: pixels take turns over 2 (ratio >= 1.25) or 4 (>= 1.75) sets.
+    // An object caps it (buildSlices' interleave): fine, fast-changing structure like the tornado's funnel
+    // loses its crispness when neighbours see different slabs, so it takes every slice.
+    u.uSkip.value = Math.min(dpr >= 1.75 ? 4 : dpr >= 1.25 ? 2 : 1, u.uSkipMax.value);
+    // phases (rates integrated on the CPU, so animating them never jumps)
+    const sp = u.uSpeed.value;
+    u.uTime.value += dt * sp;
+    u.uWind.value.addScaledVector(u.uWindDir.value, dt * sp * u.uWindStrength.value * WIND_MS_COMMON);
+    u.uTurbPhase.value += dt * sp * 0.25;
+    if (sunWorld) {
+        object.getWorldQuaternion(_cq).invert();
+        u.uSunDir.value.copy(_csun.copy(sunWorld).normalize().applyQuaternion(_cq));
+    }
+}
+/**
+ * True when a layer that only exists inside the volume and within `reach` metres of the eye can show
+ * anything: used to skip submitting near layers (thousands of instances, each fully evaluated per
+ * vertex) while the camera is away from the volume.
+ */
+function layerInReach(u, reach) {
+    const C = u.uCam.value, V = u.uVolume.value, follow = u.uFollow.value > 0.5;
+    const ox = follow ? 0 : Math.max(Math.abs(C.x) - 0.5 * V.x, 0), oz = follow ? 0 : Math.max(Math.abs(C.z) - 0.5 * V.z, 0);
+    const oy = Math.max(-C.y, C.y - V.y, 0);
+    return ox * ox + oy * oy + oz * oz < reach * reach;
+}
+// Where the pointer plane passes (object-local unit coords; the plane faces the camera):
+// a few metres ahead of the eye inside the volume, else through the volume centre's depth.
+const _pa = new THREE.Vector3(), _pd = new THREE.Vector3(), _pc = new THREE.Vector3();
+function pointerAnchor(object, camera, u, out, ahead) {
+    const V = u.uVolume.value, C = u.uCam.value;
+    const inside = Math.abs(C.x) < 0.5 * V.x && Math.abs(C.z) < 0.5 * V.z && C.y > 0 && C.y < V.y;
+    camera.getWorldDirection(_pd);
+    let dist = ahead || 4.5;
+    if (!inside) {
+        object.updateWorldMatrix(true, false);
+        object.localToWorld(_pc.set(0, 0.5, 0));
+        dist = Math.max(dist, _pc.sub(camera.position).dot(_pd));
+    }
+    _pa.copy(camera.position).addScaledVector(_pd, dist);
+    return object.worldToLocal(out.copy(_pa));
+}
+const NOISE_GLSL = /* glsl */ `
+uniform highp sampler3D uNoise;
+float hash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }
+float hash12(vec2 p) { vec3 q = fract(vec3(p.xyx) * 0.1031); q += dot(q, q.yzx + 33.33); return fract((q.x + q.y) * q.z); }
+// value noise from the lattice texture: the smoothstep is put into the coordinate, the trilinear
+// filter does the eight-corner mix (same lattice values as hash13 around the origin)
+float vnoise3(vec3 p) {
+    vec3 i = floor(p); vec3 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    return texture(uNoise, (i + f + ${(0.5 + NOISE_N / 2).toFixed(1)}) / ${NOISE_N.toFixed(1)}).r;
+}
+float vnoise2(vec2 p) {
+    vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    return mix(mix(hash12(i), hash12(i + vec2(1, 0)), f.x), mix(hash12(i + vec2(0, 1)), hash12(i + vec2(1, 1)), f.x), f.y);
+}
+// three octaves, rotated between octaves so the lattice never lines up
+float fbm3(vec3 p) {
+    float s = 0.5 * vnoise3(p);
+    p = mat3(0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64) * p * 2.03;
+    s += 0.25 * vnoise3(p);
+    p = mat3(0.00, 0.80, 0.60, -0.80, 0.36, -0.48, -0.60, -0.48, 0.64) * p * 2.01;
+    s += 0.125 * vnoise3(p);
+    return s / 0.875;
+}
+float bump(float x) { float t = clamp(1.0 - x * x, 0.0, 1.0); return t * t; }
+float hgPhase(float mu, float g) { return 0.0795775 * (1.0 - g * g) / pow(1.0 + g * g - 2.0 * g * mu, 1.5); }
+float ign(vec2 px) { return fract(52.9829189 * fract(dot(px, vec2(0.06711056, 0.00583715)))); }
+`;
+const COMMON_UNIFORMS_GLSL = /* glsl */ `
+uniform float uTime, uWindStrength, uTurb, uTurbPhase, uSpeed, uFollow, uViewH;
+uniform vec2 uWind, uWindDir;
+uniform vec3 uVolume, uCam;
+uniform vec3 uSunDir, uSunColor, uSkyAmbient, uColor, uShadeColor, uPointerColor;
+uniform float uIntensity, uOpacity;
+uniform vec3 uPointer, uPointerVel;
+uniform float uPointerActive, uPointerMode, uPointerStrength, uPointerRadius;
+`;
+const FOG_V = /* glsl */ `
+#ifdef USE_FOG
+varying float vFogDepth;
+#endif
+`;
+const FOG_F = /* glsl */ `
+#ifdef USE_FOG
+uniform vec3 fogColor;
+varying float vFogDepth;
+#ifdef FOG_EXP2
+uniform float fogDensity;
+#else
+uniform float fogNear;
+uniform float fogFar;
+#endif
+#endif
+`;
+const FOG_APPLY = /* glsl */ `
+#ifdef USE_FOG
+#ifdef FOG_EXP2
+    float fogFactor = 1.0 - exp(-fogDensity * fogDensity * vFogDepth * vFogDepth);
+#else
+    float fogFactor = smoothstep(fogNear, fogFar, vFogDepth);
+#endif
+    gl_FragColor.rgb = mix(gl_FragColor.rgb, fogColor * gl_FragColor.a, fogFactor);
+#endif
+`;
+/** Soft walls of the volume (metres); the ground is hard. */
+const VOLUME_GLSL = /* glsl */ `
+float volumeFade(vec3 p, float side, float top) {
+    float a = step(0.0, p.y) * (1.0 - smoothstep(uVolume.y - top, uVolume.y, p.y));
+    if (uFollow < 0.5) {
+        vec2 e = 0.5 * uVolume.xz - abs(p.xz);
+        a *= smoothstep(0.0, side, e.x) * smoothstep(0.0, side, e.y);
+    }
+    return a;
+}
+`;
+const SLICE_VERT = /* glsl */ `
+${COMMON_UNIFORMS_GLSL}
+uniform float uSliceNear, uSliceFar, uSliceCount;
+uniform vec4 uSliceRect;
+uniform mat4 uCamToLocal;
+attribute vec2 aCorner;
+attribute float aSlice;
+varying vec3 vLocal;
+varying vec3 vRay;
+varying float vDz, vSlice;
+${FOG_V}
+void main() {
+    // slice 0 is the farthest: instances draw back to front
+    float k = log(uSliceFar / uSliceNear);
+    float t0 = 1.0 - (aSlice + 1.0) / uSliceCount;
+    float t1 = 1.0 - aSlice / uSliceCount;
+    float z0 = uSliceNear * exp(k * t0);
+    float z1 = uSliceNear * exp(k * t1);
+    float z = 0.5 * (z0 + z1);
+    vDz = z1 - z0;
+    // the quad spans the volume's bounds on screen (NDC), not the screen
+    vec2 ndc = mix(uSliceRect.xy, uSliceRect.zw, aCorner * 0.5 + 0.5);
+    vec3 view = vec3((ndc.x + projectionMatrix[2][0]) * z / projectionMatrix[0][0], (ndc.y + projectionMatrix[2][1]) * z / projectionMatrix[1][1], -z);
+    vSlice = aSlice;
+    gl_Position = projectionMatrix * vec4(view, 1.0);
+    vLocal = (uCamToLocal * vec4(view, 1.0)).xyz * uVolume;
+    vRay = vLocal - uCam;
+#ifdef USE_FOG
+    vFogDepth = z;
+#endif
+}
+`;
+/**
+ * Wraps an object's `vec4 sliceSample(vec3 p, vec3 rd, float dz)` (premultiplied rgb, alpha).
+ *
+ * The canvas stores display (non-linear) values. By default the premultiplied colour goes through
+ * the output transform as it is, which makes a thin layer brighter than its share: the look then
+ * depends on how thin the slabs are (the first objects were tuned by eye under it — leave them).
+ * `straight` converts the colour first and weights it by alpha after, so a medium looks the same
+ * at every slice count, density and quality; new objects use it.
+ */
+function sliceFrag(body, straight) {
+    return /* glsl */ `
+${COMMON_UNIFORMS_GLSL}
+uniform float uSkip;
+varying vec3 vLocal;
+varying vec3 vRay;
+varying float vDz, vSlice;
+${FOG_F}
+${NOISE_GLSL}
+${VOLUME_GLSL}
+${body}
+void main() {
+    // dense displays: neighbouring pixels take turns over the slices (see updateCommon)
+    if (uSkip > 1.5) {
+        vec2 px = mod(floor(gl_FragCoord.xy), 2.0);
+        float turn = uSkip > 3.0 ? mod(px.x * 2.0 + px.y * 3.0, 4.0) : mod(px.x + px.y, 2.0);
+        if (mod(vSlice + turn, uSkip) > 0.5) discard;
+    }
+    vec3 rd = normalize(vRay);
+    // dithered depth inside the slab: banding becomes grain
+    vec3 p = vLocal + rd * (ign(gl_FragCoord.xy) - 0.5) * 0.6 * vDz;
+    if (p.y < 0.0 || p.y > uVolume.y) discard;
+    if (uFollow < 0.5 && (abs(p.x) > 0.5 * uVolume.x || abs(p.z) > 0.5 * uVolume.z)) discard;
+    vec4 s = sliceSample(p, rd, vDz);
+    s *= uOpacity;
+    if (s.a < 0.0015 && dot(s.rgb, vec3(1.0)) < 0.002) discard;
+    gl_FragColor = ${straight ? 'vec4(s.rgb / max(s.a, 1e-5) * uIntensity, 1.0)' : 'vec4(s.rgb * uIntensity, s.a)'};
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>${straight ? '\n    gl_FragColor = vec4(gl_FragColor.rgb * s.a, s.a);' : ''}
+${FOG_APPLY}
+    // A pixel that skipped slabs stands for them: it lays down what 2 or 4 copies of its own thin
+    // layer would have composited to (colour c (1 + t + ...), transmittance t^n), so the volume
+    // keeps exactly the brightness and opacity it has when every pixel takes every slice.
+    if (uSkip > 1.5) {
+        float t = 1.0 - gl_FragColor.a;
+        float t2 = t * t;
+        gl_FragColor = uSkip > 3.0 ? vec4(gl_FragColor.rgb * (1.0 + t) * (1.0 + t2), 1.0 - t2 * t2) : vec4(gl_FragColor.rgb * (1.0 + t), 1.0 - t2);
+    }
+}
+`;
+}
+function premulMaterial(u, vertexShader, fragmentShader, additive) {
+    return new THREE.ShaderMaterial({
+        uniforms: Object.assign({}, THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u),
+        vertexShader, fragmentShader,
+        transparent: true, depthWrite: false, fog: true,
+        blending: THREE.CustomBlending,
+        blendSrc: THREE.OneFactor, blendDst: additive ? THREE.OneFactor : THREE.OneMinusSrcAlphaFactor,
+        blendSrcAlpha: THREE.OneFactor, blendDstAlpha: THREE.OneMinusSrcAlphaFactor,
+        premultipliedAlpha: true,
+    });
+}
+/** Bounds-only `position`: the unit volume box, so Box3.expandByObject centres the gizmo on it. */
+function boxPositions(geo) {
+    geo.setAttribute('position', new THREE.Float32BufferAttribute([-0.5, 0, -0.5, 0.5, 0, 0.5, 0.5, 1, -0.5, -0.5, 1, 0.5], 3));
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0.5, 0), 0.87);
+}
+/**
+ * One instanced draw of `count` view-aligned slices. `interleave` (1, 2 or 4, default 4) is the most
+ * sets of slices neighbouring pixels may take turns over on a dense display; 1 = every pixel, every slice.
+ */
+function buildSlices(u, fragmentShader, count, interleave) {
+    const geo = new THREE.InstancedBufferGeometry();
+    boxPositions(geo);
+    geo.setAttribute('aCorner', new THREE.Float32BufferAttribute([-1, -1, 1, -1, 1, 1, -1, 1], 2));
+    geo.setIndex([0, 1, 2, 0, 2, 3]);
+    const idx = new Float32Array(count);
+    for (let i = 0; i < count; i++)
+        idx[i] = i;
+    geo.setAttribute('aSlice', new THREE.InstancedBufferAttribute(idx, 1));
+    geo.instanceCount = count;
+    u.uSliceCount.value = count;
+    u.uSkipMax.value = interleave || 4;
+    const mat = premulMaterial(u, SLICE_VERT, fragmentShader, false);
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.raycast = function () { };
+    return mesh;
+}
+/** Instanced quad geometry with per-instance seeds (two vec4s). */
+function seededQuads(count, rnd) {
+    const geo = new THREE.InstancedBufferGeometry();
+    boxPositions(geo);
+    geo.setAttribute('aCorner', new THREE.Float32BufferAttribute([-1, -1, 1, -1, 1, 1, -1, 1], 2));
+    geo.setIndex([0, 1, 2, 0, 2, 3]);
+    const a = new Float32Array(count * 4), b = new Float32Array(count * 4);
+    for (let i = 0; i < count * 4; i++) {
+        a[i] = rnd();
+        b[i] = rnd();
+    }
+    geo.setAttribute('aSeedA', new THREE.InstancedBufferAttribute(a, 4));
+    geo.setAttribute('aSeedB', new THREE.InstancedBufferAttribute(b, 4));
+    geo.instanceCount = count;
+    return geo;
+}
+/** A streak quad between two view-space points, at least 1 px wide (energy kept by alpha). */
+const STREAK_GLSL = /* glsl */ `
+// returns the clip position of this corner; writes the coverage factor into cover
+vec4 streakCorner(vec4 headV, vec4 tailV, vec2 corner, float widthM, out float cover, out float lenPx) {
+    vec4 h = projectionMatrix * headV;
+    vec4 t = projectionMatrix * tailV;
+    vec2 hs = h.xy / h.w, ts = t.xy / t.w;
+    vec2 scr = vec2(uViewH * projectionMatrix[1][1] / projectionMatrix[0][0], uViewH) * 0.5;
+    vec2 d = (hs - ts) * scr;
+    lenPx = length(d);
+    vec2 dir = lenPx > 1e-4 ? d / lenPx : vec2(0.0, 1.0);
+    vec2 nrm = vec2(dir.y, -dir.x);   // (nrm, dir) right-handed: the quad stays front-facing
+    float wPx = widthM * uViewH * projectionMatrix[1][1] * 0.5 / max(-headV.z, 1e-3);
+    float w = max(wPx, 1.0);
+    cover = wPx / w;
+    vec4 base = corner.y > 0.0 ? h : t;
+    vec2 off = nrm * corner.x * 0.5 * w / scr;
+    // extend half a pixel past both ends so short streaks stay round
+    off += dir * corner.y * 0.5 / scr;
+    return vec4(base.xy + off * base.w, base.zw);
+}
+`;
+// ---------------------------------------------------------------------------- rainbow
+// Rainbow — environment object (lab module). Shared core: ./common.mjs.
+// One rainbow and nothing else: no rain curtain, no shafts, no mist (the shower is the `mist` object).
+// Construction:
+//   optics    the scattering angle between the view ray and the antisolar point is compared with the
+//             Descartes minimum-deviation angle of light refracted into a water drop and reflected k
+//             times: cos i = sqrt((n² − 1)/(k² + 2k)), D = 2(i − r) + k(π − 2r). k = 1 gives the
+//             primary bow (~42°), k = 2 the optional secondary (~51°, colours reversed).
+//             n(λ) = 1.3240 + 3046/λ² (water, λ in nm) — dispersion spreads the colours.
+//   profile   around each bow the intensity follows the Airy function: Ai(−x)² on the bright side
+//             with its supernumerary fringes, a fast exponential fall on the dark side. The fringe
+//             scale is (λ / d)^(2/3), so small drops give wide, pale bows and at fog-drop sizes the
+//             colours overlap into a white fogbow; big drops wash the fringes out. The sun's disc
+//             (0.5°) smears every profile.
+//   colour    24 wavelengths 400–700 nm through a CIE 1931 fit, XYZ → linear sRGB.
+//   table     all of the above depends on the angle only, so it is evaluated on the CPU into a
+//             1-D texture (angle → colour) whenever dropSize or secondary change. A pixel costs one
+//             acos and one texture fetch instead of the whole spectral sum.
+//   where     the bow is seen through the object's volume as if it were filled with invisible fine
+//             drops: a half-ellipsoid standing on the ground, density 1 − s² (s = scaled radius), so
+//             its strength 1 − exp(−τ) builds with the depth looked through and falls smoothly to
+//             nothing at the silhouette. The integral along the view ray is a cubic — no samples.
+//   depth     the light is drawn on 12 shells around the eye, only inside the band of angles where
+//             the table is not black; each shell carries its slab's share e^(−τ before) − e^(−τ after).
+//             Every pixel is depth-tested at a dithered distance inside its slab, so a scene object
+//             hides exactly the share of the drops behind it and the slab edges turn into fine grain.
+//   blend     the bow is light, but added to a bright sky its colours would wash out to white, so
+//             it also covers what is behind it in proportion to its own brightness.
+//   follows   the sun read-only; below 0° or above ~42° elevation the bow is gone, as in nature.
+const catalog = {
+    key: 'rainbow',
+    name: 'Rainbow',
+    description: 'A single physical rainbow on its own: water dispersion and an Airy profile with supernumerary fringes, centred opposite the sun and seen through the object’s volume. The cursor sprays, clears or polarises it. Use for after-rain and hopeful scenes.',
+    tags: ['rainbow', 'optics', 'sky', 'weather', 'dispersion', 'interactive'],
+    structural: [],
+    pointerModes: ['spray', 'clear', 'polarizer'],
+    pointerLabels: ['Mist spray', 'Clearing', 'Polarising filter'],
+    volume: [240, 90, 240],
+    staging: { sky: '#6f8fb4', ground: '#556b4c', fog: 0.0012, sunEl: 18, sunAz: 15, inside: [[0, 1.7, 60], [0, 14, -40]], outside: [[0, 4, 210], [0, 25, 0]] },
+    pointerAhead: 30,
+};
+const SHELLS = 12; // depth slabs the bow's light is split over
+const SEGMENTS = 96; // sides of the band around the antisolar point
+const LUT_N = 1024; // texels of the angle → colour table
+const LUT_A = 0.05, LUT_B = 1.25; // its range, radians from the antisolar point (2.9°..71.6°)
+const DEPTH = 3.0; // optical depth scale: a ray through the middle of the volume has τ = 4
+function createUniforms() {
+    return Object.assign(createCommonUniforms(), {
+        uDrop: { value: 1 },
+        uSecondary: { value: 0 },
+        uLut: { value: null },
+        uLutRange: { value: new THREE.Vector2(LUT_A, LUT_B) },
+        uTheta: { value: new THREE.Vector4(0.6, 0.8, 0.8, 0.8) },
+        uShell: { value: new THREE.Vector3(1, 300, SHELLS) },
+        uAntiW: { value: new THREE.Vector3(0, 0, -1) },
+        uE1W: { value: new THREE.Vector3(1, 0, 0) },
+        uE2W: { value: new THREE.Vector3(0, 1, 0) },
+        uToLocal: { value: new THREE.Matrix3() },
+        uFilter: { value: new THREE.Vector3(1, 0, 0) },
+        uProj: { value: new THREE.Vector2(-1, -0.2) },
+    });
+}
+function applyConfig(u, c) {
+    applyCommonConfig(u, c, catalog.pointerModes);
+    if (c.dropSize !== undefined)
+        u.uDrop.value = c.dropSize;
+    if (c.secondary !== undefined)
+        u.uSecondary.value = c.secondary;
+}
+// ---------------------------------------------------------------- the bow's colour by angle (CPU)
+// Descartes angle (radians from the antisolar point) of the k-th order bow
+function bowAngle(n, k) {
+    const ci = Math.sqrt((n * n - 1) / (k * k + 2 * k));
+    const i = Math.acos(ci);
+    const r = Math.asin(Math.sin(i) / n);
+    const D = 2 * (i - r) + k * (Math.PI - 2 * r);
+    return Math.abs(k > 1.5 ? D - Math.PI : Math.PI - D);
+}
+// Airy profile, x > 0 on the bright side; damp = how far the fringes survive
+function airy(x, damp) {
+    if (x < 0)
+        return 0.126 * Math.exp(-1.33 * Math.pow(-x, 1.5));
+    const s = Math.sin(0.6667 * Math.pow(x, 1.5) + 0.785398);
+    const osc = 0.9 * s * s / (Math.PI * Math.sqrt(Math.max(x, 0.3)));
+    if (x < 1.02) {
+        const t = x / 1.02, h = t * t * (3 - 2 * t);
+        return 0.126 + (0.287 - 0.126) * h;
+    }
+    // past the main peak only the supernumerary fringes are kept, dying out with damp: the faint
+    // even glow that real drops return across the whole inside of the bow belongs to the shower
+    // (the mist object), not to a rainbow on its own
+    return osc * 0.92 * Math.exp(-(x - 1.02) * damp);
+}
+// CIE 1931 colour-matching fit (Wyman, Sloan, Shirley 2013)
+function cie(l, out) {
+    const g = (t) => Math.exp(-0.5 * t * t);
+    out[0] = 0.362 * g((l - 442.0) * (l < 442.0 ? 0.0624 : 0.0374)) + 1.056 * g((l - 599.8) * (l < 599.8 ? 0.0264 : 0.0323)) - 0.065 * g((l - 501.1) * (l < 501.1 ? 0.0490 : 0.0382));
+    out[1] = 0.821 * g((l - 568.8) * (l < 568.8 ? 0.0213 : 0.0247)) + 0.286 * g((l - 530.9) * (l < 530.9 ? 0.0613 : 0.0322));
+    out[2] = 1.217 * g((l - 437.0) * (l < 437.0 ? 0.0845 : 0.0278)) + 0.681 * g((l - 459.0) * (l < 459.0 ? 0.0385 : 0.0725));
+}
+const WAVES = 24;
+const SPECTRUM = (function () {
+    const rows = [], w = [0, 0, 0];
+    let whiteY = 0;
+    for (let j = 0; j < WAVES; j++) {
+        const l = 400 + 300 * (j + 0.5) / WAVES;
+        cie(l, w);
+        const n = 1.3240 + 3046.0 / (l * l);
+        rows.push({ l: l, x: w[0], y: w[1], z: w[2], a1: bowAngle(n, 1), a2: bowAngle(n, 2) });
+        whiteY += w[1];
+    }
+    return { rows: rows, whiteY: whiteY };
+})();
+/** Linear-sRGB colour of the bows at every angle of the table; returns the band of angles that is not black. */
+function bowTable(drop, secondary, rgb) {
+    const dmm = Math.max(drop, 0.03);
+    // how fast the supernumerary fringes die out: big drops flatten and wash them out; fog and drizzle
+    // come in mixed sizes, which leaves one or two
+    const damp = 0.55 + 1.6 * dmm + 0.75 * Math.exp(-dmm / 0.12);
+    const rows = SPECTRUM.rows;
+    const sc = new Float32Array(WAVES), en = new Float32Array(WAVES);
+    for (let j = 0; j < WAVES; j++) {
+        // Airy fringe scale (radians): (λ / d)^(2/3), smeared by the sun's disc
+        let s = Math.pow(rows[j].l * 1e-6 / dmm, 0.6667) * 1.05;
+        s = Math.sqrt(s * s + 0.0044 * 0.0044);
+        sc[j] = s;
+        // energy is conserved: a bow spread over a wider angle is proportionally fainter
+        en[j] = Math.min(1, 0.0075 / s);
+    }
+    let peak = 0;
+    for (let i = 0; i < LUT_N; i++) {
+        const theta = LUT_A + (LUT_B - LUT_A) * (i + 0.5) / LUT_N;
+        let X = 0, Y = 0, Z = 0;
+        for (let j = 0; j < WAVES; j++) {
+            const r = rows[j];
+            let p = airy((r.a1 - theta) / sc[j], damp);
+            if (secondary > 0)
+                p += airy((theta - r.a2) / sc[j], damp) * 0.43 * secondary;
+            p *= en[j];
+            X += r.x * p;
+            Y += r.y * p;
+            Z += r.z * p;
+        }
+        X /= SPECTRUM.whiteY;
+        Y /= SPECTRUM.whiteY;
+        Z /= SPECTRUM.whiteY;
+        const R = Math.max(3.2406 * X - 1.5372 * Y - 0.4986 * Z, 0);
+        const G = Math.max(-0.9689 * X + 1.8758 * Y + 0.0415 * Z, 0);
+        const B = Math.max(0.0557 * X - 0.2040 * Y + 1.0570 * Z, 0);
+        rgb[i * 3] = R;
+        rgb[i * 3 + 1] = G;
+        rgb[i * 3 + 2] = B;
+        peak = Math.max(peak, R, G, B);
+    }
+    // the band worth drawing: everything above 1.2 % of the brightest colour
+    let lo = LUT_N - 1, hi = 0;
+    const cut = 0.012 * peak;
+    for (let i = 0; i < LUT_N; i++) {
+        if (Math.max(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]) > cut) {
+            if (i < lo)
+                lo = i;
+            if (i > hi)
+                hi = i;
+        }
+    }
+    if (hi < lo) {
+        lo = 0;
+        hi = 1;
+    }
+    // with a secondary bow there is a dark gap between the two (Alexander's band): two bands, not one
+    let gapA = -1, gapB = -1, run = 0;
+    for (let i = lo; i <= hi; i++) {
+        if (Math.max(rgb[i * 3], rgb[i * 3 + 1], rgb[i * 3 + 2]) > cut)
+            run = 0;
+        else {
+            run++;
+            if (run > gapB - gapA) {
+                gapB = i;
+                gapA = i - run;
+            }
+        }
+    }
+    const at = (i) => LUT_A + (LUT_B - LUT_A) * (i + 0.5) / LUT_N;
+    const a0 = at(Math.max(lo - 2, 0)), a3 = at(Math.min(hi + 2, LUT_N - 1));
+    const split = gapB - gapA > 16; // wider than about 1°
+    return { peak: peak, theta: split ? [a0, at(gapA + 3), at(gapB - 2), a3] : [a0, a3, a3, a3] };
+}
+// brightness is set so the default bow (1 mm drops) peaks at 1
+let GAIN = 0;
+const BOW_VERT = /* glsl */ `
+${COMMON_UNIFORMS_GLSL}
+uniform vec3 uAntiW, uE1W, uE2W;
+uniform vec4 uTheta;           // inner / outer edge of the primary band, then of the secondary's
+uniform vec3 uShell;          // nearest radius, farthest radius, count
+attribute vec2 aBand;         // angle around the antisolar axis, which of the four edges
+attribute float aShell;
+varying vec3 vDirW, vDirV;
+varying vec2 vSlab;
+${FOG_V}
+float shellR(float k) { return uShell.x + (uShell.y - uShell.x) * pow(k / uShell.z, 1.5); }
+void main() {
+    // a band of directions around the antisolar point, on a shell around the eye
+    float th = aBand.y < 0.5 ? uTheta.x : aBand.y < 1.5 ? uTheta.y : aBand.y < 2.5 ? uTheta.z : uTheta.w;
+    vec3 dW = uAntiW * cos(th) + (uE1W * cos(aBand.x) + uE2W * sin(aBand.x)) * sin(th);
+    // instance 0 is the farthest shell: they draw back to front
+    float k = uShell.z - 1.0 - aShell;
+    float r0 = shellR(k), r1 = shellR(k + 1.0);
+    float rm = 0.5 * (r0 + r1);
+    vDirV = mat3(viewMatrix) * dW;
+    gl_Position = projectionMatrix * vec4(vDirV * rm, 1.0);
+    vDirW = dW;
+    vSlab = vec2(r0, r1);
+#ifdef USE_FOG
+    vFogDepth = rm;
+#endif
+}
+`;
+const BOW_FRAG = /* glsl */ `
+${COMMON_UNIFORMS_GLSL}
+uniform sampler2D uLut;
+uniform vec2 uLutRange;
+uniform mat3 uToLocal;
+uniform vec3 uFilter;
+uniform vec2 uProj;           // projectionMatrix[2][2], projectionMatrix[3][2]
+varying vec3 vDirW, vDirV;
+varying vec2 vSlab;
+${FOG_F}
+float bump(float x) { float t = clamp(1.0 - x * x, 0.0, 1.0); return t * t; }
+float ign(vec2 px) { return fract(52.9829189 * fract(dot(px, vec2(0.06711056, 0.00583715)))); }
+// linear light -> what the canvas stores (the renderer's tone mapping and output colour space)
+vec3 shown(vec3 lin) {
+#if defined( TONE_MAPPING )
+    lin = toneMapping(lin);
+#endif
+    return linearToOutputTexel(vec4(lin, 1.0)).rgb;
+}
+void main() {
+    vec3 d = normalize(uToLocal * vDirW);                     // the view ray, in the volume's own axes (metres)
+    vec3 anti = -uSunDir;
+    float th = acos(clamp(dot(d, anti), -1.0, 1.0));
+    vec3 bow = texture2D(uLut, vec2((th - uLutRange.x) / (uLutRange.y - uLutRange.x), 0.5)).rgb;
+    float top = max(bow.r, max(bow.g, bow.b));
+    if (top < 0.004) discard;
+
+    // Drops fill a half-ellipsoid standing on the ground, density 1 - s^2 (s = scaled radius).
+    // Along the ray that is disc/a - a x^2 around the chord's middle x = 0: its integral is a cubic.
+    vec3 A = vec3(0.5 * uVolume.x, uVolume.y, 0.5 * uVolume.z);
+    vec3 o1 = uCam / A, d1 = d / A;
+    float a = dot(d1, d1), b = dot(o1, d1), c = dot(o1, o1) - 1.0;
+    float disc = b * b - a * c;
+    float tauF = 0.0, dT = 0.0;
+    float ra = vSlab.x, rb = vSlab.y;                          // where this slab's drops are, along the ray
+    if (disc > 0.0) {
+        float sq = sqrt(disc), tm = -b / a;
+        float t0 = max(tm - sq / a, 0.0), t1 = tm + sq / a;
+        // the ground cuts the ellipsoid in half
+        if (d.y < -1e-5) t1 = min(t1, -uCam.y / d.y);
+        else if (uCam.y < 0.0) t0 = d.y > 1e-5 ? max(t0, -uCam.y / d.y) : t1;
+        if (t1 > t0) {
+            float x0 = t0 - tm;
+            float xa = clamp(vSlab.x, t0, t1) - tm, xb = clamp(vSlab.y, t0, t1) - tm;
+            float h = disc / a, k = ${DEPTH.toFixed(1)} * sqrt(a);
+            float F0 = x0 * h - a * x0 * x0 * x0 / 3.0;
+            float Fa = xa * h - a * xa * xa * xa / 3.0;
+            float Fb = xb * h - a * xb * xb * xb / 3.0;
+            tauF = k * (Fa - F0);       // drops in front of this slab
+            dT = k * (Fb - Fa);         // drops inside it
+            ra = xa + tm; rb = xb + tm;
+        }
+    }
+
+    float pol = 1.0, boost = 1.0;
+    vec3 tint = vec3(1.0);
+    if (uPointerMode > -0.5 && uPointerActive > 0.001) {
+        float S = uPointerStrength * uPointerActive;
+        if (uPointerMode > 1.5) {
+            // the cursor's polariser: bow light is ~96 % polarised along the bow's tangent
+            vec3 er = normalize(d - dot(d, anti) * anti);
+            vec3 et = cross(anti, er);
+            float cf = dot(et, uFilter);
+            pol = mix(1.0, 0.04 + 1.92 * cf * cf, clamp(S, 0.0, 1.0));
+        } else {
+            // a column around the line of sight to the cursor
+            vec3 P = uPointer * uVolume - uCam;
+            float tc = dot(P, d);
+            float q = sqrt(max(dot(P, P) - tc * tc, 0.0));
+            float bq = bump(q / max(uPointerRadius * 6.0, 0.5)) * step(0.0, tc);
+            if (uPointerMode < 0.5) {
+                // mist spray: fresh drops where the cursor is — a patch of bow even outside the volume,
+                // and a brighter, tinted stretch of the bow inside it
+                float sp = 2.5 * S * bq;
+                if (tc < vSlab.x) tauF += sp;
+                else if (tc < vSlab.y) { dT += sp; tint = mix(vec3(1.0), uPointerColor, sp / max(dT, 1e-4)); }
+                boost = 1.0 + 0.9 * min(S, 2.0) * bq;
+            } else {
+                // clearing: the drops are swept out of the column
+                float keep = 1.0 - clamp(S * bq, 0.0, 1.0);
+                tauF *= keep; dT *= keep;
+            }
+        }
+    }
+
+    // This slab's share of the bow: what the drops in it return, dimmed by the drops in front.
+    float g0 = 1.0 - exp(-tauF), g1 = 1.0 - exp(-tauF - dT);    // the bow built up before / after this slab
+    float w = g1 - g0;
+    float sunUp = smoothstep(-0.02, 0.06, uSunDir.y);
+    float gain = pol * sunUp * uOpacity;
+    if (w * gain * top < 0.0004) discard;
+    // The canvas blends in its own (non-linear) colour space, where twelve small lights add up to far
+    // more than one light of their sum. So each slab adds the step, in canvas values, from the bow
+    // built up in front of it to the bow including it: the steps sum to the right colour, and an
+    // object standing in the volume cuts the sum exactly where it stands.
+    vec3 light = bow * tint * uSunColor * uColor * (gain * uIntensity * boost);
+    vec3 col = shown(light * g1) - shown(light * g0);
+    // Added to a bright sky the colours would wash out to white, so the bow also covers what is behind
+    // it in proportion to its own brightness. Nearer slabs cover farther ones as well: each slab's
+    // step is raised by what the slabs in front of it take away.
+    float solid = 0.85 * pow(min(top, 1.0), 0.45) * gain;
+    col *= exp(solid * g0);
+    gl_FragColor = vec4(col, w * solid);
+#ifndef USE_LOGDEPTHBUF
+    // depth-test at a dithered distance inside the slab: an object standing in it hides its share
+    float zd = mix(ra, rb, ign(gl_FragCoord.xy)) * max(-normalize(vDirV).z, 1e-4);
+    gl_FragDepth = clamp(0.5 * (uProj.y - uProj.x * zd) / zd + 0.5, 0.0, 1.0);
+#endif
+${FOG_APPLY}
+}
+`;
+function build(u, c) {
+    // two bands (primary, secondary) of SEGMENTS quads around the antisolar axis, one instance per shell
+    const geo = new THREE.InstancedBufferGeometry();
+    const nv = (SEGMENTS + 1) * 4;
+    const band = new Float32Array(nv * 2), pos = new Float32Array(nv * 3);
+    // `position` is bounds only: the unit volume box, so Box3.expandByObject centres the gizmo on it
+    const box = [-0.5, 0, -0.5, 0.5, 0, 0.5, 0.5, 1, -0.5, -0.5, 1, 0.5];
+    for (let i = 0; i <= SEGMENTS; i++) {
+        for (let r = 0; r < 4; r++) {
+            const v = i * 4 + r;
+            band[v * 2] = (i / SEGMENTS) * Math.PI * 2;
+            band[v * 2 + 1] = r;
+            pos[v * 3] = box[(v % 4) * 3];
+            pos[v * 3 + 1] = box[(v % 4) * 3 + 1];
+            pos[v * 3 + 2] = box[(v % 4) * 3 + 2];
+        }
+    }
+    const idx = [];
+    for (let i = 0; i < SEGMENTS; i++)
+        for (let b = 0; b < 4; b += 2) {
+            const p = i * 4 + b;
+            idx.push(p, p + 1, p + 4, p + 1, p + 5, p + 4);
+        }
+    geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    geo.setAttribute('aBand', new THREE.BufferAttribute(band, 2));
+    geo.setIndex(idx);
+    const shells = new Float32Array(SHELLS);
+    for (let i = 0; i < SHELLS; i++)
+        shells[i] = i;
+    geo.setAttribute('aShell', new THREE.InstancedBufferAttribute(shells, 1));
+    geo.instanceCount = SHELLS;
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0.5, 0), 0.87);
+    // the angle -> colour table
+    const rgb = new Float32Array(LUT_N * 3), half = new Uint16Array(LUT_N * 4);
+    const lut = new THREE.DataTexture(half, LUT_N, 1, THREE.RGBAFormat, THREE.HalfFloatType);
+    lut.minFilter = THREE.LinearFilter;
+    lut.magFilter = THREE.LinearFilter;
+    lut.wrapS = THREE.ClampToEdgeWrapping;
+    lut.wrapT = THREE.ClampToEdgeWrapping;
+    lut.generateMipmaps = false;
+    u.uLut.value = lut;
+    if (!GAIN)
+        GAIN = 1 / bowTable(1, 0, rgb).peak;
+    let lutDrop = -1, lutSec = -1;
+    function refreshTable() {
+        lutDrop = u.uDrop.value;
+        lutSec = u.uSecondary.value;
+        const t = bowTable(lutDrop, lutSec, rgb);
+        for (let i = 0; i < LUT_N; i++) {
+            half[i * 4] = THREE.DataUtils.toHalfFloat(Math.min(rgb[i * 3] * GAIN, 60000));
+            half[i * 4 + 1] = THREE.DataUtils.toHalfFloat(Math.min(rgb[i * 3 + 1] * GAIN, 60000));
+            half[i * 4 + 2] = THREE.DataUtils.toHalfFloat(Math.min(rgb[i * 3 + 2] * GAIN, 60000));
+            half[i * 4 + 3] = 15360; // 1.0
+        }
+        lut.needsUpdate = true;
+        // the outer vertices of a band sit a little farther out, so its straight sides still enclose it
+        const out = (a) => Math.atan(Math.tan(a) / Math.cos(Math.PI / SEGMENTS));
+        u.uTheta.value.set(t.theta[0], out(t.theta[1]), t.theta[2], out(t.theta[3]));
+    }
+    const mat = premulMaterial(u, BOW_VERT, BOW_FRAG, false);
+    mat.side = THREE.DoubleSide; // the band is seen from inside its cone, whichever way it winds
+    const mesh = new THREE.Mesh(geo, mat);
+    mesh.frustumCulled = false;
+    mesh.raycast = function () { };
+    const object = new THREE.Group();
+    object.name = 'rainbow';
+    object.add(mesh);
+    const _x = new THREE.Vector3(), _y = new THREE.Vector3(), _q = new THREE.Quaternion(), _m = new THREE.Matrix4();
+    const _up = new THREE.Vector3(0, 1, 0), _k = new THREE.Vector3();
+    return {
+        object,
+        materials: [mat],
+        apply: function (cfg) { applyConfig(u, cfg); },
+        update: function (dt, camera, viewH, sunWorld, dpr) {
+            updateCommon(u, object, camera, dt, viewH, sunWorld, dpr);
+            // the uniforms are shared by every build of this object (React builds twice in StrictMode):
+            // make sure the table bound is this build's, and filled
+            if (u.uLut.value !== lut) {
+                u.uLut.value = lut;
+                lutDrop = -1;
+            }
+            if (u.uDrop.value !== lutDrop || u.uSecondary.value !== lutSec)
+                refreshTable();
+            // the bow's frame in the world: the antisolar axis and two directions across it
+            object.getWorldQuaternion(_q);
+            const anti = u.uAntiW.value.copy(u.uSunDir.value).applyQuaternion(_q).negate().normalize();
+            const e1 = u.uE1W.value.crossVectors(anti, _up);
+            if (e1.lengthSq() < 1e-8)
+                e1.set(1, 0, 0);
+            e1.normalize();
+            u.uE2W.value.crossVectors(anti, e1);
+            u.uToLocal.value.setFromMatrix4(_m.makeRotationFromQuaternion(_q.invert()));
+            // shells from where the volume starts in front of the eye to its far corner
+            const C = u.uCam.value, V = u.uVolume.value;
+            const hx = V.x / 2, hz = V.z / 2;
+            const near = Math.hypot(Math.max(Math.abs(C.x) - hx, 0), Math.max(-C.y, C.y - V.y, 0), Math.max(Math.abs(C.z) - hz, 0));
+            let far = 0;
+            for (let i = 0; i < 8; i++)
+                far = Math.max(far, _k.set(i & 1 ? hx : -hx, i & 2 ? V.y : 0, i & 4 ? hz : -hz).distanceTo(C));
+            const camFar = camera.far !== undefined ? camera.far : 2000;
+            const n = Math.max(camera.near !== undefined ? camera.near * 2 : 0.2, 0.3, near);
+            u.uShell.value.set(n, Math.max(n * 1.5, Math.min(far, camFar * 0.98)), SHELLS);
+            u.uProj.value.set(camera.projectionMatrix.elements[10], camera.projectionMatrix.elements[14]);
+            // polariser axis: the cursor's angle around the screen centre, in object space (_q is inverted)
+            const P = u.uPointer.value;
+            _x.setFromMatrixColumn(camera.matrixWorld, 0).applyQuaternion(_q);
+            _y.setFromMatrixColumn(camera.matrixWorld, 1).applyQuaternion(_q);
+            const dx = P.x * V.x - C.x, dy = P.y * V.y - C.y, dzz = P.z * V.z - C.z;
+            const sx = dx * _x.x + dy * _x.y + dzz * _x.z, sy = dx * _y.x + dy * _y.y + dzz * _y.z;
+            const ang = Math.atan2(sy, sx);
+            u.uFilter.value.copy(_x).multiplyScalar(Math.cos(ang)).addScaledVector(_y, Math.sin(ang)).normalize();
+        },
+        dispose: function () { geo.dispose(); mat.dispose(); lut.dispose(); },
+    };
+}
+// =============================================================================
+// Component
+// =============================================================================
+const DEFAULTS = DEFAULT_ENVIRONMENT_OBJECTS.rainbow;
+/** Knobs that rebuild the object: never live, they change once, on commit. */
+const STRUCTURAL = [];
+/** Knobs a keyframe or pointer binding may drive per frame — exactly what applyConfig pushes. */
+const ANIMATABLE = new Set(ENVIRONMENT_OBJECTS_ANIMATABLE.rainbow.map((p) => p.value));
+/** The scene's sky fill is brighter than the medium's own ambient term expects. */
+const SKY_FILL = 0.5;
+/**
+ * A single physical rainbow on its own: water dispersion and an Airy profile with supernumerary fringes, centred opposite the sun and seen through the object’s volume. The cursor sprays, clears or polarises it. Use for after-rain and hopeful scenes.
+ *
+ * The volume is the parent's transform: x / z span its scale, y rises from its origin to scale.y.
+ */
+const Rainbow = ({ config, id, keyframes, mouseMove, onObjectReady, onObjectDispose }) => {
+    const rootRef = useRef(null);
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const cfg = useMemo(() => withConfigDefaults(DEFAULTS, config), [config]);
+    // uniforms outlive rebuilds, so phases and keyframes survive a structural change
+    const uniforms = useMemo(() => createUniforms(), []);
+    const instance = useMemo(() => build(uniforms, cfg), [uniforms]); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => { applyConfig(uniforms, cfg); }, [uniforms, cfg]);
+    const push = useCallback((merged) => { applyConfig(uniforms, merged); }, [uniforms]);
+    useConfigDriver({ rootRef, id, family: 'environment', base: cfg, structural: STRUCTURAL, allowed: ANIMATABLE, keyframes, mouseMove, push });
+    const pointer = usePointerField();
+    // the scene's sun, read-only: the same one the clouds, the water and the key light use
+    const sun = useCloudSun();
+    const anchor = useMemo(() => new THREE.Vector3(), []);
+    const buffer = useMemo(() => new THREE.Vector2(), []);
+    useFrame((state, delta) => {
+        const dt = Math.min(delta, 0.1);
+        const s = sun.update();
+        uniforms.uSunColor.value.copy(s.color);
+        uniforms.uSkyAmbient.value.copy(s.skyAmbient).multiplyScalar(SKY_FILL);
+        state.gl.getDrawingBufferSize(buffer);
+        instance.update(dt, state.camera, buffer.y, s.direction, state.viewport.dpr);
+        stepPointerField(uniforms, pointer, state.camera, instance.object, 1, dt, pointerAnchor(instance.object, state.camera, uniforms, anchor, 30));
+    });
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default Rainbow;