@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/projector/projectorCore.js

@@ -0,0 +1,545 @@
+// Generated from Claude outputs/lights-lab/projector.mjs (the approved lab module) by
+// emit_object.mjs — edit there and regenerate.
+//
+// =============================================================================
+// projector — a stadium floodlight bank (lab module, light family)
+// =============================================================================
+//
+// One real THREE.SpotLight at the bank centre does the lighting; at arena throw
+// a bank of heads reads as one source. Everything else is the fixture and what
+// the eye sees of the light:
+//
+//  - Pool: an asymmetric flood. The optic is a rectangle in tangent space
+//    (horizontal half-angle `spread`, vertical = spread * aspect), so the pool on
+//    the pitch is a rectangle. Drawn as a soft rectangular mask on SpotLight.map;
+//    the spot's cone is the circle through the rectangle's corners.
+//  - Source: the fixture is self-lit and overexposed, like a stadium head seen
+//    at night. Every LED TIR lens blazes from anywhere in front and fills harder
+//    when the eye stands inside the beam (the eye's position in each head's beam
+//    rectangle drives it); a tight glow hugs each head. No haze in the air: the
+//    light is judged by what it does to the scene.
+//  - Lamp: 'led' is instant (fade = warmup) and can run show modes (chase,
+//    strobe, breathe). 'metalHalide' strikes (blue-white arc flashes), comes up
+//    dim and mercury-violet, warms to its colour over `warmup`; switched off it
+//    leaves an ember and refuses to restrike until it has cooled (`restrike`).
+//    Heads come on one by one in a fixed order, `stagger` apart.
+//
+// Internal only: heads tilt in their yokes (articulation). Pan, position and the
+// mast are the parent transform / the user's own meshes.
+//
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { DEFAULT_LIGHTS } from '@3driseai/3drise-core';
+import { kelvinToColor } from '../lightBulb/kelvin.js';
+/** The defaults live in core (DEFAULT_LIGHTS.projector); this is that table. */
+export const DEFAULTS = DEFAULT_LIGHTS.projector;
+export const STRUCTURAL = ['lamp', 'columns', 'rows', 'aspect', 'edgeSoftness'];
+// Head dimensions (metres, object space). A 1–1.5 kW LED flood head.
+const HW = 0.62, HH = 0.44, HD = 0.11;
+const GAP_X = 0.1, GAP_Y = 0.2;
+const MAX_HEADS = 24;
+const LENS_GRID = [7, 5];
+const MERCURY = new THREE.Color(0.55, 0.62, 1.0);
+const ARC = new THREE.Color(0.8, 0.88, 1.0);
+const EMBER = new THREE.Color(1.0, 0.36, 0.08);
+const clamp = (v, a, b) => Math.min(Math.max(v, a), b);
+const num = (v, f) => (typeof v === 'number' && isFinite(v) ? v : f);
+const smooth = (a, b, x) => { const t = clamp((x - a) / (b - a), 0, 1); return t * t * (3 - 2 * t); };
+const hash = (n) => { const s = Math.sin(n * 127.1 + 311.7) * 43758.5453; return s - Math.floor(s); };
+const noise1 = (x) => { const i = Math.floor(x), f = x - i, u = f * f * (3 - 2 * f); return hash(i) * (1 - u) + hash(i + 1) * u; };
+// -----------------------------------------------------------------------------
+// Geometry
+// -----------------------------------------------------------------------------
+/** One head's housing: body, back fins, bezel, visor. Lens face at +Z. */
+function headGeometry() {
+    const parts = [];
+    const body = new THREE.BoxGeometry(HW, HH, HD);
+    parts.push(body);
+    // Cast-aluminium heat-sink fins on the back, vertical.
+    const fins = 11;
+    for (let i = 0; i < fins; i++) {
+        const f = new THREE.BoxGeometry(0.012, HH * 0.86, 0.075);
+        f.translate(-HW * 0.44 + (i / (fins - 1)) * HW * 0.88, 0, -HD / 2 - 0.037);
+        parts.push(f);
+    }
+    // Bezel frame proud of the lens.
+    const bz = 0.022, bd = 0.025;
+    for (const [w, h, x, y] of [[HW, bz, 0, HH / 2 - bz / 2], [HW, bz, 0, -HH / 2 + bz / 2], [bz, HH, HW / 2 - bz / 2, 0], [bz, HH, -HW / 2 + bz / 2, 0]]) {
+        const b = new THREE.BoxGeometry(w, h, bd);
+        b.translate(x, y, HD / 2 + bd / 2 - 0.004);
+        parts.push(b);
+    }
+    // Glare visor over the top, angled down at the front.
+    const visor = new THREE.BoxGeometry(HW * 1.02, 0.008, 0.16);
+    visor.translate(0, 0, 0.08);
+    visor.rotateX(0.18);
+    visor.translate(0, HH / 2 + 0.006, HD / 2 - 0.02);
+    parts.push(visor);
+    const g = mergeGeometries(parts.map((p) => p.toNonIndexed()));
+    parts.forEach((p) => p.dispose());
+    return g;
+}
+/** Yoke: a U-bracket around the head, pivoting on the head's horizontal axis. */
+function yokeGeometry() {
+    const parts = [];
+    for (const s of [-1, 1]) {
+        const arm = new THREE.BoxGeometry(0.018, 0.09, 0.32);
+        arm.translate(s * (HW / 2 + 0.03), 0, -0.13);
+        parts.push(arm);
+        const hub = new THREE.CylinderGeometry(0.035, 0.035, 0.03, 16);
+        hub.rotateZ(Math.PI / 2);
+        hub.translate(s * (HW / 2 + 0.03), 0, 0);
+        parts.push(hub);
+    }
+    const back = new THREE.BoxGeometry(HW + 0.08, 0.06, 0.018);
+    back.translate(0, 0, -0.29);
+    parts.push(back);
+    const g = mergeGeometries(parts.map((p) => p.toNonIndexed()));
+    parts.forEach((p) => p.dispose());
+    return g;
+}
+function bankLayout(cols, rows) {
+    const out = [];
+    const sx = HW + GAP_X + 0.06, sy = HH + GAP_Y;
+    for (let r = 0; r < rows; r++)
+        for (let c = 0; c < cols; c++)
+            out.push(new THREE.Vector3((c - (cols - 1) / 2) * sx, ((rows - 1) / 2 - r) * sy, 0));
+    return out;
+}
+// -----------------------------------------------------------------------------
+// Pool mask (SpotLight.map)
+// -----------------------------------------------------------------------------
+/**
+ * The spot's projection square spans ±tan(angle); the optic's rectangle spans
+ * ±tx, ±ty inside it. angle is set from the rectangle's corner (×1.04), so the
+ * rectangle's share of the square depends only on aspect — `spread` can then be
+ * animated without redrawing the mask.
+ */
+export const CORNER = 1.04;
+function poolMask(aspect, soft) {
+    const N = 128;
+    const data = new Uint8Array(N * N * 4);
+    const diag = Math.sqrt(1 + aspect * aspect) * CORNER;
+    const rx = 1 / diag, ry = aspect / diag;
+    const s = 0.05 + soft * 0.6;
+    for (let j = 0; j < N; j++)
+        for (let i = 0; i < N; i++) {
+            const x = Math.abs((i + 0.5) / N * 2 - 1) / rx, y = Math.abs((j + 0.5) / N * 2 - 1) / ry;
+            // soft rectangle with a hot centre — a flood optic is not a flat field
+            const e = (1 - smooth(1 - s, 1, x)) * (1 - smooth(1 - s, 1, y));
+            const hot = 1 - 0.3 * Math.min(x * x * 0.6 + y * y * 0.6, 1);
+            const v = Math.round(clamp(e * hot, 0, 1) * 255);
+            const k = (j * N + i) * 4;
+            data[k] = data[k + 1] = data[k + 2] = v;
+            data[k + 3] = 255;
+        }
+    const tex = new THREE.DataTexture(data, N, N, THREE.RGBAFormat);
+    tex.colorSpace = THREE.SRGBColorSpace;
+    tex.magFilter = THREE.LinearFilter;
+    tex.minFilter = THREE.LinearFilter;
+    tex.needsUpdate = true;
+    return tex;
+}
+// -----------------------------------------------------------------------------
+// Shaders
+// -----------------------------------------------------------------------------
+const LENS_VERT = /* glsl */ `
+attribute vec3 aCol;
+attribute float aGlare;
+varying vec2 vUv;
+varying vec3 vCol;
+varying float vGlare;
+void main() {
+    vUv = uv; vCol = aCol; vGlare = aGlare;
+    gl_Position = projectionMatrix * modelViewMatrix * instanceMatrix * vec4(position, 1.0);
+}`;
+// LED: a grid of TIR lenses, the die always visible, the whole lens filling
+// with light as the eye moves into the beam. Metal halide: a faceted reflector
+// around a horizontal arc tube; the facets light up toward the beam axis.
+const LENS_FRAG = /* glsl */ `
+uniform float uLamp;
+uniform vec2 uGrid;
+uniform float uAspect;
+varying vec2 vUv;
+varying vec3 vCol;
+varying float vGlare;
+float lineAA(float d, float w) { float fw = fwidth(d) + 1e-5; return 1.0 - smoothstep(w - fw, w + fw, d); }
+void main() {
+    vec3 glass = vec3(0.018, 0.021, 0.026);
+    vec3 col;
+        if (uLamp < 0.5) {
+        vec2 g = vUv * uGrid;
+        vec2 c = fract(g) - 0.5;
+        float r = length(c) * 2.0;
+        float fw = fwidth(r) + 1e-5;
+        float lens = 1.0 - smoothstep(0.86 - fw, 0.86 + fw, r);
+        float rim = lineAA(abs(r - 0.88), 0.03);
+        float die = max(1.0 - r / 0.2, 0.0); die *= die;
+        float fill = lens * (1.0 - 0.45 * r * r);
+        col = glass * (0.7 + 0.5 * lens) + vec3(0.05) * rim;
+        col += vCol * (die * 4.0 + fill * (0.55 + 1.4 * vGlare));
+    } else {
+        vec2 p = (vUv - 0.5) * vec2(uAspect, 1.0);
+        float r = length(p);
+        float a = atan(p.y, p.x);
+        float facet = 0.5 + 0.5 * cos(a * 28.0) * cos(r * 60.0);
+        float bowl = 1.0 - smoothstep(0.4, 0.46, r);
+        vec2 q = p; q.x = max(abs(q.x) - 0.09, 0.0);
+        float d = length(q);
+        float arc = 1.0 / (1.0 + (d * d) / 0.00006);
+        float tube = 1.0 - smoothstep(0.012, 0.018, d);
+        col = glass * (0.6 + 0.6 * bowl * facet) + vec3(0.04) * tube;
+        col += vCol * (arc * 5.0 + bowl * (0.35 + 0.65 * facet) * (0.4 + 1.2 * vGlare) * (1.0 - 0.6 * r));
+    }
+    gl_FragColor = vec4(col, 1.0);
+    #include <colorspace_fragment>
+}`;
+// Glow: one camera-facing quad per head, hugging the lens — the source reads as
+// a hot, overexposed panel. It keeps a floor size in metres near the bank and an
+// angular size from afar (glow is in the eye), grows a little and gains a short
+// cross (diffraction off the rectangular lens grid) as the eye moves into the
+// beam, and is gone from behind. Only the core and the thin cross pass 1.0.
+const GLOW_VERT = /* glsl */ `
+attribute vec3 aCol;
+attribute float aGlare;
+uniform vec3 uRightW;
+varying vec2 vP;
+varying vec2 vDir;
+varying vec3 vCol;
+varying float vGlare;
+void main() {
+    vCol = aCol; vGlare = aGlare;
+    vec4 c = modelViewMatrix * instanceMatrix * vec4(0.0, 0.0, 0.0, 1.0);
+    float scale = length(modelMatrix[0].xyz);
+    float size = max(${(0.62 * 1.3).toFixed(3)} * scale, -c.z * 0.025) * (0.7 + 1.1 * aGlare);
+    c.xyz += normalize(-c.xyz) * 0.3 * scale; // in front of the housing
+    vec2 d = (viewMatrix * vec4(uRightW, 0.0)).xy;
+    vDir = length(d) > 1e-4 ? normalize(d) : vec2(1.0, 0.0);
+    vP = position.xy;
+    c.xy += position.xy * size;
+    gl_Position = projectionMatrix * c;
+}`;
+const GLOW_FRAG = /* glsl */ `
+uniform float uStrength;
+varying vec2 vP;
+varying vec2 vDir;
+varying vec3 vCol;
+varying float vGlare;
+void main() {
+    float r = length(vP);
+    float along = dot(vP, vDir);
+    float across = dot(vP, vec2(-vDir.y, vDir.x));
+    float core = 1.0 / (1.0 + r * r * 220.0);
+    float veil = max(1.0 - r, 0.0); veil *= veil * veil * veil;
+    float sx = max(1.0 - abs(along), 0.0); sx = sx * sx / (1.0 + across * across * 9000.0);
+    float sy = max(1.0 - abs(across), 0.0); sy = sy * sy / (1.0 + along * along * 9000.0);
+    float k = core * (0.55 + 0.8 * vGlare) + veil * (0.3 + 0.4 * vGlare) + (sx + 0.6 * sy) * vGlare * 0.8;
+    k *= 1.0 - smoothstep(0.2, 1.0, r); // fades out inside the quad, no square edge
+    vec3 col = vCol * k * uStrength;
+    if (max(max(col.r, col.g), col.b) < 0.002) discard;
+    gl_FragColor = vec4(col, 1.0);
+    #include <colorspace_fragment>
+}`;
+// -----------------------------------------------------------------------------
+// Build
+// -----------------------------------------------------------------------------
+const KEY_OF = (c) => [c.lamp, c.columns, c.rows, c.aspect, c.edgeSoftness].join(':');
+export function createProjector(cfg0) {
+    const root = new THREE.Group();
+    root.name = 'projector';
+    const light = new THREE.SpotLight(0xffffff, num(cfg0.intensity, DEFAULTS.intensity), num(cfg0.distance, 0), 0.5, 0, num(cfg0.decay, 1));
+    const target = new THREE.Object3D();
+    root.add(light, target);
+    light.target = target;
+    light.shadow.camera.near = 0.5;
+    const housingMat = new THREE.MeshStandardMaterial({ color: cfg0.housingColor ?? DEFAULTS.housingColor, metalness: 0.55, roughness: 0.5 });
+    const frameMat = new THREE.MeshStandardMaterial({ color: '#3a3f45', metalness: 0.6, roughness: 0.45 });
+    const lensMat = new THREE.ShaderMaterial({
+        vertexShader: LENS_VERT, fragmentShader: LENS_FRAG,
+        uniforms: { uLamp: { value: 0 }, uGrid: { value: new THREE.Vector2(LENS_GRID[0], LENS_GRID[1]) }, uAspect: { value: HW / HH } },
+    });
+    const glowMat = new THREE.ShaderMaterial({
+        vertexShader: GLOW_VERT, fragmentShader: GLOW_FRAG,
+        uniforms: { uRightW: { value: new THREE.Vector3(1, 0, 0) }, uStrength: { value: 1 } },
+        transparent: true, depthWrite: false, blending: THREE.AdditiveBlending,
+    });
+    const geo = { head: headGeometry(), yoke: yokeGeometry(), lens: new THREE.PlaneGeometry(HW - 0.05, HH - 0.05), glow: new THREE.PlaneGeometry(2, 2) };
+    let fixture = null; // rebuilt on structural change
+    let mask = null;
+    let key = '';
+    const heads = [];
+    const state = { on: !!(cfg0.on ?? true), written: NaN, base: num(cfg0.intensity, DEFAULTS.intensity), showPhase: 0, time: 0, seed: 17.3 };
+    function disposeFixture() {
+        if (!fixture)
+            return;
+        root.remove(fixture.group);
+        fixture.housing.dispose();
+        fixture.yokes.dispose();
+        fixture.lens.dispose();
+        fixture.glow.dispose();
+        fixture.lens.geometry.dispose();
+        fixture.glow.geometry.dispose();
+        fixture.crossbars.geometry.dispose();
+        fixture = null;
+    }
+    function rebuild(cfg) {
+        disposeFixture();
+        const cols = clamp(Math.round(num(cfg.columns, 3)), 1, 6), rows = clamp(Math.round(num(cfg.rows, 2)), 1, 4);
+        const layout = bankLayout(cols, rows);
+        const n = layout.length;
+        const group = new THREE.Group();
+        const mk = (g, m) => { const im = new THREE.InstancedMesh(g, m, n); im.castShadow = false; im.receiveShadow = false; im.frustumCulled = false; group.add(im); return im; };
+        const housing = mk(geo.head, housingMat);
+        const yokes = mk(geo.yoke, frameMat);
+        const lensGeo = geo.lens.clone();
+        lensGeo.setAttribute('aCol', new THREE.InstancedBufferAttribute(new Float32Array(n * 3), 3));
+        lensGeo.setAttribute('aGlare', new THREE.InstancedBufferAttribute(new Float32Array(n), 1));
+        const lens = mk(lensGeo, lensMat);
+        const glowGeo = geo.glow.clone();
+        glowGeo.setAttribute('aCol', new THREE.InstancedBufferAttribute(new Float32Array(n * 3), 3));
+        glowGeo.setAttribute('aGlare', new THREE.InstancedBufferAttribute(new Float32Array(n), 1));
+        const glow = mk(glowGeo, glowMat);
+        glow.renderOrder = 4;
+        glow.raycast = () => { };
+        // Crossbars: one tube per row behind the yokes, plus two end posts.
+        const parts = [];
+        const sx = HW + GAP_X + 0.06, sy = HH + GAP_Y;
+        const width = (cols - 1) * sx + HW + 0.3;
+        for (let r = 0; r < rows; r++) {
+            const t = new THREE.BoxGeometry(width, 0.07, 0.07);
+            t.translate(0, ((rows - 1) / 2 - r) * sy, -0.33);
+            parts.push(t.toNonIndexed());
+            t.dispose();
+        }
+        for (const s of [-1, 1]) {
+            const p = new THREE.BoxGeometry(0.07, (rows - 1) * sy + 0.3, 0.07);
+            p.translate(s * width / 2, 0, -0.33);
+            parts.push(p.toNonIndexed());
+            p.dispose();
+        }
+        const crossbars = new THREE.Mesh(mergeGeometries(parts), frameMat);
+        parts.forEach((p) => p.dispose());
+        group.add(crossbars);
+        root.add(group);
+        // Fixed strike order: a shuffled ranking, the same every time.
+        const order = layout.map((_, i) => i).sort((a, b) => hash(a * 3.1 + 0.7) - hash(b * 3.1 + 0.7));
+        heads.length = 0;
+        layout.forEach((pos, i) => heads.push({
+            pos, rank: order.indexOf(i), level: state.on ? 1 : 0, warm: state.on ? 1 : 0,
+            phase: state.on ? 'on' : 'off', timer: 0, lock: 0, ember: 0, strike: 0,
+            col: new THREE.Color(), out: 0,
+        }));
+        fixture = { group, housing, yokes, lens, glow, crossbars };
+        lensMat.uniforms.uLamp.value = cfg.lamp === 'metalHalide' ? 1 : 0;
+        if (mask)
+            mask.dispose();
+        mask = poolMask(clamp(num(cfg.aspect, 0.5), 0.15, 1.5), clamp(num(cfg.edgeSoftness, 0.35), 0, 1));
+        light.map = mask;
+    }
+    function setOn(on, cfg) {
+        if (on === state.on)
+            return;
+        state.on = on;
+        const stagger = Math.max(num(cfg.stagger, 0.25), 0);
+        for (const h of heads) {
+            if (on) {
+                h.phase = 'wait';
+                h.timer = h.rank * stagger;
+            }
+            else {
+                if (cfg.lamp === 'metalHalide' && h.level > 0.05) {
+                    h.lock = Math.max(num(cfg.restrike, 4), 0);
+                    h.ember = 1;
+                }
+                h.phase = 'off';
+            }
+        }
+    }
+    const tmp = { q: new THREE.Quaternion(), wq: new THREE.Quaternion(), m: new THREE.Matrix4(), lm: new THREE.Matrix4(), gm: new THREE.Matrix4(), m2: new THREE.Matrix4(), ym: new THREE.Matrix4(),
+        v: new THREE.Vector3(), o: new THREE.Vector3(), cam: new THREE.Vector3(), ws: new THREE.Vector3(), one: new THREE.Vector3(1, 1, 1),
+        axis: new THREE.Vector3(), right: new THREE.Vector3(), up: new THREE.Vector3(),
+        e: new THREE.Euler(), base: new THREE.Color(), sum: new THREE.Color() };
+    /** cfg is the merged config for this frame (committed + live + keyframes + pointer). */
+    function update(dt, camera, cfg) {
+        dt = Math.min(Math.max(dt, 0), 0.1);
+        state.time += dt;
+        const k = KEY_OF(cfg);
+        if (k !== key) {
+            key = k;
+            rebuild(cfg);
+        }
+        setOn(cfg.on ?? true, cfg);
+        const mh = cfg.lamp === 'metalHalide';
+        const warmup = Math.max(num(cfg.warmup, mh ? 6 : 0.15), 0);
+        const flicker = clamp(num(cfg.flicker, 0), 0, 1);
+        const tilt = clamp(num(cfg.tilt, 0.42), -1.2, 1.4);
+        const spread = clamp(num(cfg.spread, 0.42), 0.05, 1.2);
+        const aspect = clamp(num(cfg.aspect, 0.5), 0.15, 1.5);
+        const tx = Math.tan(spread), ty = tx * aspect;
+        // light colour from the config (the repo's applyLightConfig reads it the same way)
+        if ((cfg.colorMode ?? 'temperature') === 'temperature')
+            kelvinToColor(num(cfg.temperature, 5700), tmp.base);
+        else
+            tmp.base.set(cfg.color ?? '#ffffff');
+        // show modes run on an integrated phase, so animating the rate never jumps
+        const show = mh ? 'none' : (cfg.show ?? 'none');
+        state.showPhase += dt * clamp(num(cfg.showRate, 1), 0, 8);
+        // --- per-head lamp state ---
+        let sumOut = 0;
+        const sum = tmp.sum.setRGB(0, 0, 0);
+        const n = heads.length;
+        heads.forEach((h, i) => {
+            if (h.lock > 0)
+                h.lock = Math.max(h.lock - dt, 0);
+            h.ember = Math.max(h.ember - dt / 1.6, 0);
+            if (h.phase === 'wait') {
+                h.timer -= dt;
+                if (h.timer <= 0 && h.lock <= 0) {
+                    h.phase = mh ? 'strike' : 'on';
+                    h.strike = 0;
+                    h.warm = mh ? 0 : 1;
+                }
+            }
+            let tint = 0; // 0 = lamp colour, 1 = mercury / arc
+            if (h.phase === 'strike') {
+                // arc strike: a few hard blue-white flashes over a third of a second
+                h.strike += dt;
+                h.level = noise1(state.time * 38 + i * 5.3) > 0.55 ? 1.25 : 0.04;
+                tint = 1;
+                if (h.strike > 0.38) {
+                    h.phase = 'warm';
+                    h.level = 0.08;
+                }
+            }
+            else if (h.phase === 'warm') {
+                h.warm += warmup > 0 ? dt / warmup : 1;
+                const w = clamp(h.warm, 0, 1);
+                const target = 0.1 + 0.9 * Math.pow(smooth(0, 1, w), 1.3);
+                tint = 1 - smooth(0.15, 1, w);
+                h.level += (target - h.level) * (1 - Math.exp(-dt * 6));
+                if (h.warm >= 1)
+                    h.phase = 'on';
+            }
+            else if (h.phase === 'on') {
+                const tau = mh ? 0.2 : Math.max(warmup, 0.001);
+                h.level += (1 - h.level) * (1 - Math.exp(-dt * 3 / tau));
+            }
+            else {
+                // off or waiting: an arc dies at once, an LED fades with its driver
+                const tau = mh ? 0.04 : Math.max(warmup * 0.6, 0.001);
+                h.level -= h.level * (1 - Math.exp(-dt * 3 / tau));
+            }
+            if (h.level < 1e-4)
+                h.level = 0;
+            let mod = 1;
+            if (flicker > 0) {
+                const t = state.time + i * 13.7 + state.seed;
+                mod *= 1 - flicker * (0.1 * noise1(t * 9) + 0.6 * Math.pow(noise1(t * 1.9), 5));
+            }
+            if (show === 'chase') {
+                const c = 0.5 + 0.5 * Math.cos(2 * Math.PI * (state.showPhase - h.rank / Math.max(n, 1)));
+                mod *= 0.06 + 0.94 * c * c * c;
+            }
+            else if (show === 'strobe') {
+                const ph = state.showPhase - Math.floor(state.showPhase);
+                mod *= ph < 0.08 ? 1 : 0.02 + 0.98 * Math.exp(-(ph - 0.08) * 40);
+            }
+            else if (show === 'breathe') {
+                mod *= 0.2 + 0.8 * Math.pow(0.5 + 0.5 * Math.sin(2 * Math.PI * state.showPhase), 2);
+            }
+            h.out = h.level * mod;
+            h.col.copy(tmp.base);
+            if (tint > 0)
+                h.col.lerp(h.phase === 'strike' ? ARC : MERCURY, tint);
+            sumOut += h.out;
+            sum.r += h.col.r * h.out;
+            sum.g += h.col.g * h.out;
+            sum.b += h.col.b * h.out;
+        });
+        const mean = n ? sumOut / n : 0;
+        // --- the light: one spot for the bank, carrying the heads' mean output ---
+        // (adopt any intensity we didn't write as the new base)
+        if (light.intensity !== state.written)
+            state.base = light.intensity;
+        if (typeof cfg.intensity === 'number')
+            state.base = cfg.intensity;
+        light.intensity = state.base * mean;
+        state.written = light.intensity;
+        if (sumOut > 1e-4)
+            light.color.setRGB(sum.r / sumOut, sum.g / sumOut, sum.b / sumOut);
+        else
+            light.color.copy(tmp.base);
+        light.distance = num(cfg.distance, 0);
+        light.decay = num(cfg.decay, 1);
+        light.angle = Math.min(Math.atan(Math.sqrt(tx * tx + ty * ty) * CORNER), Math.PI / 2 - 0.01);
+        light.penumbra = 0;
+        // Aim: the heads' shared axis, +Z tilted down by `tilt`. The source sits half
+        // a metre in front of the lenses — at the bank centre it would light its own
+        // visors from centimetres away.
+        tmp.axis.set(0, -Math.sin(tilt), Math.cos(tilt));
+        light.position.copy(tmp.axis).multiplyScalar(0.5);
+        target.position.copy(tmp.axis).multiplyScalar(10);
+        if (cfg.housingColor)
+            housingMat.color.set(cfg.housingColor);
+        // --- fixture instances + lens fill ---
+        const f = fixture;
+        tmp.q.setFromEuler(tmp.e.set(tilt, 0, 0));
+        root.updateMatrixWorld();
+        root.getWorldQuaternion(tmp.wq);
+        const ws = root.getWorldScale(tmp.ws).x || 1;
+        tmp.wq.multiply(tmp.q);
+        const axisW = tmp.axis.set(0, 0, 1).applyQuaternion(tmp.wq);
+        const rightW = tmp.right.set(1, 0, 0).applyQuaternion(tmp.wq);
+        const upW = tmp.up.set(0, 1, 0).applyQuaternion(tmp.wq);
+        const camPos = camera.getWorldPosition(tmp.cam);
+        const soft = 0.05 + clamp(num(cfg.edgeSoftness, 0.35), 0, 1) * 0.6;
+        const apX = HW * 0.5 * ws, apY = HH * 0.5 * ws;
+        const lensCol = f.lens.geometry.getAttribute('aCol'), lensGl = f.lens.geometry.getAttribute('aGlare');
+        const glowCol = f.glow.geometry.getAttribute('aCol'), glowGl = f.glow.geometry.getAttribute('aGlare');
+        const halo = clamp(num(cfg.halo, 1), 0, 2);
+        tmp.gm.makeTranslation(0, 0, HD / 2 + 0.01);
+        tmp.lm.makeTranslation(0, 0, HD / 2 + 0.002);
+        heads.forEach((h, i) => {
+            tmp.m.compose(h.pos, tmp.q, tmp.one);
+            f.housing.setMatrixAt(i, tmp.m);
+            f.glow.setMatrixAt(i, tmp.m2.copy(tmp.m).multiply(tmp.gm));
+            f.lens.setMatrixAt(i, tmp.m.multiply(tmp.lm));
+            f.yokes.setMatrixAt(i, tmp.ym.makeTranslation(h.pos.x, h.pos.y, h.pos.z));
+            // the eye in this head's beam frame: how deep into the rectangle it stands
+            const o = root.localToWorld(tmp.o.copy(h.pos).add(tmp.v.set(0, 0, HD / 2).applyQuaternion(tmp.q)));
+            const q = tmp.v.copy(camPos).sub(o);
+            const z = q.dot(axisW);
+            let g = 0;
+            if (z > 0) {
+                const u = Math.abs(q.dot(rightW)) / (z * tx + apX), v = Math.abs(q.dot(upW)) / (z * ty + apY);
+                g = (1 - smooth(1 - soft, 1.15, u)) * (1 - smooth(1 - soft, 1.15, v)) * smooth(0, 2, z);
+            }
+            // what the lens shows, plus the cooling arc tube's ember
+            lensCol.setXYZ(i, h.col.r * h.out + EMBER.r * h.ember * 0.5, h.col.g * h.out + EMBER.g * h.ember * 0.5, h.col.b * h.out + EMBER.b * h.ember * 0.5);
+            lensGl.setX(i, g);
+            // the glow shows only from in front of the lens plane
+            const facing = smooth(0.0, 0.25, z / Math.max(q.length(), 1e-4));
+            const gk = h.out * halo * facing;
+            glowCol.setXYZ(i, h.col.r * gk, h.col.g * gk, h.col.b * gk);
+            glowGl.setX(i, g);
+        });
+        f.housing.instanceMatrix.needsUpdate = f.lens.instanceMatrix.needsUpdate = f.yokes.instanceMatrix.needsUpdate = f.glow.instanceMatrix.needsUpdate = true;
+        lensCol.needsUpdate = lensGl.needsUpdate = glowCol.needsUpdate = glowGl.needsUpdate = true;
+        glowMat.uniforms.uRightW.value.copy(rightW);
+        f.glow.visible = halo > 0;
+    }
+    function dispose() {
+        disposeFixture();
+        for (const g of Object.values(geo))
+            g.dispose();
+        housingMat.dispose();
+        frameMat.dispose();
+        lensMat.dispose();
+        glowMat.dispose();
+        mask?.dispose();
+    }
+    const first = { ...DEFAULTS, ...cfg0 };
+    rebuild(first);
+    key = KEY_OF(first);
+    return { root, light, update, dispose, heads };
+}

package/dist/components/sports/SportsBall.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { BallSportsConfig } from '@3driseai/3drise-core';
+import type { SportsVariantProps } from './useSportsInstance';
+export interface SportsBallProps extends SportsVariantProps {
+    config: BallSportsConfig;
+}
+declare const SportsBall: React.FC<SportsBallProps>;
+export default SportsBall;
+//# sourceMappingURL=SportsBall.d.ts.map

package/dist/components/sports/SportsBall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SportsBall.d.ts","sourceRoot":"","sources":["../../../src/components/sports/SportsBall.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAmB1E,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACvD,MAAM,EAAE,gBAAgB,CAAC;CAC5B;AAED,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAOzC,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/components/sports/SportsBall.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_SPORTS_OBJECTS, SPORTS_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useSportsInstance } from './useSportsInstance.js';
+import { createUniforms, build, STRUCTURAL } from './core/ball.js';
+// =============================================================================
+// SportsBall — Ball (type 'sports', config.type 'ball')
+// =============================================================================
+// A ball at its real size with its true panel geometry and seams: football, basketball, tennis, baseball, volleyball, rugby, American football, golf, cricket, bowling or beach ball, with leather, felt, rubber or resin surfaces, grooved seams, stitches, dimples and wear. Use for sports scenes, product shots, playgrounds and still lifes.
+// The construction lives in core/ball.ts (emitted from the lab); this component wires it into
+// the config pattern through useSportsInstance.
+const CORE = {
+    DEFAULTS: DEFAULT_SPORTS_OBJECTS.ball,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(SPORTS_OBJECTS_ANIMATABLE.ball.map((p) => p.value)),
+    createUniforms,
+    build,
+};
+const SportsBall = (props) => {
+    const { rootRef, instance } = useSportsInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default SportsBall;

package/dist/components/sports/SportsCourt.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { CourtSportsConfig } from '@3driseai/3drise-core';
+import type { SportsVariantProps } from './useSportsInstance';
+export interface SportsCourtProps extends SportsVariantProps {
+    config: CourtSportsConfig;
+}
+declare const SportsCourt: React.FC<SportsCourtProps>;
+export default SportsCourt;
+//# sourceMappingURL=SportsCourt.d.ts.map

package/dist/components/sports/SportsCourt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SportsCourt.d.ts","sourceRoot":"","sources":["../../../src/components/sports/SportsCourt.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAmB1E,MAAM,WAAW,gBAAiB,SAAQ,kBAAkB;IACxD,MAAM,EAAE,iBAAiB,CAAC;CAC7B;AAED,QAAA,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAO3C,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/components/sports/SportsCourt.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_SPORTS_OBJECTS, SPORTS_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useSportsInstance } from './useSportsInstance.js';
+import { createUniforms, build, STRUCTURAL } from './core/court.js';
+// =============================================================================
+// SportsCourt — Court (type 'sports', config.type 'court')
+// =============================================================================
+// A regulation playing surface with every rulebook line drawn sharp at any distance: tennis, basketball, soccer, American football, futsal, handball, volleyball, badminton, padel, pickleball, ice hockey rink, athletics track or table-tennis table, on acrylic, clay, grass, parquet, ice, tartan, turf or sand, with its nets, goals or hoops. Use for sports venues, parks, schools, product scenes and arenas.
+// The construction lives in core/court.ts (emitted from the lab); this component wires it into
+// the config pattern through useSportsInstance.
+const CORE = {
+    DEFAULTS: DEFAULT_SPORTS_OBJECTS.court,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(SPORTS_OBJECTS_ANIMATABLE.court.map((p) => p.value)),
+    createUniforms,
+    build,
+};
+const SportsCourt = (props) => {
+    const { rootRef, instance } = useSportsInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default SportsCourt;

package/dist/components/sports/SportsEquipment.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { EquipmentSportsConfig } from '@3driseai/3drise-core';
+import type { SportsVariantProps } from './useSportsInstance';
+export interface SportsEquipmentProps extends SportsVariantProps {
+    config: EquipmentSportsConfig;
+}
+declare const SportsEquipment: React.FC<SportsEquipmentProps>;
+export default SportsEquipment;
+//# sourceMappingURL=SportsEquipment.d.ts.map

package/dist/components/sports/SportsEquipment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SportsEquipment.d.ts","sourceRoot":"","sources":["../../../src/components/sports/SportsEquipment.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE,OAAO,KAAK,EAAc,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAmB1E,MAAM,WAAW,oBAAqB,SAAQ,kBAAkB;IAC5D,MAAM,EAAE,qBAAqB,CAAC;CACjC;AAED,QAAA,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAOnD,CAAC;AAEF,eAAe,eAAe,CAAC"}

package/dist/components/sports/SportsEquipment.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_SPORTS_OBJECTS, SPORTS_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useSportsInstance } from './useSportsInstance.js';
+import { createUniforms, build, STRUCTURAL } from './core/equipment.js';
+// =============================================================================
+// SportsEquipment — Equipment (type 'sports', config.type 'equipment')
+// =============================================================================
+// A piece of sports equipment at real size, built from its parts: tennis or badminton racquet with a strung bed, table-tennis paddle, baseball or cricket bat, golf driver, iron or putter, hockey stick, skateboard, dumbbell, kettlebell, barbell with plates, or frisbee, in wood, steel, carbon, rubber and leather with wear. Use for gyms, sports shops, locker rooms, product shots and lifestyle scenes.
+// The construction lives in core/equipment.ts (emitted from the lab); this component wires it into
+// the config pattern through useSportsInstance.
+const CORE = {
+    DEFAULTS: DEFAULT_SPORTS_OBJECTS.equipment,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(SPORTS_OBJECTS_ANIMATABLE.equipment.map((p) => p.value)),
+    createUniforms,
+    build,
+};
+const SportsEquipment = (props) => {
+    const { rootRef, instance } = useSportsInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default SportsEquipment;