@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/sports/sportsCore.js

@@ -0,0 +1,758 @@
+// Emitted from Claude outputs/sports-lab/common.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Shared core of the sports objects (lab). Emitted as packages/viewer/src/components/sports/sportsCore.ts.
+//
+// A sports object is a solid prop standing in the scene — a court, a ball, a piece of equipment, a
+// goal — built at REAL size in metres (a tennis court is 23.77 × 10.97 m, a football 22 cm across;
+// the transform scale starts at 1 and only places / resizes it). Everything is lit by the scene's
+// lights like a mesh and casts and receives shadows: every material is a three.js lit material
+// (MeshStandardMaterial) with the prop's own code injected through onBeforeCompile —
+//   fragment  procedural surfaces (acrylic, clay, wood planks, grass, ice, leather, felt, rubber,
+//             brushed metal, carbon weave), court markings and ball seams as anti-aliased signed
+//             distances (fwidth), wear as fbm scuffs where the play is, seams and dimples as bumps
+//             from screen-space derivatives (no tangent frames);
+//   vertex    nets sag by a catenary (uniform-driven), ball panels puff out between the seams.
+// Colour slots every variant shares: color (the main surface), secondaryColor (lines / second
+// panel / grip / net), accentColor (seams, paint, bands). Knobs describe the prop, never move it.
+import * as THREE from 'three';
+import { MAX_LAMPS, lampRegistry, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, createLampUniforms, gatherLamps, createSunUniforms, nightFromSun, applySun, GLSL_COMMON, } from '../urban/urbanCore.js';
+// Night lighting is the urban family's (one lamp list, one night factor): re-exported for the variants.
+export { MAX_LAMPS, lampRegistry, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, createLampUniforms, gatherLamps, createSunUniforms, nightFromSun, applySun, GLSL_COMMON, };
+export const DEG_S = Math.PI / 180;
+export const QUALITY_S = { low: 0.5, medium: 1, high: 2 };
+export 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;
+    };
+}
+export function setColor(uniform, v) {
+    if (v === undefined || v === null)
+        return;
+    if (v.isColor)
+        uniform.value.copy(v);
+    else
+        uniform.value.set(v);
+}
+export function injectUniforms(shader, u) { for (const k in u)
+    if (u[k] && typeof u[k] === 'object' && 'value' in u[k])
+        shader.uniforms[k] = u[k]; }
+// ---------------------------------------------------------------------------- uniforms / config
+/** Uniforms every sports object has (shared by all of its materials). */
+export function createCommonUniforms() {
+    return {
+        uTime: { value: 0 },
+        uColor: { value: new THREE.Color('#ffffff') },
+        uSecondaryColor: { value: new THREE.Color('#ffffff') },
+        uAccentColor: { value: new THREE.Color('#ffffff') },
+        uWear: { value: 0.2 },
+        uGloss: { value: 1 },
+        uOpacity: { value: 1 },
+        uSeed: { value: 0 },
+    };
+}
+/** The base knobs every sports object shares (push point, part 1). `mats` = every lit material of the object. */
+export function applyCommonConfig(u, c, mats = undefined) {
+    setColor(u.uColor, c.color);
+    setColor(u.uSecondaryColor, c.secondaryColor);
+    setColor(u.uAccentColor, c.accentColor);
+    if (c.wear !== undefined)
+        u.uWear.value = c.wear;
+    if (c.gloss !== undefined)
+        u.uGloss.value = c.gloss;
+    if (c.seed !== undefined)
+        u.uSeed.value = (c.seed % 1000) * 0.731;
+    if (c.opacity !== undefined) {
+        u.uOpacity.value = c.opacity;
+        if (mats)
+            for (const m of mats) {
+                m.opacity = c.opacity;
+                m.transparent = c.opacity < 0.999 || !!m.userData.alwaysTransparent;
+            }
+    }
+}
+/** Per-frame bookkeeping shared by every object. */
+export function updateCommon(u, dt) { u.uTime.value += dt; }
+// ---------------------------------------------------------------------------- GLSL: shared pieces
+export const SPORT_UNIFORMS_GLSL = /* glsl */ `
+uniform float uTime, uWear, uGloss, uOpacity, uSeed;
+uniform vec3 uColor, uSecondaryColor, uAccentColor;
+varying vec3 vObj;
+varying vec3 vWorldPos;
+`;
+export const NOISE_GLSL_S = /* glsl */ `
+float shash12(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); }
+float shash13(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }
+float snoise2(vec2 p) {
+    vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    return mix(mix(shash12(i), shash12(i + vec2(1, 0)), f.x), mix(shash12(i + vec2(0, 1)), shash12(i + vec2(1, 1)), f.x), f.y);
+}
+float snoise3(vec3 p) {
+    vec3 i = floor(p); vec3 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    return mix(mix(mix(shash13(i), shash13(i + vec3(1, 0, 0)), f.x), mix(shash13(i + vec3(0, 1, 0)), shash13(i + vec3(1, 1, 0)), f.x), f.y),
+               mix(mix(shash13(i + vec3(0, 0, 1)), shash13(i + vec3(1, 0, 1)), f.x), mix(shash13(i + vec3(0, 1, 1)), shash13(i + vec3(1, 1, 1)), f.x), f.y), f.z);
+}
+float sfbm2(vec2 p) { return (0.5 * snoise2(p) + 0.25 * snoise2(p * 2.03 + 7.1) + 0.125 * snoise2(p * 4.07 + 3.3)) / 0.875; }
+float sfbm3(vec3 p) { return (0.5 * snoise3(p) + 0.25 * snoise3(p * 2.03 + 7.1) + 0.125 * snoise3(p * 4.07 + 3.3)) / 0.875; }
+// anti-aliased line coverage of a signed distance d (metres) for a line of width w
+float aaLine(float d, float w) { float fw = fwidth(d) * 0.75 + 1e-5; return 1.0 - smoothstep(w * 0.5 - fw, w * 0.5 + fw, abs(d)); }
+float aaStep(float d) { float fw = fwidth(d) * 0.75 + 1e-5; return smoothstep(-fw, fw, d); }
+float sdSeg(vec2 p, vec2 a, vec2 b) { vec2 pa = p - a, ba = b - a; float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0); return length(pa - ba * h); }
+float sdBox2(vec2 p, vec2 b) { vec2 d = abs(p) - b; return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0); }
+// distance to the outline of a box / circle / arc (for line marking)
+float lnBox(vec2 p, vec2 c, vec2 hb) { return abs(sdBox2(p - c, hb)); }
+float lnCircle(vec2 p, vec2 c, float r) { return abs(length(p - c) - r); }
+// arc of a circle between angles a0..a1 (radians, counter-clockwise from +x); outside the span, distance to the end points
+float lnArc(vec2 p, vec2 c, float r, float a0, float a1) {
+    vec2 q = p - c; float a = atan(q.y, q.x);
+    float mid = 0.5 * (a0 + a1), hw = 0.5 * (a1 - a0);
+    float da = mod(a - mid + 3.14159265, 6.2831853) - 3.14159265;
+    if (abs(da) <= hw) return abs(length(q) - r);
+    vec2 e0 = c + r * vec2(cos(a0), sin(a0)), e1 = c + r * vec2(cos(a1), sin(a1));
+    return min(length(p - e0), length(p - e1));
+}
+`;
+export const WEAR_GLSL = /* glsl */ `
+// Scuffs: two fbm layers thresholded by uWear, 0 pristine .. 1 heavily worn; focus (0..1) raises the wear
+// where the play is (a key, a baseline, the sweet spot) so it never looks like uniform noise.
+float scuffs(vec3 p, float scale, float focus) {
+    float n = sfbm3(p * scale + uSeed * 7.0) * 0.65 + sfbm3(p * scale * 4.3 + 13.0) * 0.35;
+    float t = 1.0 - clamp(uWear * (0.55 + 0.9 * focus), 0.0, 1.0);
+    return smoothstep(t - 0.05, t + 0.3, n) * clamp(uWear * 2.0, 0.0, 1.0);
+}
+// a height field as a bump, from screen-space derivatives (no tangent frame needed)
+vec3 bumpNormal(vec3 normal, float h) {
+    vec3 dpdx = dFdx(-vViewPosition), dpdy = dFdy(-vViewPosition);
+    float dhx = dFdx(h), dhy = dFdy(h);
+    vec3 r1 = cross(dpdy, normal), r2 = cross(normal, dpdx);
+    float det = dot(dpdx, r1);
+    vec3 grad = (r1 * dhx + r2 * dhy) / max(abs(det), 1e-7) * sign(det);
+    return normalize(normal - grad);
+}
+`;
+const COMMON_VERT_PARS = /* glsl */ `
+varying vec3 vObj;
+varying vec3 vWorldPos;
+`;
+/**
+ * A lit material (MeshStandardMaterial) with the prop's code injected, plus its depth twin for
+ * shadows (same vertex displacement, same alpha cut). Hooks (GLSL strings):
+ *   pars      fragment declarations (functions, uniforms of `own`)
+ *   color     sets `diffuseColor.rgb` (and `.a` for cut-outs); runs at map_fragment
+ *   rough     expression for roughnessFactor (default o.roughness)
+ *   metal     expression for metalnessFactor
+ *   normal    code that may reassign `normal` (after normal_fragment_maps)
+ *   emissive  code adding to totalEmissiveRadiance
+ *   vPars / vCode   vertex declarations / code after begin_vertex (may edit `transformed`, `objectNormal` is already read)
+ *   depthBias       [factor, units] polygon offset for a surface laid on other ground surfaces
+ * Every material gets vObj (object-space position) and vWorldPos.
+ */
+export function litMaterial(u, o) {
+    const own = o.own || {};
+    const mat = new THREE.MeshStandardMaterial({
+        color: 0xffffff, roughness: o.roughness ?? 0.7, metalness: o.metalness ?? 0, envMapIntensity: o.envMapIntensity ?? 0.6,
+        side: o.side ?? THREE.FrontSide, transparent: !!o.transparent, alphaTest: o.alphaTest ?? 0, depthWrite: o.depthWrite ?? true,
+    });
+    if (o.transparent)
+        mat.userData.alwaysTransparent = true;
+    // A ground surface laid on other ground surfaces (a court on a plaza, a park lawn, a road) sits only
+    // centimetres above them; urban paving already pulls itself toward the camera in depth (polygon offset
+    // -2 / -4) to beat the terrain, so at a distance it would beat the court too. `depthBias` [factor, units]
+    // pulls this surface further forward — depth only, nothing moves on screen.
+    if (o.depthBias) {
+        mat.polygonOffset = true;
+        mat.polygonOffsetFactor = o.depthBias[0];
+        mat.polygonOffsetUnits = o.depthBias[1];
+    }
+    mat.defines = { USE_UV: '' };
+    mat.userData.uniforms = own;
+    const vert = (shader) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = shader.vertexShader
+            .replace('#include <common>', `#include <common>\n${COMMON_VERT_PARS}\n${SPORT_UNIFORMS_GLSL.replace(/varying[^\n]*\n/g, '')}\n${o.vPars || ''}`)
+            .replace('#include <begin_vertex>', `#include <begin_vertex>\n    vObj = position;\n    ${o.vCode || ''}\n    vWorldPos = (modelMatrix * vec4(transformed, 1.0)).xyz;`);
+    };
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${SPORT_UNIFORMS_GLSL}\n${NOISE_GLSL_S}\n${WEAR_GLSL}\n${o.pars || ''}`)
+            .replace('#include <map_fragment>', `${o.color || ''}\n    float propRough = ${o.rough ? '(' + o.rough + ')' : 'roughness'};\n    float propMetal = ${o.metal ? '(' + o.metal + ')' : 'metalness'};`)
+            .replace('#include <roughnessmap_fragment>', '#include <roughnessmap_fragment>\n    roughnessFactor = clamp(propRough, 0.03, 1.0);')
+            .replace('#include <metalnessmap_fragment>', '#include <metalnessmap_fragment>\n    metalnessFactor = propMetal;')
+            .replace('#include <normal_fragment_maps>', `#include <normal_fragment_maps>\n    ${o.normal || ''}`)
+            .replace('#include <emissivemap_fragment>', `#include <emissivemap_fragment>\n    ${o.emissive || ''}`);
+    };
+    mat.customProgramCacheKey = () => 'sport-' + (o.name || 'lit');
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking, side: o.side ?? THREE.FrontSide });
+    depth.defines = { USE_UV: '' };
+    if (o.alphaTest || o.transparent)
+        depth.alphaTest = o.depthAlphaTest ?? 0.5;
+    depth.onBeforeCompile = (shader) => {
+        vert(shader);
+        if (o.depthAlpha) {
+            shader.fragmentShader = shader.fragmentShader
+                .replace('#include <common>', `#include <common>\n${SPORT_UNIFORMS_GLSL}\n${NOISE_GLSL_S}\n${o.pars || ''}`)
+                .replace('#include <map_fragment>', `${o.depthAlpha}`);
+        }
+    };
+    depth.customProgramCacheKey = () => 'sport-' + (o.name || 'lit') + '-depth';
+    return { material: mat, depth };
+}
+/** A prop mesh: casts and receives shadows, picks normally (props are clickable scene objects). */
+export function propMesh(geo, pair, name = '', opts = undefined) {
+    const o = Object.assign({ cast: true, receive: true, cull: true }, opts);
+    const mesh = new THREE.Mesh(geo, pair.material);
+    mesh.customDepthMaterial = pair.depth;
+    mesh.castShadow = o.cast;
+    mesh.receiveShadow = o.receive;
+    mesh.frustumCulled = o.cull;
+    mesh.name = name || '';
+    return mesh;
+}
+export function disposePair(pair) { pair.material.dispose(); pair.depth.dispose(); }
+// ---------------------------------------------------------------------------- geometry helpers
+/** Concatenate geometries (made non-indexed) that share a material. */
+export function mergeGeos(list) {
+    const parts = list.map((g) => (g.index ? g.toNonIndexed() : g));
+    let n = 0;
+    for (const g of parts)
+        n += g.attributes.position.count;
+    const pos = new Float32Array(n * 3), nrm = new Float32Array(n * 3), uv = new Float32Array(n * 2);
+    let off = 0;
+    for (const g of parts) {
+        const c = g.attributes.position.count;
+        pos.set(g.attributes.position.array, off * 3);
+        if (g.attributes.normal)
+            nrm.set(g.attributes.normal.array, off * 3);
+        if (g.attributes.uv)
+            uv.set(g.attributes.uv.array, off * 2);
+        off += c;
+    }
+    const out = new THREE.BufferGeometry();
+    out.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    out.setAttribute('normal', new THREE.BufferAttribute(nrm, 3));
+    out.setAttribute('uv', new THREE.BufferAttribute(uv, 2));
+    for (const g of parts)
+        if (!list.includes(g))
+            g.dispose();
+    out.computeBoundingSphere();
+    out.computeBoundingBox();
+    return out;
+}
+/** Apply a matrix (position / rotation / scale) to a geometry in place and return it. */
+export function placed(geo, pos = undefined, rotEuler = undefined, scale = undefined) {
+    const m = new THREE.Matrix4();
+    const q = new THREE.Quaternion();
+    if (rotEuler)
+        q.setFromEuler(new THREE.Euler(rotEuler[0] || 0, rotEuler[1] || 0, rotEuler[2] || 0));
+    m.compose(new THREE.Vector3(...(pos || [0, 0, 0])), q, new THREE.Vector3(...(scale || [1, 1, 1])));
+    geo.applyMatrix4(m);
+    return geo;
+}
+/** Lathe from a profile of [radius, y] pairs (bottom → top). */
+export function lathe(profile, segs = 32) {
+    const pts = profile.map(([r, y]) => new THREE.Vector2(r, y));
+    const g = new THREE.LatheGeometry(pts, segs || 32);
+    return g;
+}
+/** A tube along points (metres), round section. */
+export function tube(points, radius, segs = 32, radial = 10, closed = false) {
+    const curve = new THREE.CatmullRomCurve3(points.map((p) => new THREE.Vector3(...p)), !!closed, 'catmullrom', 0.5);
+    return new THREE.TubeGeometry(curve, segs || 32, radius, radial || 10, !!closed);
+}
+/** A straight cylinder between two points. */
+export function bar(a, b, r, radial = 12) {
+    const A = new THREE.Vector3(...a), B = new THREE.Vector3(...b);
+    const len = A.distanceTo(B);
+    const g = new THREE.CylinderGeometry(r, r, len, radial || 12, 1);
+    const mid = A.clone().add(B).multiplyScalar(0.5);
+    const dir = B.clone().sub(A).normalize();
+    const q = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), dir);
+    g.applyQuaternion(q);
+    g.translate(mid.x, mid.y, mid.z);
+    return g;
+}
+export function box(w, h, d, pos = undefined, rot = undefined) { return placed(new THREE.BoxGeometry(w, h, d), pos, rot); }
+// ---------------------------------------------------------------------------- the material library
+/**
+ * The surfaces equipment, goals and fixtures are made of, one shader with a per-part kind:
+ *   0 paint     smooth coat with a faint orange peel, chips where worn
+ *   1 wood      grain along the part's own long axis (uGrainAxis), ash / maple tones, scuffed where worn
+ *   2 metal     brushed (anisotropic streaks along the axis), fingerprints where worn, metallic
+ *   3 rubber    matte with a fine stipple, lighter where worn
+ *   4 leather   pebble grain bump, darker creases, polished where handled
+ *   5 carbon    twill weave, glossy clear coat
+ *   6 plastic   glossy, slight flow lines
+ *   7 fabric    felt / cloth, soft nap (no specular)
+ * Colour: `slot` 0 color · 1 secondaryColor · 2 accentColor · 3 the part's own uTint (natural material colour).
+ * A multiplier uTint always applies (white = as is).
+ */
+export const PART_KINDS = { paint: 0, wood: 1, metal: 2, rubber: 3, leather: 4, carbon: 5, plastic: 6, fabric: 7 };
+export function partMaterial(u, o = undefined) {
+    const opt = Object.assign({ kind: 'paint', slot: 3, tint: '#cccccc', roughness: 0.5, metalness: 0, axis: [1, 0, 0], scale: 1 }, o);
+    const own = {
+        uKind: { value: PART_KINDS[opt.kind] ?? 0 },
+        uSlot: { value: opt.slot },
+        uTint: { value: new THREE.Color(opt.tint) },
+        uGrainAxis: { value: new THREE.Vector3(...opt.axis).normalize() },
+        uPartScale: { value: opt.scale },
+    };
+    const pair = litMaterial(u, {
+        name: 'part-' + opt.kind,
+        own, roughness: opt.roughness, metalness: opt.metalness, envMapIntensity: opt.kind === 'metal' ? 1.0 : 0.6,
+        pars: /* glsl */ `
+uniform float uKind, uSlot, uPartScale;
+uniform vec3 uTint, uGrainAxis;
+vec3 slotColor() {
+    vec3 c = uSlot < 0.5 ? uColor : uSlot < 1.5 ? uSecondaryColor : uSlot < 2.5 ? uAccentColor : uTint;
+    return uSlot < 2.5 ? c * uTint : c;
+}
+// coordinates along / across the part's grain axis, in metres
+vec2 grainUV(vec3 p) {
+    vec3 a = uGrainAxis; vec3 b = normalize(abs(a.y) < 0.9 ? cross(a, vec3(0, 1, 0)) : cross(a, vec3(1, 0, 0)));
+    vec3 c = cross(a, b);
+    return vec2(dot(p, a), dot(p, b) + dot(p, c) * 0.37);
+}
+float partHeight; float partRough; float partMetalF; vec3 partCol;
+void partSurface(vec3 p) {
+    vec3 base = slotColor();
+    vec2 g = grainUV(p) / uPartScale;
+    float worn = scuffs(p, 28.0 / uPartScale, 0.6);
+    partHeight = 0.0; partRough = roughness; partMetalF = metalness; partCol = base;
+    if (uKind < 0.5) {           // paint: orange peel, chips show primer
+        float peel = snoise3(p * 900.0) * 0.5 + 0.5;
+        partHeight = peel * 0.00004;
+        partCol = mix(base, base * 0.55 + 0.2, worn * 0.8);
+        partRough = mix(0.25, 0.6, worn) + peel * 0.05;
+    } else if (uKind < 1.5) {    // wood: rings as long streaks along the axis, pores, darker where oiled by hands
+        float ring = sfbm2(vec2(g.x * 6.0, g.y * 90.0));
+        float pores = snoise2(vec2(g.x * 400.0, g.y * 1400.0));
+        float grain = smoothstep(0.35, 0.75, ring) * 0.7 + pores * 0.15;
+        partCol = base * mix(vec3(1.08, 1.03, 0.95), vec3(0.72, 0.6, 0.48), grain);
+        partCol = mix(partCol, partCol * 0.6, worn * 0.7);
+        partHeight = grain * 0.00006;
+        partRough = mix(0.55, 0.85, grain) + worn * 0.1;
+    } else if (uKind < 2.5) {    // metal: brushed streaks, dull where handled
+        float streak = snoise2(vec2(g.x * 60.0, g.y * 2500.0));
+        partCol = base * (0.92 + 0.16 * streak);
+        partRough = mix(0.28, 0.5, streak * 0.5 + worn * 0.5);
+        partMetalF = 1.0 - worn * 0.3;
+        partHeight = streak * 0.00002;
+    } else if (uKind < 3.5) {    // rubber: stipple, polished where worn
+        float st = snoise3(p * 1500.0);
+        partCol = mix(base, base * 1.6 + 0.08, worn * 0.5);
+        partHeight = st * 0.00005;
+        partRough = mix(0.9, 0.55, worn);
+    } else if (uKind < 4.5) {    // leather: pebble grain, creases
+        float peb = snoise3(p * 700.0) * 0.6 + snoise3(p * 2100.0) * 0.4;
+        float crease = smoothstep(0.55, 0.75, sfbm3(p * 90.0 + 3.0));
+        partCol = base * (0.85 + 0.3 * peb) * (1.0 - 0.25 * crease);
+        partCol = mix(partCol, partCol * 1.25, worn * 0.5);
+        partHeight = peb * 0.00012;
+        partRough = mix(0.65, 0.35, worn) - 0.1 * crease;
+    } else if (uKind < 5.5) {    // carbon: 2x2 twill weave under a clear coat
+        vec2 w = g * 700.0;
+        float tw = step(0.5, fract((floor(w.x) + floor(w.y)) * 0.5));
+        float fib = mix(abs(fract(w.x) - 0.5), abs(fract(w.y) - 0.5), tw) * 2.0;
+        partCol = base * mix(0.55, 1.15, 1.0 - fib * fib) ;
+        partRough = 0.18 + worn * 0.25;
+        partHeight = (1.0 - fib) * 0.00001;
+    } else if (uKind < 6.5) {    // plastic: glossy with flow lines
+        float fl = snoise2(g * vec2(30.0, 400.0));
+        partCol = base * (0.96 + 0.08 * fl);
+        partCol = mix(partCol, partCol * 0.8 + 0.1, worn * 0.6);
+        partRough = 0.22 + worn * 0.3;
+    } else {                     // fabric / felt: soft nap, no shine
+        float nap = snoise3(p * 2500.0);
+        partCol = base * (0.9 + 0.2 * nap);
+        partCol = mix(partCol, partCol * 0.7, worn * 0.5);
+        partRough = 1.0;
+        partHeight = nap * 0.00008;
+    }
+    partRough = clamp(partRough / max(uGloss, 0.05), 0.03, 1.0);
+}`,
+        color: /* glsl */ `partSurface(vObj);\n    diffuseColor.rgb *= partCol;`,
+        rough: 'partRough', metal: 'partMetalF',
+        normal: /* glsl */ `normal = bumpNormal(normal, partHeight);`,
+    });
+    return pair;
+}
+// ---------------------------------------------------------------------------- nets
+/**
+ * A net: knotted square mesh drawn as anti-aliased threads (alpha-cut, with a translucent far field so a
+ * distant net reads as a veil instead of shimmering), on a ruled surface spanned between two frame
+ * curves (netRuled). The sag is a uniform (so netTension animates): every vertex moves along its own
+ * aSag (direction × metres, set at build: out of the goal, down for a roof) by
+ *   uSag × 4s(1−s) × profile(t)       profile: hanging (bottom free) 1−t · held on both edges 4t(1−t)
+ * where s runs along the frame curves and t from the first curve to the second.
+ */
+export function netMaterial(u, o = undefined) {
+    const opt = Object.assign({ mesh: 0.12, thread: 0.004, sag: 0.1, sagMode: 1, slot: 1 }, o);
+    const own = {
+        uMesh: { value: opt.mesh }, uThread: { value: opt.thread }, uSag: { value: opt.sag }, uSagMode: { value: opt.sagMode },
+        uNetSlot: { value: opt.slot },
+    };
+    const pars = /* glsl */ `
+uniform float uMesh, uThread, uNetSlot;
+float netCover(vec2 m) {
+    // square mesh with knots at the crossings; m in metres
+    vec2 c = m / uMesh;
+    vec2 d = abs(fract(c) - 0.5) * uMesh;          // distance to the nearest thread in each direction
+    float w = uThread;
+    float fw = max(fwidth(m.x), fwidth(m.y)) * 0.7 + 1e-5;
+    float tx = 1.0 - smoothstep(w * 0.5 - fw, w * 0.5 + fw, d.x);
+    float ty = 1.0 - smoothstep(w * 0.5 - fw, w * 0.5 + fw, d.y);
+    float knot = 1.0 - smoothstep(w * 0.9 - fw, w * 0.9 + fw, length(d));
+    float cover = max(max(tx, ty), knot);
+    // far field: when a cell is a few pixels the threads can't be resolved — fade to the mean coverage
+    float far = smoothstep(0.08, 0.5, fw / uMesh);
+    // two thread directions plus knots, seen a little obliquely: reads denser than the bare 2w/mesh
+    float mean = clamp(2.6 * w / uMesh, 0.0, 0.85);
+    return mix(cover, mean, far);
+}`;
+    const pair = litMaterial(u, {
+        name: 'net', own, roughness: 0.85, metalness: 0, side: THREE.DoubleSide, transparent: true, alphaTest: 0.02, depthWrite: true,
+        vPars: /* glsl */ `uniform float uSag, uSagMode; attribute vec2 aT; attribute vec3 aSag;`,
+        vCode: /* glsl */ `
+    {
+        float across = 4.0 * aT.x * (1.0 - aT.x);
+        float prof = uSagMode < 0.5 ? (1.0 - aT.y) : 4.0 * aT.y * (1.0 - aT.y);
+        transformed += aSag * (uSag * across * prof);
+    }`,
+        pars,
+        color: /* glsl */ `
+    float cover = netCover(vUv);
+    vec3 nc = uNetSlot < 0.5 ? uColor : uNetSlot < 1.5 ? uSecondaryColor : uAccentColor;
+    float dirt = scuffs(vWorldPos, 3.0, 0.3);
+    diffuseColor.rgb *= mix(nc, nc * 0.6, dirt * 0.6);
+    diffuseColor.a *= cover;`,
+        depthAlpha: /* glsl */ `diffuseColor.a *= netCover(vUv);`,
+        rough: '0.9',
+    });
+    pair.material.userData.net = true;
+    return pair;
+}
+/**
+ * A net surface spanned between two curves A(s) and B(s), s in 0..1 (both [x, y, z] in metres): the
+ * vertex at (s, t) is A(s)·(1−t) + B(s)·t. uv in metres (arc length along the mid curve, distance
+ * across) so the mesh cells stay square on any trapezoid or curved strip. sag(s) → [x, y, z]: the
+ * direction × metres this vertex bellies at netTension 0.
+ */
+export function netRuled(A, B, nS, nT, sag) {
+    const pos = [], uv = [], at = [], sg = [], idx = [];
+    // arc length of the mid curve for u
+    const mids = [], acc = [0];
+    for (let i = 0; i <= nS; i++) {
+        const s = i / nS, a = A(s), b = B(s);
+        mids.push([(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2]);
+    }
+    for (let i = 1; i <= nS; i++)
+        acc.push(acc[i - 1] + Math.hypot(mids[i][0] - mids[i - 1][0], mids[i][1] - mids[i - 1][1], mids[i][2] - mids[i - 1][2]));
+    for (let i = 0; i <= nS; i++) {
+        const s = i / nS, a = A(s), b = B(s), g = sag(s);
+        const span = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+        for (let j = 0; j <= nT; j++) {
+            const t = j / nT;
+            pos.push(a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t);
+            uv.push(acc[i], span * t);
+            at.push(s, t);
+            sg.push(g[0], g[1], g[2]);
+        }
+    }
+    for (let i = 0; i < nS; i++)
+        for (let j = 0; j < nT; j++) {
+            const k = i * (nT + 1) + j;
+            idx.push(k, k + nT + 1, k + 1, k + 1, k + nT + 1, k + nT + 2);
+        }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    g.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+    g.setAttribute('aT', new THREE.Float32BufferAttribute(at, 2));
+    g.setAttribute('aSag', new THREE.Float32BufferAttribute(sg, 3));
+    g.setIndex(idx);
+    g.computeVertexNormals();
+    g.computeBoundingSphere();
+    g.computeBoundingBox();
+    return g;
+}
+const line3 = (p, q) => (s) => [p[0] + (q[0] - p[0]) * s, p[1] + (q[1] - p[1]) * s, p[2] + (q[2] - p[2]) * s];
+/** One net mesh = one net material (each net has its own sag share and mode). */
+export function netMesh(geo, pair) {
+    const m = new THREE.Mesh(geo, pair.material);
+    m.customDepthMaterial = pair.depth;
+    m.castShadow = true;
+    m.receiveShadow = false;
+    return m;
+}
+// ---------------------------------------------------------------------------- goals (shared by `goal` and a court's fixtures)
+export const GOAL_KINDS = ['footballGoal', 'futsalGoal', 'handballGoal', 'hockeyNet', 'basketballHoop', 'volleyballNet', 'tennisNet', 'badmintonNet', 'rugbyPosts', 'americanUprights'];
+/** Natural colours of every goal / net kind, [posts / frame, mesh, tapes / pads / board frame], and its default mesh size (m). */
+export const GOAL_COLORS = {
+    footballGoal: { colors: ['#f4f4f2', '#f2f2f2', '#f4f4f2'], mesh: 0.12 },
+    futsalGoal: { colors: ['#f4f4f2', '#f2f2f2', '#f4f4f2'], mesh: 0.1 },
+    handballGoal: { colors: ['#f4f4f2', '#f2f2f2', '#d13b2a'], mesh: 0.1 },
+    hockeyNet: { colors: ['#d12f2f', '#f2f2f2', '#f2f2f2'], mesh: 0.045 },
+    basketballHoop: { colors: ['#b9bcc0', '#f2f2f2', '#f2f2f2'], mesh: 0.06 },
+    volleyballNet: { colors: ['#b9bcc0', '#1a1a1a', '#f2f2f2'], mesh: 0.1 },
+    tennisNet: { colors: ['#2a2a2a', '#1a1a1a', '#f2f2f2'], mesh: 0.045 },
+    badmintonNet: { colors: ['#2a2a2a', '#4a2a1e', '#f2f2f2'], mesh: 0.019 },
+    pickleballNet: { colors: ['#2a2a2a', '#1a1a1a', '#f2f2f2'], mesh: 0.04 },
+    padelNet: { colors: ['#2a2a2a', '#1a1a1a', '#f2f2f2'], mesh: 0.045 },
+    tableTennisNet: { colors: ['#2a2a2a', '#1f3f86', '#f2f2f2'], mesh: 0.012 },
+    rugbyPosts: { colors: ['#f4f4f2', '#f2f2f2', '#1d4f9c'], mesh: 0.1 },
+    americanUprights: { colors: ['#f2c230', '#f2f2f2', '#1d4f9c'], mesh: 0.1 },
+};
+/**
+ * Builds a goal / net / hoop at the origin (the goal line, the net's centre, the hoop's base on the
+ * ground), facing +z (the play side). Returns { object, mats, nets, apply(cfg), dispose }.
+ * Dimensions are the rulebook ones. Materials: posts = slot 0 (color), nets = slot 1, pads / boards /
+ * bands = slot 2.
+ */
+export function buildGoal(kind, u, o = undefined) {
+    const opt = Object.assign({ mesh: undefined, net: true, quality: 1, sag: 0.3 }, o);
+    const object = new THREE.Group();
+    const mats = [], nets = [], geos = [];
+    const paint = (slot, kindName = undefined, extra = undefined) => { const p = partMaterial(u, Object.assign({ kind: kindName || 'paint', slot, tint: '#ffffff', roughness: 0.35 }, extra)); mats.push(p); return p; };
+    const addMesh = (geo, pair, name = '') => { geos.push(geo); const m = propMesh(geo, pair, name); object.add(m); return m; };
+    // np: { mesh, thread, k (this net's share of the sag at netTension 0) }; mode 0 hanging (bottom free), 1 held on all edges
+    const addNet = (geo, np, mode = undefined) => {
+        if (!opt.net) {
+            geo.dispose();
+            return null;
+        }
+        const k = np.k ?? 1;
+        const pair = netMaterial(u, { mesh: np.mesh, thread: np.thread, sag: opt.sag * k, sagMode: mode ?? 1, slot: 1 });
+        mats.push(pair);
+        geos.push(geo);
+        const m = netMesh(geo, pair);
+        m.userData.sagK = k;
+        object.add(m);
+        nets.push(m);
+        return m;
+    };
+    const R = 10 + Math.round(6 * opt.quality);
+    const nq = (len) => Math.max(4, Math.round(len * 4 * opt.quality)); // net segments for a length
+    /**
+     * The nets of a box goal (football, futsal, handball), spanned between the frame's own bars:
+     *   posts (±W/2, 0..H, 0), crossbar at H, ground bars to the back bar (x, 0, −D), top-rear bar at
+     *   (x, Hb, −D), stanchions from the crossbar corners down to it. Back and roof belly out / down,
+     *   the sides belly outward; every edge sits on a bar.
+     */
+    const boxGoalNets = (W, H, D, Hb, np) => {
+        const x0 = -W / 2, x1 = W / 2;
+        addNet(netRuled(line3([x0, 0, -D], [x1, 0, -D]), line3([x0, Hb, -D], [x1, Hb, -D]), nq(W), nq(Hb), () => [0, 0, -0.35]), np, 1); // back
+        addNet(netRuled(line3([x0, H, 0], [x1, H, 0]), line3([x0, Hb, -D], [x1, Hb, -D]), nq(W), nq(D), () => [0, -0.25, 0]), np, 1); // roof
+        for (const x of [x0, x1]) {
+            const out = Math.sign(x) * 0.2;
+            addNet(netRuled(line3([x, 0, 0], [x, 0, -D]), line3([x, H, 0], [x, Hb, -D]), nq(D), nq(H), () => [out, 0, 0]), np, 1); // side
+        }
+    };
+    const boxGoalFrame = (W, H, D, Hb, r) => {
+        const rb = r * 0.5;
+        return [
+            bar([-W / 2, rb, 0], [-W / 2, rb, -D], rb, 8), bar([W / 2, rb, 0], [W / 2, rb, -D], rb, 8), bar([-W / 2, rb, -D], [W / 2, rb, -D], rb, 8),
+            bar([-W / 2, Hb, -D], [W / 2, Hb, -D], rb, 8), bar([-W / 2, rb, -D], [-W / 2, Hb, -D], rb, 8), bar([W / 2, rb, -D], [W / 2, Hb, -D], rb, 8),
+            bar([-W / 2, H, 0], [-W / 2, Hb, -D], rb, 8), bar([W / 2, H, 0], [W / 2, Hb, -D], rb, 8),
+        ];
+    };
+    const frameGoal = (W, H, D, r, postPair, meshSize) => {
+        const Hb = H * 0.8;
+        const parts = [bar([-W / 2, 0, 0], [-W / 2, H + r, 0], r, R), bar([W / 2, 0, 0], [W / 2, H + r, 0], r, R), bar([-W / 2 - r, H + r, 0], [W / 2 + r, H + r, 0], r, R)];
+        addMesh(mergeGeos(parts.concat(boxGoalFrame(W, H, D, Hb, r))), postPair, 'frame');
+        boxGoalNets(W, H, D, Hb, { mesh: meshSize, thread: Math.min(0.005, meshSize * 0.045) });
+    };
+    /**
+     * A net across a court, along x at z = 0 (the court builder turns it across the court). n:
+     *   posts      distance between the posts (m)          netW    net length (≤ posts; cables run on to the posts)
+     *   top        height of the top of the net at the posts  dip   how much lower it is at the centre (tennis 1.07 → 0.914)
+     *   depth      net depth (top to bottom edge)           grounded  the bottom edge rests on the ground (tennis, pickleball, padel)
+     *   band       top tape height                          strap   centre strap (tennis, pickleball, padel)
+     *   antennae   volleyball antennae + side bands at ±antennae
+     * The top edge, its tape and the mesh follow the dip as a parabola between the posts.
+     */
+    const netOnPosts = (n, meshSize, postPair, bandPair) => {
+        const L = n.posts, W = n.netW ?? n.posts, Htop = n.top, dip = n.dip ?? 0, D = n.depth ?? n.top, bandH = n.band, postR = n.postR;
+        const topAt = (x) => Htop - dip * (1 - (2 * x / W) ** 2); // x in [-W/2, W/2]
+        const bottomAt = (x) => (n.grounded ? 0 : topAt(x) - D);
+        addMesh(mergeGeos([bar([-L / 2, 0, 0], [-L / 2, Htop + 0.03, 0], postR, R), bar([L / 2, 0, 0], [L / 2, Htop + 0.03, 0], postR, R)]), postPair, 'posts');
+        // cables from the net's ends to the posts (only when the net is shorter than the post span)
+        const cables = [];
+        if (L - W > 0.05)
+            for (const sx of [-1, 1]) {
+                cables.push(bar([sx * W / 2, Htop - bandH / 2, 0], [sx * L / 2, Htop - bandH / 2, 0], 0.003, 6));
+                if (!n.grounded)
+                    cables.push(bar([sx * W / 2, Htop - D + 0.02, 0], [sx * L / 2, Htop - D + 0.02, 0], 0.003, 6));
+            }
+        if (cables.length)
+            addMesh(mergeGeos(cables), postPair, 'cables');
+        // tapes: the top band follows the dip (short boxes along the parabola), a bottom band on hanging nets, the centre strap
+        const tape = (yAt, h, thick) => {
+            const seg = 32, parts = [];
+            for (let i = 0; i < seg; i++) {
+                const x0 = -W / 2 + W * i / seg, x1 = -W / 2 + W * (i + 1) / seg;
+                const y0 = yAt(x0), y1 = yAt(x1), len = Math.hypot(x1 - x0, y1 - y0);
+                parts.push(box(len + 0.002, h, thick, [(x0 + x1) / 2, (y0 + y1) / 2 - h / 2, 0], [0, 0, Math.atan2(y1 - y0, x1 - x0)]));
+            }
+            return mergeGeos(parts);
+        };
+        const bands = [tape(topAt, bandH, 0.012)];
+        if (!n.grounded)
+            bands.push(tape((x) => bottomAt(x) + bandH * 0.6, bandH * 0.6, 0.01));
+        if (n.strap)
+            bands.push(box(0.05, topAt(0), 0.014, [0, topAt(0) / 2, 0]));
+        if (n.antennae)
+            for (const sx of [-1, 1])
+                bands.push(box(0.05, D, 0.013, [sx * n.antennae, Htop - D / 2, 0]));
+        addMesh(mergeGeos(bands), bandPair, 'bands');
+        if (n.antennae) {
+            // 1.8 m fibreglass rods, 0.8 m above the net, 10 cm red / white stripes
+            const red = [], white = [];
+            for (const sx of [-1, 1])
+                for (let i = 0; i < 18; i++) {
+                    const y0 = Htop - D + i * 0.1, y1 = y0 + 0.1;
+                    (i % 2 ? white : red).push(bar([sx * (n.antennae + 0.03), y0, 0], [sx * (n.antennae + 0.03), y1, 0], 0.005, 8));
+                }
+            addMesh(mergeGeos(red), paint(3, 'plastic', { tint: '#d13b2a', roughness: 0.4 }), 'antennaRed');
+            addMesh(mergeGeos(white), paint(3, 'plastic', { tint: '#f2f2f2', roughness: 0.4 }), 'antennaWhite');
+        }
+        if (opt.net) {
+            // the mesh: from the bottom edge to just under the top tape, along x at z = 0; the top follows
+            // the dip (grounded: stretched, the bottom stays on the ground; hanging: shifted down)
+            const h0 = (n.grounded ? Htop : D) - bandH * 0.5;
+            const y0 = n.grounded ? 0 : Htop - D;
+            const drop = (x) => dip * (1 - (2 * x / W) ** 2);
+            const A = (s) => { const x = -W / 2 + W * s; return [x, n.grounded ? 0 : y0 - drop(x), 0]; };
+            const B = (s) => { const x = -W / 2 + W * s; return [x, (n.grounded ? h0 : y0 + h0) - drop(x), 0]; };
+            addNet(netRuled(A, B, nq(W), nq(h0), () => [0, 0, -0.08 * Math.min(h0, 1)]), { mesh: meshSize, thread: n.thread ?? Math.min(0.0035, meshSize * 0.07), k: 0.6 }, 1);
+        }
+    };
+    if (kind === 'footballGoal')
+        frameGoal(7.32, 2.44, 2.0, 0.06, paint(0, 'paint', { tint: '#ffffff', roughness: 0.3 }), opt.mesh ?? 0.12);
+    else if (kind === 'futsalGoal')
+        frameGoal(3.0, 2.0, 1.0, 0.04, paint(0, 'paint', { tint: '#ffffff', roughness: 0.3 }), opt.mesh ?? 0.1);
+    else if (kind === 'handballGoal') {
+        // 3 × 2 m, posts and crossbar painted in 0.2 m bands of two colours (two meshes)
+        const W = 3, H = 2, D = 1.0, r = 0.04;
+        const p0 = paint(0, 'paint', { tint: '#ffffff' }), p1 = paint(2, 'paint', { tint: '#ffffff' });
+        const segsA = [], segsB = [];
+        const stripe = (a, b) => { const len = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]); const n = Math.max(1, Math.round(len / 0.2)); for (let i = 0; i < n; i++) {
+            const t0 = i / n, t1 = (i + 1) / n;
+            const pa = a.map((v, k) => v + (b[k] - v) * t0), pb = a.map((v, k) => v + (b[k] - v) * t1);
+            (i % 2 ? segsB : segsA).push(bar(pa, pb, r, R));
+        } };
+        stripe([-W / 2, 0, 0], [-W / 2, H + r, 0]);
+        stripe([W / 2, 0, 0], [W / 2, H + r, 0]);
+        stripe([-W / 2 - r, H + r, 0], [W / 2 + r, H + r, 0]);
+        addMesh(mergeGeos(segsA), p0, 'frameA');
+        addMesh(mergeGeos(segsB), p1, 'frameB');
+        addMesh(mergeGeos(boxGoalFrame(W, H, D, H * 0.8, r)), p0, 'back');
+        boxGoalNets(W, H, D, H * 0.8, { mesh: opt.mesh ?? 0.1, thread: 0.0045 });
+    }
+    else if (kind === 'hockeyNet') {
+        // NHL: 1.83 wide, 1.22 high, 1.12 deep. Posts and crossbar at the goal line; a base frame on the ice
+        // curving back to its deepest point; an upper frame at 0.55 H over the same curve; the net spans
+        // crossbar → upper frame (roof), upper frame → base (back) and post → frame (the two sides).
+        const W = 1.83, H = 1.22, D = 1.12, r = 0.025, Hu = H * 0.55;
+        const zb = (s) => -D * (0.55 + 0.45 * Math.sin(Math.PI * s)); // depth of the curved back at s
+        const base = (s) => [-W / 2 + W * s, r, zb(s)], upper = (s) => [-W / 2 + W * s, Hu, zb(s)];
+        const curvePts = (f) => { const p = []; for (let i = 0; i <= 16; i++)
+            p.push(f(i / 16)); return p; };
+        const red = paint(0, 'paint', { tint: '#ffffff', roughness: 0.3 });
+        const fr = [tube(curvePts(base), r, 32, 8), tube(curvePts(upper), r * 0.8, 32, 8),
+            bar([-W / 2, 0, 0], [-W / 2, H, 0], r, R), bar([W / 2, 0, 0], [W / 2, H, 0], r, R), bar([-W / 2 - r, H, 0], [W / 2 + r, H, 0], r, R)];
+        for (const sx of [-1, 1]) {
+            fr.push(bar([sx * W / 2, r, 0], [sx * W / 2, r, -0.55 * D], r, 8)); // base side bar on the ice
+            fr.push(bar([sx * W / 2, r, -0.55 * D], [sx * W / 2, Hu, -0.55 * D], r * 0.8, 8)); // upright at the back corner
+            fr.push(bar([sx * W / 2, H, 0], [sx * W / 2, Hu, -0.55 * D], r * 0.8, 8)); // top side bar
+        }
+        fr.push(bar([0, H, 0], [0, Hu, -D], r * 0.6, 8));
+        addMesh(mergeGeos(fr), red, 'frame');
+        const np = { mesh: opt.mesh ?? 0.045, thread: 0.0025, k: 0.5 };
+        addNet(netRuled(base, upper, nq(W * 1.3), nq(Hu), (s) => { const x = -W / 2 + W * s, z = zb(s) + 0.3 * D, l = Math.hypot(x, z) || 1; return [0.15 * x / l, 0, 0.15 * z / l]; }), np, 1); // back, out of the goal
+        addNet(netRuled(line3([-W / 2, H, 0], [W / 2, H, 0]), upper, nq(W), nq(D * 0.8), () => [0, -0.12, 0]), np, 1); // roof
+        for (const sx of [-1, 1])
+            addNet(netRuled(line3([sx * W / 2, 0, 0], [sx * W / 2, 0, -0.55 * D]), line3([sx * W / 2, H, 0], [sx * W / 2, Hu, -0.55 * D]), nq(0.6), nq(H), () => [sx * 0.1, 0, 0]), np, 1); // sides
+    }
+    else if (kind === 'basketballHoop') {
+        // backboard 1.8 × 1.05, rim r 0.2286 at 3.05 m, 0.15 m in front of the board; pole 1.2 m behind the baseline with a padded base
+        const rimR = 0.2286, rimY = 3.05, bw = 1.8, bh = 1.05, bz = -0.15 - rimR;
+        const pole = paint(0, 'metal', { tint: '#dddddd', roughness: 0.35, metalness: 1 });
+        const pad = paint(2, 'rubber', { tint: '#ffffff', roughness: 0.9 });
+        const glass = paint(3, 'plastic', { tint: '#dfe8ee', roughness: 0.15 });
+        const rimP = paint(3, 'paint', { tint: '#e8521f', roughness: 0.4 });
+        const pz = bz - 1.2;
+        addMesh(mergeGeos([bar([0, 0, pz], [0, rimY + 0.6, pz], 0.08, R), bar([0, rimY + 0.5, pz], [0, rimY + 0.35, bz - 0.03], 0.04, 10), bar([0, rimY - 0.25, pz], [0, rimY - 0.2, bz - 0.03], 0.04, 10)]), pole, 'pole');
+        addMesh(box(0.5, 1.8, 0.5, [0, 0.9, pz]), pad, 'pad');
+        addMesh(mergeGeos([box(bw, bh, 0.02, [0, rimY + bh / 2 - 0.3, bz - 0.02])]), glass, 'board');
+        // board frame + inner rectangle (accent)
+        const frameP = paint(2, 'paint', { tint: '#ffffff', roughness: 0.4 });
+        addMesh(mergeGeos([box(bw, 0.05, 0.03, [0, rimY + bh - 0.3, bz - 0.01]), box(bw, 0.05, 0.03, [0, rimY - 0.3, bz - 0.01]), box(0.05, bh, 0.03, [-bw / 2, rimY + bh / 2 - 0.3, bz - 0.01]), box(0.05, bh, 0.03, [bw / 2, rimY + bh / 2 - 0.3, bz - 0.01]),
+            box(0.59, 0.03, 0.03, [0, rimY + 0.45, bz]), box(0.03, 0.45, 0.03, [-0.295, rimY + 0.225, bz]), box(0.03, 0.45, 0.03, [0.295, rimY + 0.225, bz])]), frameP, 'boardFrame');
+        const ring = new THREE.TorusGeometry(rimR, 0.01, 10, 48);
+        ring.rotateX(Math.PI / 2);
+        ring.translate(0, rimY, 0);
+        addMesh(mergeGeos([ring, box(0.12, 0.08, 0.15, [0, rimY - 0.03, bz + 0.07])]), rimP, 'rim');
+        if (opt.net) {
+            // the net: a cone of 12 cords, drawn as a lathe with the net shader in polar coordinates
+            const np = netMaterial(u, { mesh: opt.mesh ?? 0.06, thread: 0.004, sag: 0, slot: 1 });
+            mats.push(np);
+            const g = lathe([[rimR * 0.62, rimY - 0.42], [rimR * 0.78, rimY - 0.3], [rimR * 0.95, rimY - 0.12], [rimR, rimY - 0.01]], 36);
+            const uv = g.attributes.uv;
+            for (let i = 0; i < uv.count; i++)
+                uv.setXY(i, uv.getX(i) * rimR * 6.2832, uv.getY(i) * 0.42);
+            g.setAttribute('aT', new THREE.Float32BufferAttribute(new Float32Array(uv.count * 2), 2));
+            g.setAttribute('aSag', new THREE.Float32BufferAttribute(new Float32Array(uv.count * 3), 3));
+            geos.push(g);
+            const m = netMesh(g, np);
+            m.userData.sagK = 0;
+            object.add(m);
+            nets.push(m);
+        }
+    }
+    // posts: slot 0, mesh: slot 1, tapes: slot 2 — natural colours in GOAL_COLORS
+    else if (kind === 'volleyballNet')
+        netOnPosts({ posts: 11.0, netW: 10.0, top: 2.43, depth: 1.0, band: 0.07, postR: 0.05, antennae: 4.5 }, opt.mesh ?? 0.1, paint(0, 'metal', { tint: '#ffffff', roughness: 0.4, metalness: 1 }), paint(2, 'fabric', { tint: '#ffffff' }));
+    else if (kind === 'tennisNet')
+        netOnPosts({ posts: 12.8, top: 1.07, dip: 0.156, band: 0.06, postR: 0.04, grounded: true, strap: true, thread: 0.003 }, opt.mesh ?? 0.045, paint(0, 'metal', { tint: '#ffffff', roughness: 0.5, metalness: 0.6 }), paint(2, 'fabric', { tint: '#ffffff' }));
+    else if (kind === 'badmintonNet')
+        netOnPosts({ posts: 6.1, top: 1.55, dip: 0.026, depth: 0.76, band: 0.075, postR: 0.02 }, opt.mesh ?? 0.019, paint(0, 'metal', { tint: '#ffffff', roughness: 0.5, metalness: 0.6 }), paint(2, 'fabric', { tint: '#ffffff' }));
+    else if (kind === 'pickleballNet')
+        netOnPosts({ posts: 6.71, top: 0.914, dip: 0.05, band: 0.05, postR: 0.03, grounded: true, strap: true }, opt.mesh ?? 0.04, paint(0, 'metal', { tint: '#ffffff', roughness: 0.5, metalness: 0.6 }), paint(2, 'fabric', { tint: '#ffffff' }));
+    else if (kind === 'padelNet')
+        netOnPosts({ posts: 10.0, top: 0.92, dip: 0.04, band: 0.06, postR: 0.04, grounded: true, strap: true }, opt.mesh ?? 0.045, paint(0, 'metal', { tint: '#ffffff', roughness: 0.5, metalness: 0.6 }), paint(2, 'fabric', { tint: '#ffffff' }));
+    else if (kind === 'tableTennisNet')
+        netOnPosts({ posts: 1.83, top: 0.1525, band: 0.015, postR: 0.008, grounded: true, thread: 0.0012 }, opt.mesh ?? 0.012, paint(0, 'metal', { tint: '#ffffff', roughness: 0.5, metalness: 0.6 }), paint(2, 'fabric', { tint: '#ffffff' }));
+    else if (kind === 'rugbyPosts' || kind === 'americanUprights') {
+        const american = kind === 'americanUprights';
+        const W = american ? 5.64 : 5.6, cb = american ? 3.05 : 3.0, top = american ? 10.7 : 11.0, r = american ? 0.06 : 0.07;
+        const p = paint(0, 'paint', { tint: '#ffffff', roughness: 0.35 });
+        const parts = [];
+        if (american) {
+            // gooseneck: one pole 1.8 m behind, curving up to the crossbar
+            parts.push(bar([0, 0, -1.8], [0, cb - 1.0, -1.8], 0.12, R), tube([[0, cb - 1.0, -1.8], [0, cb - 0.3, -1.5], [0, cb, -0.6], [0, cb, 0]], 0.1, 16, 10));
+            parts.push(bar([-W / 2, cb, 0], [W / 2, cb, 0], r, R), bar([-W / 2, cb, 0], [-W / 2, top, 0], r * 0.8, R), bar([W / 2, cb, 0], [W / 2, top, 0], r * 0.8, R));
+        }
+        else {
+            parts.push(bar([-W / 2, 0, 0], [-W / 2, top, 0], r, R), bar([W / 2, 0, 0], [W / 2, top, 0], r, R), bar([-W / 2, cb, 0], [W / 2, cb, 0], r * 0.9, R));
+        }
+        addMesh(mergeGeos(parts), p, 'posts');
+        const padP = paint(2, 'rubber', { tint: '#ffffff', roughness: 0.9 });
+        if (american)
+            addMesh(box(0.5, 1.9, 0.5, [0, 0.95, -1.8]), padP, 'pad');
+        else
+            addMesh(mergeGeos([bar([-W / 2, 0, 0], [-W / 2, 1.9, 0], 0.16, 12), bar([W / 2, 0, 0], [W / 2, 1.9, 0], 0.16, 12)]), padP, 'pads');
+    }
+    const apply = (cfg) => {
+        for (const m of nets) {
+            const uu = m.material.userData.uniforms;
+            if (!uu)
+                continue;
+            if (cfg.netTension !== undefined)
+                uu.uSag.value = (1 - cfg.netTension) * (m.userData.sagK ?? 1);
+        }
+    };
+    return { object, mats, nets, apply, dispose: () => { geos.forEach((g) => g.dispose()); mats.forEach(disposePair); } };
+}