@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/sports/core/court.js

@@ -0,0 +1,658 @@
+// Emitted from Claude outputs/sports-lab/court.mjs by gen_family.mjs — edit the lab module and re-emit.
+// sports/core/court — Court (type 'sports', config.type 'court'). Shared core: ../sportsCore.
+// Construction: a playing surface at regulation size with its markings drawn as anti-aliased signed
+// distances in the fragment (every line of the rulebook, metres, sharp at any zoom), on a procedural
+// surface (acrylic, clay, grass, parquet, ice, tartan, turf, sand, concrete, paint) with wear where
+// the play is and puddles when wet; the sport's fixtures (nets, goals, hoops) built from the shared
+// goal builders. Lines are drawn on the mesh itself — no decals, no textures. Size: real metres;
+// the transform places it.
+// Night: the court is lit the urban way, with no real lights — its surface gathers the lamps of the
+// one lamp list (street lamps, other courts' floodlights) and adds their pools, scaled by the night
+// factor from the scene sun; its own floodlight masts register their heads in the same list, so
+// they light the court evenly and spill onto the paving around it.
+import * as THREE from 'three';
+import { setColor, createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_S, litMaterial, propMesh, partMaterial, mergeGeos, box, bar, buildGoal, GOAL_COLORS, disposePair, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, createLampUniforms, createSunUniforms, GLSL_COMMON } from '../sportsCore.js';
+/**
+ * The sports: regulation size (length × width, metres), line width, the run-off the venue adds around
+ * the lines [ends, sides], the natural surface, the three colour slots when the config leaves them
+ * white (surface, lines, accent), the fixtures and where they stand (x along the length).
+ */
+export const SPORTS = {
+    tennis: { L: 23.77, W: 10.97, line: 0.05, mow: 1.32, runoff: [6.4, 3.66], surface: 'hardcourt', colors: ['#2a62a8', '#ffffff', '#3b7f44'], fixtures: [{ kind: 'tennisNet', x: 0, rot: 1 }] },
+    basketball: { L: 28, W: 15, line: 0.05, runoff: [2, 2], surface: 'wood', colors: ['#c89659', '#ffffff', '#a2372f'], fixtures: [{ kind: 'basketballHoop', x: 12.425, rot: -1 }, { kind: 'basketballHoop', x: -12.425, rot: 1 }] },
+    soccer: { L: 105, W: 68, line: 0.12, mow: 5.25, runoff: [6, 4], surface: 'grass', colors: ['#3d8a39', '#ffffff', '#3d8a39'], fixtures: [{ kind: 'footballGoal', x: 52.5, rot: -1 }, { kind: 'footballGoal', x: -52.5, rot: 1 }] },
+    futsal: { L: 40, W: 20, line: 0.08, runoff: [2, 1.5], surface: 'wood', colors: ['#c89659', '#ffffff', '#2a62a8'], fixtures: [{ kind: 'futsalGoal', x: 20, rot: -1 }, { kind: 'futsalGoal', x: -20, rot: 1 }] },
+    handball: { L: 40, W: 20, line: 0.05, runoff: [2, 1], surface: 'wood', colors: ['#c89659', '#ffffff', '#2f6cb5'], fixtures: [{ kind: 'handballGoal', x: 20, rot: -1 }, { kind: 'handballGoal', x: -20, rot: 1 }] },
+    volleyball: { L: 18, W: 9, line: 0.05, runoff: [5, 3], surface: 'hardcourt', colors: ['#d4823a', '#ffffff', '#2a62a8'], fixtures: [{ kind: 'volleyballNet', x: 0, rot: 1 }] },
+    badminton: { L: 13.4, W: 6.1, line: 0.04, runoff: [2, 1.5], surface: 'hardcourt', colors: ['#3b8a4a', '#ffffff', '#2d6d3a'], fixtures: [{ kind: 'badmintonNet', x: 0, rot: 1 }] },
+    padel: { L: 20, W: 10, line: 0.05, runoff: [0.5, 0.5], surface: 'turf', colors: ['#2a62a8', '#ffffff', '#1f4f8a'], fixtures: [{ kind: 'padelNet', x: 0, rot: 1 }] },
+    pickleball: { L: 13.41, W: 6.1, line: 0.05, runoff: [3, 2], surface: 'hardcourt', colors: ['#2a62a8', '#ffffff', '#3b8a4a'], fixtures: [{ kind: 'pickleballNet', x: 0, rot: 1 }] },
+    iceHockey: { L: 60.96, W: 25.91, line: 0.05, runoff: [0, 0], corner: 8.53, surface: 'ice', colors: ['#e9f1f6', '#d8322d', '#2f6cd0'], fixtures: [{ kind: 'hockeyNet', x: 27.13, rot: -1 }, { kind: 'hockeyNet', x: -27.13, rot: 1 }] },
+    athleticsTrack: { L: 176.9, W: 92.5, line: 0.05, runoff: [3, 3], surface: 'tartan', colors: ['#b8453a', '#ffffff', '#3d8a39'], fixtures: [] },
+    tableTennis: { L: 2.74, W: 1.525, line: 0.02, runoff: [0, 0], table: 0.76, surface: 'painted', colors: ['#1d3f86', '#ffffff', '#1d3f86'], fixtures: [{ kind: 'tableTennisNet', x: 0, rot: 1 }] },
+    // NFL: 120 × 53⅓ yd with the end zones; the uprights' crossbar stands over each end line
+    americanFootball: { L: 109.728, W: 48.768, line: 0.1016, mow: 4.572, runoff: [6, 8], surface: 'grass', colors: ['#3d8a39', '#ffffff', '#1f3f7a'], fixtures: [{ kind: 'americanUprights', x: 54.864, rot: -1 }, { kind: 'americanUprights', x: -54.864, rot: 1 }] },
+};
+export const SPORT_LIST = Object.keys(SPORTS);
+/** Earlier names of a sport (saved scenes keep working): 'football' was the soccer pitch. */
+export const SPORT_ALIASES = { football: 'soccer' };
+/** The sport key a config means (an alias resolved; unknown -> tennis). */
+export function sportKey(k) { const a = SPORT_ALIASES[k] || k; return SPORTS[a] ? a : 'tennis'; }
+/**
+ * Floodlights per sport. sides: n masts along each long side, heads on an arm over the slab edge,
+ * tilted toward the court (street-lamp pools); towers: four stadium towers outside the corners, each a
+ * bank of rows × cols projectors aimed into the field, registered as PROJECTOR lamps (aimed long-throw
+ * beams: lamp.aim + lamp.spread) — every tower throws one beam at each quarter of the field, so the
+ * whole surface is lit evenly. h = head height (m), set = how far outside the corner the tower stands,
+ * radius = reach, I = lamp intensity (urban units), spread = cos of a beam's outer half-angle.
+ */
+export const FLOOD = {
+    tennis: { mode: 'sides', n: 3, h: 9, radius: 26, I: 0.9 },
+    basketball: { mode: 'sides', n: 3, h: 10, radius: 26, I: 0.9 },
+    soccer: { mode: 'towers', h: 32, rows: 4, cols: 5, set: 6, radius: 170, I: 0.2, spread: 0.74 },
+    futsal: { mode: 'sides', n: 3, h: 10, radius: 28, I: 0.95 },
+    handball: { mode: 'sides', n: 3, h: 10, radius: 28, I: 0.95 },
+    volleyball: { mode: 'sides', n: 2, h: 9, radius: 24, I: 0.9 },
+    badminton: { mode: 'sides', n: 2, h: 7, radius: 18, I: 0.8 },
+    padel: { mode: 'sides', n: 2, h: 7, radius: 18, I: 0.8 },
+    pickleball: { mode: 'sides', n: 2, h: 7, radius: 18, I: 0.8 },
+    iceHockey: { mode: 'sides', n: 4, h: 12, radius: 30, I: 1.0 },
+    athleticsTrack: { mode: 'towers', h: 38, rows: 5, cols: 6, set: 8, radius: 240, I: 0.2, spread: 0.74 },
+    tableTennis: null,
+    americanFootball: { mode: 'towers', h: 34, rows: 4, cols: 5, set: 7, radius: 175, I: 0.2, spread: 0.74 },
+};
+export const LIGHTING = ['auto', 'day', 'night'];
+export const SURFACES = ['auto', 'hardcourt', 'clay', 'grass', 'wood', 'ice', 'tartan', 'turf', 'sand', 'concrete', 'painted'];
+export function createUniforms() {
+    return Object.assign(createCommonUniforms(), {
+        // the fixtures (nets, goals, hoops) keep their own natural colours: the court's colour slots are surface / lines / zone
+        fixtureU: createCommonUniforms(),
+        uSport: { value: 0 }, uSurface: { value: 0 }, uMow: { value: 5 }, uLineW: { value: 0.05 }, uWet: { value: 0 }, uTableY: { value: -1 },
+        uSurfCol: { value: new THREE.Color('#2a62a8') }, uLineCol: { value: new THREE.Color('#ffffff') }, uZoneCol: { value: new THREE.Color('#3b7f44') },
+        uFloodColor: { value: new THREE.Color('#fff1dc') }, uFloodGlow: { value: 1 },
+    }, createSunUniforms(), createLampUniforms());
+}
+export function applyConfig(u, c, inst = undefined) {
+    applyCommonConfig(u, c, inst && inst.mats);
+    const S = SPORTS[sportKey(c.sport)];
+    // the three colour slots (surface, lines, surround / zone): the sport's own while naturalColors is on
+    const nat = c.naturalColors !== false;
+    setColor(u.uSurfCol, nat ? S.colors[0] : c.color);
+    setColor(u.uLineCol, nat ? S.colors[1] : c.secondaryColor);
+    setColor(u.uZoneCol, nat ? S.colors[2] : c.accentColor);
+    if (c.sport !== undefined) {
+        u.uSport.value = SPORT_LIST.indexOf(sportKey(c.sport));
+        u.uMow.value = S.mow || 5;
+    }
+    if (c.surface !== undefined)
+        u.uSurface.value = Math.max(0, SURFACES.indexOf(c.surface === 'auto' ? S.surface : c.surface) - 1);
+    if (c.lineScale !== undefined)
+        u.uLineW.value = S.line * c.lineScale;
+    if (c.wetness !== undefined)
+        u.uWet.value = c.wetness;
+    // fixtures: the court's wear / gloss / seed / opacity, their own colours (set at build from GOAL_COLORS)
+    const fu = u.fixtureU;
+    applyCommonConfig(fu, { wear: c.wear, gloss: c.gloss, seed: c.seed, opacity: c.opacity }, inst && inst.fixtureMats);
+    if (inst)
+        for (const f of inst.fixtures)
+            f.apply({ netTension: 0.75 });
+    // floodlights: the heads' glow and their entries in the lamp list
+    if (c.floodColor !== undefined)
+        setColor(u.uFloodColor, c.floodColor);
+    if (c.floodIntensity !== undefined)
+        u.uFloodGlow.value = c.floodIntensity;
+    // setLamps bumps the shared lamp list only on a real change: apply runs every frame while any
+    // knob animates, and a bump per frame re-gathers / re-bakes every lamp-lit surface in the scene
+    if (inst && inst.lamps.length)
+        setLamps(inst.lamps, c.floodColor, c.floodIntensity !== undefined ? inst.lamps[0].base * c.floodIntensity : undefined);
+}
+// ---------------------------------------------------------------------------- GLSL: the markings
+// p = (x along the length, z across), metres from the centre. Every sport writes:
+//   dL   distance to the nearest line (drawn in the line colour, width uLineW)
+//   dA   distance to the nearest accent-coloured line (hockey blue lines), width wA
+//   zone 1 inside the accent-filled area (a key, a crease, the surround, the infield)
+//   field 1 inside the playing area (for the surface's own wear focus)
+const MARKINGS_GLSL = /* glsl */ `
+uniform float uSport, uSurface, uLineW, uWet, uTableY, uMow;
+uniform vec3 uSurfCol, uLineCol, uZoneCol;
+// a stadium (two straights + two semicircles): distance to its outline
+float lnStadium(vec2 p, float a, float r) { return abs(length(vec2(max(abs(p.x) - a, 0.0), p.y)) - r); }
+float inBox(vec2 p, vec2 hb) { return step(abs(p.x), hb.x) * step(abs(p.y), hb.y); }
+// dashes are a coverage mask (dOn), never a jump in the distance field — a discontinuous distance
+// blows up fwidth and smears the line across a whole band
+float dashOn(float s, float len) { return step(0.5, fract(s / (2.0 * len))); }
+
+// a seven-segment digit (0–9), centred, 1.2 × 1.83 m (the field numbers' 4 × 6 ft), distance to its strokes' centre lines
+float segD(vec2 uv, vec2 a, vec2 b) { return sdSeg(uv, a, b); }
+float digit7(vec2 uv, int n) {
+    float w = 0.49, h = 0.805, d = 1e9;
+    bool A = n != 1 && n != 4, B = n != 5 && n != 6, C = n != 2, D = n != 1 && n != 4 && n != 7;
+    bool E = n == 0 || n == 2 || n == 6 || n == 8, F = n != 1 && n != 2 && n != 3 && n != 7, G = n != 0 && n != 1 && n != 7;
+    if (A) d = min(d, segD(uv, vec2(-w, h), vec2(w, h)));
+    if (B) d = min(d, segD(uv, vec2(w, h), vec2(w, 0.0)));
+    if (C) d = min(d, segD(uv, vec2(w, 0.0), vec2(w, -h)));
+    if (D) d = min(d, segD(uv, vec2(-w, -h), vec2(w, -h)));
+    if (E) d = min(d, segD(uv, vec2(-w, 0.0), vec2(-w, -h)));
+    if (F) d = min(d, segD(uv, vec2(-w, h), vec2(-w, 0.0)));
+    if (G) d = min(d, segD(uv, vec2(-w, 0.0), vec2(w, 0.0)));
+    return d;
+}
+
+void markings(vec2 p, out float dL, out float dA, out float wA, out float dD, out float dOn, out float zone, out float field) {
+    dL = 1e9; dA = 1e9; wA = uLineW; dD = 1e9; dOn = 0.0; zone = 0.0; field = 0.0;
+    vec2 q = abs(p);                                 // every court is symmetric about both axes
+    int s = int(uSport + 0.5);
+    if (s == 0) {                                    // tennis 23.77 × 10.97
+        vec2 H = vec2(11.885, 5.485);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(0.0, 4.115), vec2(11.885, 4.115)));          // singles sideline
+        dL = min(dL, sdSeg(q, vec2(6.4, 0.0), vec2(6.4, 4.115)));               // service line
+        dL = min(dL, sdSeg(q, vec2(0.0, 0.0), vec2(6.4, 0.0)));                 // centre service line
+        dL = min(dL, sdSeg(q, vec2(11.885, 0.0), vec2(11.785, 0.0)));           // centre mark
+        field = inBox(p, H); zone = 1.0 - field;
+    } else if (s == 1) {                             // basketball FIBA 28 × 15
+        vec2 H = vec2(14.0, 7.5);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(0.0, 0.0), vec2(0.0, 7.5)));                 // halfway
+        dL = min(dL, lnCircle(p, vec2(0.0), 1.8));                              // centre circle
+        dL = min(dL, lnBox(q, vec2(11.1, 0.0), vec2(2.9, 2.45)));               // the key 5.8 × 4.9
+        dL = min(dL, lnCircle(q, vec2(8.2, 0.0), 1.8));                         // free-throw circle
+        vec2 bk = vec2(12.425, 0.0);                                            // basket
+        dL = min(dL, lnArc(q, bk, 6.75, 3.14159 - 1.3598, 3.14159 + 1.3598));    // 3-pt arc (meets the straights at |z| = 6.6)
+        dL = min(dL, sdSeg(q, vec2(14.0, 6.6), vec2(11.01, 6.6)));             // 3-pt straight
+        dL = min(dL, lnArc(q, bk, 1.25, 1.5708, 4.7124));                       // no-charge semicircle
+        field = inBox(p, H); zone = inBox(q - vec2(11.1, 0.0), vec2(2.9, 2.45));
+    } else if (s == 2) {                             // soccer 105 × 68
+        vec2 H = vec2(52.5, 34.0);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(0.0, 0.0), vec2(0.0, 34.0)));                // halfway
+        dL = min(dL, lnCircle(p, vec2(0.0), 9.15));
+        dL = min(dL, length(p) - 0.2);                                          // centre spot
+        dL = min(dL, lnBox(q, vec2(44.25, 0.0), vec2(8.25, 20.16)));            // penalty area 16.5 × 40.32
+        dL = min(dL, lnBox(q, vec2(49.75, 0.0), vec2(2.75, 9.16)));             // goal area 5.5 × 18.32
+        dL = min(dL, length(q - vec2(41.5, 0.0)) - 0.2);                        // penalty mark
+        dL = min(dL, lnArc(q, vec2(41.5, 0.0), 9.15, 3.14159 - 0.9273, 3.14159 + 0.9273)); // penalty arc, outside the area
+        dL = min(dL, lnArc(q, vec2(52.5, 34.0), 1.0, 3.14159, 4.7124));         // corner arc
+        field = inBox(p, H);
+    } else if (s == 3 || s == 4) {                   // futsal / handball 40 × 20
+        vec2 H = vec2(20.0, 10.0);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(0.0, 0.0), vec2(0.0, 10.0)));
+        float r = s == 3 ? 6.0 : 6.0;
+        // the D: quarter circles around the posts (±1.5) joined by a straight
+        float dD = min(lnArc(q, vec2(20.0, 1.5), r, 1.5708, 3.14159), sdSeg(q, vec2(20.0 - r, 0.0), vec2(20.0 - r, 1.5)));
+        dL = min(dL, dD);
+        if (s == 3) {
+            dL = min(dL, lnCircle(p, vec2(0.0), 3.0));
+            dL = min(dL, length(q - vec2(14.0, 0.0)) - 0.15);                   // penalty mark 6 m
+            dL = min(dL, length(q - vec2(10.0, 0.0)) - 0.15);                   // second mark 10 m
+        } else {
+            // 9 m dashed line, 7 m mark, 4 m goalkeeper line
+            vec2 c = vec2(20.0, 1.5);
+            float a = atan(q.y - 1.5, q.x - 20.0);
+            float d9 = min(lnArc(q, c, 9.0, 1.5708, 3.14159), sdSeg(q, vec2(11.0, 0.0), vec2(11.0, 1.5)));
+            float along = q.y < 1.5 && q.x < 11.5 ? q.y : (a - 1.5708) * 9.0 + 1.5;
+            dD = d9; dOn = dashOn(along, 0.15);
+            dL = min(dL, sdSeg(q, vec2(13.0, 0.0), vec2(13.0, 0.5)));           // 7 m mark (1 m long)
+            dL = min(dL, sdSeg(q, vec2(16.0, 0.0), vec2(16.0, 0.075)));         // 4 m line
+            zone = step(sdSeg(q, vec2(20.0, 0.0), vec2(20.0, 1.5)), r);          // the goal area, filled
+        }
+        field = inBox(p, H);
+    } else if (s == 5) {                             // volleyball 18 × 9
+        vec2 H = vec2(9.0, 4.5);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(0.0, 0.0), vec2(0.0, 4.5)));
+        dL = min(dL, sdSeg(q, vec2(3.0, 0.0), vec2(3.0, 4.5)));                 // attack line
+        field = inBox(p, H); zone = 1.0 - field;
+    } else if (s == 6) {                             // badminton 13.4 × 6.1
+        vec2 H = vec2(6.7, 3.05);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(0.0, 2.59), vec2(6.7, 2.59)));               // singles sideline
+        dL = min(dL, sdSeg(q, vec2(1.98, 0.0), vec2(1.98, 3.05)));              // short service line
+        dL = min(dL, sdSeg(q, vec2(5.94, 0.0), vec2(5.94, 3.05)));              // doubles long service line
+        dL = min(dL, sdSeg(q, vec2(1.98, 0.0), vec2(6.7, 0.0)));                // centre line
+        field = inBox(p, H); zone = 1.0 - field;
+    } else if (s == 7) {                             // padel 20 × 10
+        vec2 H = vec2(10.0, 5.0);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(6.95, 0.0), vec2(6.95, 5.0)));               // service line
+        dL = min(dL, sdSeg(q, vec2(0.0, 0.0), vec2(6.95, 0.0)));                // centre service line
+        field = inBox(p, H); zone = 1.0 - field;
+    } else if (s == 8) {                             // pickleball 13.41 × 6.1
+        vec2 H = vec2(6.705, 3.05);
+        dL = lnBox(p, vec2(0.0), H);
+        dL = min(dL, sdSeg(q, vec2(2.13, 0.0), vec2(2.13, 3.05)));              // non-volley line
+        dL = min(dL, sdSeg(q, vec2(2.13, 0.0), vec2(6.705, 0.0)));              // centre line
+        field = inBox(p, H); zone = step(q.x, 2.13) * field;
+    } else if (s == 9) {                             // ice hockey NHL 60.96 × 25.91
+        float gl = 27.13;
+        dL = sdSeg(q, vec2(gl, 0.0), vec2(gl, 13.0));                           // goal line (red)
+        dA = sdSeg(q, vec2(7.62, 0.0), vec2(7.62, 13.0)); wA = 0.3;              // blue lines
+        dD = sdSeg(q, vec2(0.0, 0.0), vec2(0.0, 13.0)); dOn = dashOn(q.y, 0.2);  // centre red line (dashed look)
+        dL = min(dL, lnCircle(p, vec2(0.0), 4.57) + 0.0);                        // centre faceoff circle
+        vec2 fo = vec2(gl - 6.1, 6.71);
+        dL = min(dL, lnCircle(q, fo, 4.57));                                    // end-zone circles
+        dL = min(dL, length(q - fo) - 0.3);                                     // faceoff dots
+        dL = min(dL, length(q - vec2(6.1, 6.71)) - 0.3);                        // neutral-zone dots
+        dL = min(dL, length(p) - 0.15);
+        dL = min(dL, sdSeg(q, vec2(fo.x - 0.6, fo.y - 0.9), vec2(fo.x - 0.6, fo.y + 0.9)));  // hash marks (simplified)
+        dL = min(dL, sdSeg(q, vec2(fo.x + 0.6, fo.y - 0.9), vec2(fo.x + 0.6, fo.y + 0.9)));
+        dL = min(dL, lnArc(q, vec2(gl, 0.0), 1.83, 1.5708, 4.7124));            // crease outline (red)
+        zone = step(length(q - vec2(gl, 0.0)), 1.83) * step(q.x, gl);           // crease fill (light blue)
+        field = 1.0;
+    } else if (s == 10) {                            // athletics track: 400 m, 8 lanes of 1.22 m, r 36.5, straights 84.39
+        float a = 42.195, r0 = 36.5;
+        for (int k = 0; k <= 8; k++) dL = min(dL, lnStadium(p, a, r0 + 1.22 * float(k)));
+        float rr = length(vec2(max(abs(p.x) - a, 0.0), p.y));
+        field = step(r0, rr) * step(rr, r0 + 9.76);
+        zone = 1.0 - field;
+        // finish line across the home straight at the start of the bend
+        dL = min(dL, sdSeg(vec2(p.x, p.y), vec2(a, r0), vec2(a, r0 + 9.76)));
+    } else if (s == 12) {                            // American football (NFL) 120 × 53⅓ yd, in metres
+        float Y = 0.9144, hx = 54.864, hz = 24.384, gl = 45.72;
+        // the 6 ft white border outside the sidelines and end lines
+        vec2 bq = q - vec2(hx, hz) - 0.915;
+        // (filled shapes: zero inside, so the line test |dL| < lw/2 paints them whole)
+        dL = max(abs(length(max(bq, 0.0)) + min(max(bq.x, bq.y), 0.0)) - 0.915 + uLineW * 0.5, 0.0);
+        dL = min(dL, max(sdSeg(q, vec2(gl, 0.0), vec2(gl, hz)) - 0.1016 + uLineW * 0.5, 0.0));            // goal lines, 8 in
+        // grids with the nearest index CLAMPED (never a branch per index): the distance stays continuous,
+        // so fwidth never spikes and paints a phantom line where the nearest mark changes
+        float n5 = clamp(floor(q.x / (5.0 * Y) + 0.5), 0.0, 10.0);
+        dL = min(dL, length(vec2(q.x - n5 * 5.0 * Y, max(q.y - hz, 0.0))));    // yard lines every 5 yd
+        float n1 = clamp(floor(q.x / Y + 0.5), 0.0, 50.0), dx = q.x - n1 * Y;  // 1-yd hashes: inbounds (NFL) and sidelines
+        dL = min(dL, length(vec2(dx, max(abs(q.y - 3.124) - 0.305, 0.0))));
+        dL = min(dL, length(vec2(dx, max(abs(q.y - (hz - 0.407)) - 0.305, 0.0))));
+        dL = min(dL, sdSeg(q, vec2(gl - 1.8288, 0.0), vec2(gl - 1.8288, 0.457))); // try line at the 2
+        // field numbers every 10 yd, 6 ft tall, tops 12 yd in from the sideline, read from the near sideline
+        float k = clamp(floor(p.x / (10.0 * Y) + 0.5), -4.0, 4.0);
+        {
+            float sg = p.y < 0.0 ? -1.0 : 1.0;
+            vec2 uv = vec2(sg * (p.x - k * 10.0 * Y), -(q.y - (hz - 10.973 + 0.915)));
+            dL = min(dL, max(digit7(uv + vec2(0.95, 0.0), int(5.0 - abs(k) + 0.5)) - 0.1 + uLineW * 0.5, 0.0));
+            dL = min(dL, max(digit7(uv - vec2(0.95, 0.0), 0) - 0.1 + uLineW * 0.5, 0.0));
+            // direction arrows beside the numbers, pointing to the nearer goal (not at the 50)
+            if (abs(k) > 0.5) {
+                float dir = sign(k);
+                vec2 t = vec2((p.x - (k * 10.0 * Y + dir * 2.0)) * dir, q.y - (hz - 10.973 + 0.35));
+                float f = max(-0.15 - t.x, abs(t.y) - (0.3 - t.x) * 0.667);
+                dL = min(dL, max(f, 0.0));
+            }
+        }
+        field = inBox(p, vec2(hx, hz));
+        zone = step(gl, q.x) * field;                                          // the end zones
+    } else {                                         // table tennis 2.74 × 1.525 (lines 2 cm along the edges, 3 mm centre line)
+        vec2 H = vec2(1.37 - 0.01, 0.7625 - 0.01);
+        dL = lnBox(p, vec2(0.0), H);
+        float dc = abs(p.y);                                                    // centre line along the length
+        dL = min(dL, dc + (uLineW - 0.003) * 0.5);                              // 3 mm line in the same width unit
+        field = 1.0;
+    }
+}
+`;
+// ---------------------------------------------------------------------------- GLSL: the surfaces
+const SURFACE_GLSL = /* glsl */ `
+// Returns albedo, roughness and a height (for the bump) of the bare surface at p (metres), given the
+// in-play flag and the wear focus (0..1, higher where the play is).
+vec3 surfAlb; float surfRough; float surfH; float lineSoft; float lineBump;
+void surfaceAt(vec2 p, float focus, float worn) {
+    int k = int(uSurface + 0.5);
+    vec3 base = uSurfCol;
+    lineSoft = 1.0; lineBump = 0.0; surfH = 0.0;
+    if (k == 0) {                // hardcourt: acrylic over asphalt — fine grit, ball marks and scuffs lighten it
+        float grit = snoise3(vec3(p * 900.0, 1.0));
+        surfAlb = base * (0.94 + 0.12 * grit) * (0.97 + 0.06 * sfbm2(p * 0.7));
+        surfAlb = mix(surfAlb, surfAlb * 1.35 + 0.05, worn * 0.7);
+        surfRough = 0.72 + 0.1 * grit - worn * 0.12;
+        surfH = grit * 0.00012;
+    } else if (k == 1) {         // clay: crushed brick, brushed streaks along the length, damp patches
+        float gr = snoise3(vec3(p * 500.0, 2.0));
+        float streak = snoise2(vec2(p.x * 2.5, p.y * 90.0));
+        float damp = sfbm2(p * 0.35 + uSeed);
+        surfAlb = base * (0.9 + 0.18 * gr) * (0.92 + 0.12 * streak) * mix(1.0, 0.72, smoothstep(0.55, 0.8, damp) * 0.6);
+        surfAlb = mix(surfAlb, surfAlb * 0.8, worn * 0.6);                     // drag marks darken the clay
+        surfRough = 0.95;
+        surfH = gr * 0.0003 + streak * 0.0002;
+        lineSoft = 1.6; lineBump = 0.002;                                      // tape lines, slightly raised, dusty edge
+    } else if (k == 2) {         // grass: mowing stripes across the length (uMow metres: ~1.3 on a tennis lawn, ~5 on a pitch), blade noise, worn to earth where played
+        float tri = abs(fract(p.x / (2.0 * uMow)) - 0.5);                   // 0..0.5, one stripe each side of 0.25
+        float bw = fwidth(p.x) / (2.0 * uMow) + 1e-4;
+        float band = smoothstep(0.25 - bw, 0.25 + bw, tri);
+        float blades = snoise2(p * 60.0) * 0.5 + snoise2(p * 200.0 + 5.0) * 0.5;
+        float ptch = sfbm2(p * 0.15 + uSeed * 3.0);
+        surfAlb = base * mix(0.92, 1.08, band) * (0.85 + 0.3 * blades) * (0.9 + 0.2 * ptch);
+        vec3 earth = vec3(0.42, 0.33, 0.22);
+        surfAlb = mix(surfAlb, earth * (0.8 + 0.4 * blades), worn * 0.85);
+        surfRough = 0.95;
+        surfH = blades * 0.004 * (1.0 - worn);
+        lineSoft = 2.2;                                                        // chalk / paint on blades
+    } else if (k == 3) {         // parquet: boards 5.7 cm wide along the length, staggered ends, varnish dulled where played
+        float bw = 0.057;
+        float row = floor(p.y / bw);
+        float h = shash12(vec2(row, uSeed));
+        float len = 1.8 + 0.8 * h;
+        float seg = floor((p.x + h * 7.0) / len);
+        float tone = shash12(vec2(row * 3.1, seg + uSeed));
+        float far = smoothstep(0.15, 0.5, fwidth(p.y) / bw);               // boards thinner than a pixel: average them out
+        float grain = snoise2(vec2(p.x * 6.0 + seg, p.y * 260.0 + row * 7.0)) * (1.0 - far) + 0.5 * far;
+        vec3 wood = base * mix(0.86, 1.14, mix(tone, 0.5, far)) * (0.9 + 0.18 * grain);
+        float gap = min(abs(fract(p.y / bw) - 0.5) * bw, abs(fract((p.x + h * 7.0) / len) - 0.5) * len);
+        float gapL = (1.0 - smoothstep(0.0, 0.0015 + fwidth(p.x) * 0.5, gap - 0.0007)) * (1.0 - far);
+        surfAlb = mix(wood, wood * 0.55, gapL * 0.8);
+        surfAlb = mix(surfAlb, surfAlb * 0.9, worn * 0.4);
+        surfRough = mix(0.32, 0.6, worn) + 0.08 * grain;
+        surfH = -gapL * 0.0006 + grain * 0.00002;
+    } else if (k == 4) {         // ice: pale blue-white, skate scratches in two directions, markings painted under it
+        float sc1 = snoise2(vec2(p.x * 1.5 + p.y * 0.3, p.y * 220.0));
+        float sc2 = snoise2(vec2(p.y * 1.2 - p.x * 0.2, p.x * 180.0 + 9.0));
+        float scr = max(sc1, sc2);
+        float frost = sfbm2(p * 0.4 + uSeed);
+        surfAlb = base * (0.96 + 0.04 * frost);
+        surfAlb = mix(surfAlb, vec3(1.0), worn * 0.5 * smoothstep(0.6, 0.95, scr));   // snow dust in the cuts
+        surfRough = mix(0.06, 0.3, worn * smoothstep(0.5, 0.95, scr)) + 0.02 * frost;
+        surfH = -worn * smoothstep(0.75, 0.95, scr) * 0.0004;
+        lineSoft = 2.5;                                                        // under the ice: soft-edged, slightly veiled
+    } else if (k == 5) {         // tartan: rubber granules
+        float gr = snoise3(vec3(p * 420.0, 3.0));
+        surfAlb = base * (0.82 + 0.3 * gr) * (0.95 + 0.08 * sfbm2(p * 0.3));
+        surfAlb = mix(surfAlb, surfAlb * 1.2 + 0.03, worn * 0.5);
+        surfRough = 0.9;
+        surfH = gr * 0.0005;
+    } else if (k == 6) {         // artificial turf: fibres with a nap direction, sand infill
+        float fib = snoise2(vec2(p.x * 300.0, p.y * 40.0));
+        float sand = step(0.93, snoise2(p * 700.0));
+        surfAlb = base * (0.85 + 0.3 * fib);
+        surfAlb = mix(surfAlb, vec3(0.75, 0.7, 0.6), sand * 0.5 + worn * 0.35);
+        surfRough = 0.9;
+        surfH = fib * 0.001;
+    } else if (k == 7) {         // sand: ripples and footprints
+        float rip = sfbm2(p * vec2(2.5, 0.8));
+        float grain = snoise3(vec3(p * 600.0, 4.0));
+        surfAlb = base * (0.9 + 0.1 * rip) * (0.94 + 0.12 * grain);
+        surfAlb = mix(surfAlb, surfAlb * 0.85, worn * 0.4);
+        surfRough = 1.0;
+        surfH = rip * 0.012 + grain * 0.0006 - worn * 0.004 * smoothstep(0.4, 0.7, sfbm2(p * 3.0));
+        lineSoft = 3.0;
+    } else if (k == 8) {         // concrete: panels, tone variation, cracks
+        float tone = sfbm2(p * 0.25 + uSeed);
+        float crack = 1.0 - abs(2.0 * sfbm2(p * 0.9 + 3.0) - 1.0);
+        float cr = smoothstep(0.93, 0.99, crack);
+        float joint = min(abs(fract(p.x / 4.0) - 0.5) * 4.0, abs(fract(p.y / 4.0) - 0.5) * 4.0);
+        float jl = 1.0 - smoothstep(0.004, 0.012, joint);
+        surfAlb = base * (0.85 + 0.3 * tone) * (1.0 - 0.5 * cr) * (1.0 - 0.4 * jl);
+        surfAlb = mix(surfAlb, surfAlb * 0.75, worn * 0.5);
+        surfRough = 0.9 - 0.1 * tone;
+        surfH = -cr * 0.0015 - jl * 0.002;
+    } else {                     // painted (a table top): matte paint, slight orange peel, scuffed edges
+        float peel = snoise2(p * 500.0);
+        surfAlb = base * (0.97 + 0.05 * peel);
+        surfAlb = mix(surfAlb, surfAlb * 1.3 + 0.05, worn * 0.5);
+        surfRough = 0.55 + 0.05 * peel + worn * 0.2;
+        surfH = peel * 0.00003;
+    }
+}
+`;
+export function courtMaterial(u) {
+    return litMaterial(u, {
+        name: 'court', roughness: 0.7, metalness: 0,
+        depthBias: [-4, -8], // beats urban paving (-2 / -4) it may be laid on
+        pars: 'float courtRough; float courtH;\n' + GLSL_COMMON + MARKINGS_GLSL + SURFACE_GLSL,
+        // the lamp list's pools (street lamps, floodlights), faded in by the night factor — urban's lampLight
+        emissive: /* glsl */ `totalEmissiveRadiance += diffuseColor.rgb * lampLight(vWorldPos, normalize(inverseTransformDirection(normal, viewMatrix)));`,
+        color: /* glsl */ `
+    vec2 p = vObj.xz;
+    float dL, dA, wA, dD, dOn, zone, field;
+    markings(p, dL, dA, wA, dD, dOn, zone, field);
+    // table top only (a flat court has uTableY < 0 → always true)
+    float top = step(uTableY - 0.002, vObj.y);
+    if (top < 0.5) { dL = 1e9; dA = 1e9; dD = 1e9; zone = 0.0; }
+    // wear concentrates where the lines are dense and inside the field
+    float focus = field * (0.2 + 0.8 * (1.0 - smoothstep(0.0, 1.2, min(dL, dA)))) + zone * 0.3;
+    if (int(uSport + 0.5) == 0)      // tennis wears behind the baselines (centre), then around the service T
+        focus = field * 0.1 + exp(-pow((abs(p.x) - 11.6) / 1.4, 2.0) - pow(p.y / 2.6, 2.0)) + 0.45 * exp(-pow((abs(p.x) - 6.4) / 0.9, 2.0) - pow(p.y / 1.3, 2.0));
+    if (int(uSport + 0.5) == 12)     // a gridiron wears between the hashes, most between the 20s
+        focus = field * (0.15 + 0.85 * exp(-pow(p.y / 6.0, 2.0)) * (0.5 + 0.5 * exp(-pow(p.x / 30.0, 2.0))));
+    if (int(uSport + 0.5) == 2)      // a pitch wears in the goalmouths and around the centre spot
+        focus = field * (0.1 + 0.9 * exp(-pow((abs(p.x) - 52.5) / 7.0, 2.0) - pow(p.y / 9.0, 2.0)) + 0.5 * exp(-dot(p, p) / 60.0));
+    float worn = scuffs(vec3(p.x, 0.0, p.y), 1.6, focus) ;
+    surfaceAt(p, focus, worn);
+    vec3 alb = mix(surfAlb, surfAlb * (uZoneCol / max(uSurfCol, vec3(0.02))), zone);
+    // lines, anti-aliased, softened per surface; worn lines thin and fade
+    float lw = uLineW * mix(1.0, 0.85, worn);
+    float lineA = 1.0 - smoothstep(lw * 0.5 - fwidth(dL) * lineSoft * 0.7, lw * 0.5 + fwidth(dL) * lineSoft * 0.7, abs(dL));
+    float accA = 1.0 - smoothstep(wA * 0.5 - fwidth(dA) * lineSoft * 0.7, wA * 0.5 + fwidth(dA) * lineSoft * 0.7, abs(dA));
+    float dashA = (1.0 - smoothstep(lw * 0.5 - fwidth(dD) * lineSoft * 0.7, lw * 0.5 + fwidth(dD) * lineSoft * 0.7, abs(dD))) * dOn;
+    lineA = max(lineA, dashA);
+    lineA *= 1.0 - worn * 0.55;
+    alb = mix(alb, uZoneCol, accA * 0.95);
+    alb = mix(alb, uLineCol, lineA * 0.95);
+    float h = surfH + lineA * lineBump;
+    // wet: dark and glossy, puddles in the hollows
+    float puddle = smoothstep(1.0 - uWet * 0.6, 1.05 - uWet * 0.6, sfbm2(p * 0.22 + uSeed * 2.0 + 11.0)) * step(0.01, uWet);
+    float damp = clamp(uWet * 0.6 + puddle, 0.0, 1.0);
+    alb *= mix(1.0, 0.55, damp);
+    courtRough = clamp(mix(mix(surfRough, 0.35, lineA * 0.5), 0.06, damp) / max(uGloss, 0.05), 0.03, 1.0);
+    courtH = mix(h, 0.0, puddle);
+    diffuseColor.rgb *= alb;`,
+        rough: 'courtRough',
+        normal: /* glsl */ `normal = bumpNormal(normal, courtH);`,
+    });
+}
+export function build(u, c) {
+    const S = SPORTS[sportKey(c.sport)];
+    const q = QUALITY_S[c.quality] || 1;
+    const mx = S.runoff[0] * (c.margin ?? 1), mz = S.runoff[1] * (c.margin ?? 1);
+    const L = S.L + 2 * mx, W = S.W + 2 * mz;
+    const object = new THREE.Group();
+    object.name = 'court';
+    const geos = [], mats = [], fixtures = [];
+    const pair = courtMaterial(u);
+    mats.push(pair);
+    if (S.table) {
+        // a table: the top box (markings on its top face), an apron, four legs, a brace
+        const t = S.table, th = 0.025;
+        const top = new THREE.BoxGeometry(S.L, th, S.W);
+        top.translate(0, t - th / 2, 0);
+        geos.push(top);
+        object.add(propMesh(top, pair, 'top'));
+        u.uTableY.value = t - 0.001;
+        const legP = partMaterial(u, { kind: 'metal', slot: 3, tint: '#3a3a3a', roughness: 0.45, metalness: 1, axis: [0, 1, 0] });
+        mats.push(legP);
+        const legs = [];
+        for (const sx of [-1, 1])
+            for (const sz of [-1, 1])
+                legs.push(box(0.05, t - th, 0.05, [sx * (S.L / 2 - 0.25), (t - th) / 2, sz * (S.W / 2 - 0.2)]));
+        legs.push(box(S.L - 0.5, 0.04, 0.04, [0, 0.2, 0]), box(S.L - 0.1, 0.06, 0.02, [0, t - th - 0.03, S.W / 2 - 0.01]), box(S.L - 0.1, 0.06, 0.02, [0, t - th - 0.03, -S.W / 2 + 0.01]));
+        const lg = mergeGeos(legs);
+        geos.push(lg);
+        object.add(propMesh(lg, legP, 'legs'));
+    }
+    else {
+        u.uTableY.value = -1;
+        // the slab: a rounded rectangle (hockey rink corners), flat on the ground
+        const rc = Math.min((S.corner || 0) + Math.min(mx, mz) * 0.0, L / 2, W / 2);
+        const shape = new THREE.Shape();
+        const hx = L / 2, hz = W / 2, r = Math.max(0, rc);
+        if (r > 0.01) {
+            shape.moveTo(-hx + r, -hz);
+            shape.lineTo(hx - r, -hz);
+            shape.absarc(hx - r, -hz + r, r, -Math.PI / 2, 0, false);
+            shape.lineTo(hx, hz - r);
+            shape.absarc(hx - r, hz - r, r, 0, Math.PI / 2, false);
+            shape.lineTo(-hx + r, hz);
+            shape.absarc(-hx + r, hz - r, r, Math.PI / 2, Math.PI, false);
+            shape.lineTo(-hx, -hz + r);
+            shape.absarc(-hx + r, -hz + r, r, Math.PI, Math.PI * 1.5, false);
+        }
+        else {
+            shape.moveTo(-hx, -hz);
+            shape.lineTo(hx, -hz);
+            shape.lineTo(hx, hz);
+            shape.lineTo(-hx, hz);
+            shape.closePath();
+        }
+        // one slab 6 cm thick (top face at y = 0.02): a single geometry, so nothing can z-fight under the markings
+        const g = new THREE.ExtrudeGeometry(shape, { depth: 0.06, bevelEnabled: false, curveSegments: 12 + Math.round(12 * q) });
+        g.rotateX(Math.PI / 2);
+        g.translate(0, 0.02, 0); // XY → XZ, extruded downward; the top sits 2 cm proud of the ground
+        g.computeVertexNormals();
+        geos.push(g);
+        object.add(propMesh(g, pair, 'surface', { cast: false, receive: true }));
+    }
+    if (c.fixtures !== false) {
+        const G = GOAL_COLORS[S.fixtures[0] && S.fixtures[0].kind];
+        if (G) {
+            setColor(u.fixtureU.uColor, G.colors[0]);
+            setColor(u.fixtureU.uSecondaryColor, G.colors[1]);
+            setColor(u.fixtureU.uAccentColor, G.colors[2]);
+        }
+        for (const f of S.fixtures) {
+            const gl = buildGoal(f.kind, u.fixtureU, { quality: q, sag: 0.25, mesh: G ? G.mesh : undefined });
+            gl.object.position.set(f.x, S.table ? S.table : 0, 0);
+            gl.object.rotation.y = f.rot * Math.PI / 2;
+            object.add(gl.object);
+            fixtures.push(gl);
+        }
+    }
+    // ---- floodlights: masts with heads that glow at night, registered in the lamp list
+    const lamps = [], heads = [], aims = [];
+    const F = FLOOD[sportKey(c.sport)] || null;
+    if (c.floodlights !== false && F && !S.table) {
+        let lensP = null;
+        const poleP = partMaterial(u, { kind: 'metal', slot: 3, tint: '#8c9196', roughness: 0.45, metalness: 1, axis: [0, 1, 0] });
+        mats.push(poleP);
+        const headP = litMaterial(u, {
+            name: 'flood-head', roughness: 0.35, metalness: 0.6,
+            pars: /* glsl */ `uniform vec3 uFloodColor; uniform float uFloodGlow; uniform float uNight;`,
+            color: /* glsl */ `diffuseColor.rgb *= vec3(0.16);`,
+            // the lens faces down toward the court: it glows by the night factor, brighter than 1 so bloom can take it
+            emissive: /* glsl */ `{ vec3 nw = normalize(inverseTransformDirection(normal, viewMatrix)); totalEmissiveRadiance += uFloodColor * (uFloodGlow * uNight * 6.0 * (1.0 - smoothstep(-0.6, -0.2, nw.y))); }`,
+        });
+        mats.push(headP);
+        const poles = [], headGeos = [];
+        const addHead = (pole, head, tiltX, tiltZ, size) => {
+            const [w, d] = size;
+            headGeos.push(box(w, 0.14, d, head, [tiltX, 0, tiltZ]));
+            heads.push(new THREE.Vector3(head[0], head[1] - 0.15, head[2]));
+        };
+        if (F.mode === 'sides') {
+            // poles stand ON the slab's outer edge line: courts laid side by side share them (their poles
+            // coincide), as at a real club, instead of two poles a step apart
+            const zEdge = W / 2, reach = 1.6;
+            for (let i = 0; i < F.n; i++) {
+                const x = -L / 2 + L * (i + 0.5) / F.n;
+                for (const sz of [-1, 1]) {
+                    const zp = sz * zEdge, zh = sz * (zEdge - reach);
+                    poles.push(bar([x, 0, zp], [x, F.h + 0.2, zp], 0.07 + F.h * 0.004, 10), bar([x, F.h + 0.15, zp], [x, F.h + 0.15, zh], 0.04, 8));
+                    addHead([x, 0, zp], [x, F.h, zh], sz * -0.5, 0, [1.0, 0.55]);
+                }
+            }
+        }
+        else {
+            // stadium towers: a lattice-like mast (four legs braced to a platform) with a bank of
+            // projectors — dark housings, each with a lens that glows by the night factor
+            lensP = litMaterial(u, {
+                name: 'flood-lens', roughness: 0.2, metalness: 0,
+                pars: /* glsl */ `uniform vec3 uFloodColor; uniform float uFloodGlow; uniform float uNight;`,
+                color: /* glsl */ `diffuseColor.rgb = mix(vec3(0.55), uFloodColor, 0.3);`,
+                emissive: /* glsl */ `totalEmissiveRadiance += uFloodColor * (uFloodGlow * uNight * 9.0);`,
+            });
+            mats.push(lensP);
+            const lensGeos = [];
+            const o3 = new THREE.Object3D();
+            for (const sx of [-1, 1])
+                for (const sz of [-1, 1]) {
+                    const xp = sx * (L / 2 + F.set), zp = sz * (W / 2 + F.set), H = F.h;
+                    // the mast: four legs from a wide base to the platform, a few braces
+                    const b0 = 1.6, b1 = 0.7;
+                    for (const lx of [-1, 1])
+                        for (const lz of [-1, 1])
+                            poles.push(bar([xp + lx * b0, 0, zp + lz * b0], [xp + lx * b1, H - 2.2, zp + lz * b1], 0.16, 8));
+                    for (let k = 1; k <= 4; k++) {
+                        const y = (H - 2.2) * k / 5, t = k / 5, bb = b0 + (b1 - b0) * t;
+                        poles.push(bar([xp - bb, y, zp - bb], [xp + bb, y, zp - bb], 0.07, 6), bar([xp - bb, y, zp + bb], [xp + bb, y, zp + bb], 0.07, 6), bar([xp - bb, y, zp - bb], [xp - bb, y, zp + bb], 0.07, 6), bar([xp + bb, y, zp - bb], [xp + bb, y, zp + bb], 0.07, 6));
+                    }
+                    // the bank: a frame facing the field centre, tilted down toward it
+                    const to = new THREE.Vector3(-xp, -H, -zp).normalize();
+                    const yaw = Math.atan2(to.x, to.z);
+                    const bw = F.cols * 1.0 + 0.4, bh = F.rows * 0.85 + 0.4;
+                    const bankC = new THREE.Vector3(xp, H, zp).addScaledVector(new THREE.Vector3(to.x, 0, to.z).normalize(), 0.9);
+                    o3.position.copy(bankC);
+                    o3.rotation.set(0, yaw, 0);
+                    o3.rotateX(0.55);
+                    o3.updateMatrix();
+                    const frame = new THREE.BoxGeometry(bw, bh, 0.25);
+                    frame.applyMatrix4(new THREE.Matrix4().makeTranslation(0, 0, -0.45));
+                    frame.applyMatrix4(o3.matrix);
+                    poles.push(frame);
+                    poles.push(box(bw * 0.8, 0.3, 3.2, [xp, H - 2.2, zp], [0, yaw, 0])); // the service platform
+                    for (let r = 0; r < F.rows; r++)
+                        for (let k = 0; k < F.cols; k++) {
+                            const lx = (k - (F.cols - 1) / 2) * 1.0, ly = (r - (F.rows - 1) / 2) * 0.85;
+                            const m = new THREE.Matrix4().makeTranslation(lx, ly, 0).premultiply(o3.matrix);
+                            const hous = new THREE.BoxGeometry(0.82, 0.68, 0.5);
+                            hous.applyMatrix4(new THREE.Matrix4().makeTranslation(0, 0, -0.1));
+                            hous.applyMatrix4(m);
+                            poles.push(hous);
+                            const lens = new THREE.PlaneGeometry(0.7, 0.56);
+                            lens.applyMatrix4(new THREE.Matrix4().makeTranslation(0, 0, 0.152));
+                            lens.applyMatrix4(m);
+                            lensGeos.push(lens);
+                        }
+                    // one projector beam per field quarter, from the bank
+                    for (const qx of [-1, 1])
+                        for (const qz of [-1, 1]) {
+                            const tgt = new THREE.Vector3(qx * L / 4, 0, qz * W / 4);
+                            heads.push(bankC.clone());
+                            aims.push(tgt.sub(bankC).normalize());
+                        }
+                }
+            const lg = mergeGeos(lensGeos);
+            geos.push(lg);
+            object.add(propMesh(lg, lensP, 'projector lenses', { cast: false, receive: false }));
+        }
+        const pg = mergeGeos(poles);
+        geos.push(pg);
+        object.add(propMesh(pg, poleP, 'floodlight masts'));
+        if (headGeos.length) {
+            const hg = mergeGeos(headGeos);
+            geos.push(hg);
+            object.add(propMesh(hg, headP, 'floodlight heads', { receive: false }));
+        }
+        heads.forEach((p, i) => lamps.push(registerLamp({ id: aims[i] ? 'court-projector' : 'court-flood', position: p.clone(), color: new THREE.Color(c.floodColor || '#fff1dc'), radius: F.radius, intensity: F.I * (c.floodIntensity ?? 1), base: F.I, on: true,
+            aim: aims[i] ? aims[i].clone() : undefined, spread: F.spread })));
+    }
+    const inst = { mats: mats.map((p) => p.material), fixtures, fixtureMats: fixtures.flatMap((f) => f.mats.map((p) => p.material)), lamps };
+    applyConfig(u, c, inst);
+    // the playing surface's local bounds: the shared time-lighting hook (useTimeLighting) gathers
+    // the lamps that reach it, in world space, whenever the lamp list changes or the court moves
+    const localBox = new THREE.Box3(new THREE.Vector3(-L / 2, -0.1, -W / 2), new THREE.Vector3(L / 2, (S.table || 0) + 0.2, W / 2));
+    const lastWorld = new THREE.Matrix4();
+    return {
+        object,
+        materials: inst.mats.concat(inst.fixtureMats),
+        /** the uniform sets that take the sun block (uNight) and gather lamps — the TimeControls pattern */
+        uniformSets: [u],
+        bounds: function () { return localBox; },
+        apply: function (cfg) { applyConfig(u, cfg, inst); },
+        /** per frame: the shared clock, and this court's floodlights kept at their world positions (like urban's lamps) */
+        update: function (dt) {
+            updateCommon(u, dt);
+            if (!lamps.length)
+                return;
+            object.updateWorldMatrix(true, false);
+            if (!lastWorld.equals(object.matrixWorld)) {
+                lastWorld.copy(object.matrixWorld);
+                placeLamps(lamps, heads, object.matrixWorld); // positions, reach and falloff follow the object's scale
+                for (let i = 0; i < lamps.length; i++)
+                    if (aims[i])
+                        lamps[i].aim.copy(aims[i]).transformDirection(object.matrixWorld);
+                touchLamps();
+            }
+        },
+        stats: { size: [L, W], fixtures: fixtures.length, floodlights: lamps.length },
+        dispose: function () { for (const Lp of lamps)
+            unregisterLamp(Lp); geos.forEach((g) => g.dispose()); fixtures.forEach((f) => f.dispose()); mats.forEach(disposePair); },
+    };
+}
+/** Knobs whose change rebuilds the object (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['sport', 'surface', 'margin', 'fixtures', 'floodlights', 'quality', 'seed'];