@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/sports/core/equipment.d.ts

@@ -0,0 +1,103 @@
+import * as THREE from 'three';
+/** The items: natural colours [main, grip, accent] and the main material kind. */
+export declare const ITEMS: {
+    tennisRacquet: {
+        colors: string[];
+        kind: string;
+    };
+    badmintonRacquet: {
+        colors: string[];
+        kind: string;
+    };
+    tableTennisPaddle: {
+        colors: string[];
+        kind: string;
+    };
+    baseballBat: {
+        colors: string[];
+        kind: string;
+    };
+    cricketBat: {
+        colors: string[];
+        kind: string;
+    };
+    golfDriver: {
+        colors: string[];
+        kind: string;
+    };
+    golfIron: {
+        colors: string[];
+        kind: string;
+    };
+    golfPutter: {
+        colors: string[];
+        kind: string;
+    };
+    hockeyStick: {
+        colors: string[];
+        kind: string;
+    };
+    skateboard: {
+        colors: string[];
+        kind: string;
+    };
+    dumbbell: {
+        colors: string[];
+        kind: string;
+    };
+    kettlebell: {
+        colors: string[];
+        kind: string;
+    };
+    barbell: {
+        colors: string[];
+        kind: string;
+    };
+    frisbee: {
+        colors: string[];
+        kind: string;
+    };
+};
+export declare const ITEM_LIST: string[];
+export declare const MATERIALS: string[];
+export declare function createUniforms(): {
+    uTime: {
+        value: number;
+    };
+    uColor: {
+        value: THREE.Color;
+    };
+    uSecondaryColor: {
+        value: THREE.Color;
+    };
+    uAccentColor: {
+        value: THREE.Color;
+    };
+    uWear: {
+        value: number;
+    };
+    uGloss: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uSeed: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any, mats?: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: any[];
+    apply: (cfg: any) => void;
+    update: (dt: any) => void;
+    stats: {
+        parts: any;
+        verts: number;
+    };
+    dispose: () => void;
+};
+/** Knobs whose change rebuilds the object (dispose + build); every other knob is a live push through apply. */
+export declare const STRUCTURAL: string[];
+//# sourceMappingURL=equipment.d.ts.map

package/dist/components/sports/core/equipment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equipment.d.ts","sourceRoot":"","sources":["../../../../src/components/sports/core/equipment.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,kFAAkF;AAClF,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAejB,CAAC;AACF,eAAO,MAAM,SAAS,UAAqB,CAAC;AAC5C,eAAO,MAAM,SAAS,UAA0D,CAAC;AAEjF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AAEnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,MAAY,QAIjD;AAwOD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAqBzB;AAED,+GAA+G;AAC/G,eAAO,MAAM,UAAU,UAAoD,CAAC"}

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

@@ -0,0 +1,403 @@
+// Emitted from Claude outputs/sports-lab/equipment.mjs by gen_family.mjs — edit the lab module and re-emit.
+// sports/core/equipment — Equipment (type 'sports', config.type 'equipment'). Shared core: ../sportsCore.
+// Construction: one piece of sports equipment at real size, lying or standing on the ground the way it
+// would be put down: lathe-turned bats, a racquet hoop as a tube along an ellipse with its string bed
+// laid string by string, extruded blades, trucks and wheels, plates on a bar, a kettlebell's cast body
+// and handle. Each part is one of the family's procedural materials (ash and willow grain along the
+// part's own axis, brushed steel, carbon twill, rubber grip, pebbled leather, glossy plastic) with
+// wear where hands and ground touch it. Size: real metres; the transform places it.
+import * as THREE from 'three';
+import { createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_S, propMesh, partMaterial, mergeGeos, lathe, tube, bar, box, disposePair, setColor } from '../sportsCore.js';
+/** The items: natural colours [main, grip, accent] and the main material kind. */
+export const ITEMS = {
+    tennisRacquet: { colors: ['#1f2a44', '#1a1a1a', '#e8e6df'], kind: 'carbon' },
+    badmintonRacquet: { colors: ['#2a2a2e', '#d13b2a', '#f2f2f2'], kind: 'carbon' },
+    tableTennisPaddle: { colors: ['#c89a62', '#c89a62', '#c8262a'], kind: 'wood' },
+    baseballBat: { colors: ['#d9b98c', '#1a1a1a', '#5a3a22'], kind: 'wood' },
+    cricketBat: { colors: ['#e8d6b0', '#2a4fa0', '#f2f2f2'], kind: 'wood' },
+    golfDriver: { colors: ['#1a1a1a', '#202020', '#c9c9c9'], kind: 'carbon' },
+    golfIron: { colors: ['#c9c9c9', '#202020', '#c9c9c9'], kind: 'metal' },
+    golfPutter: { colors: ['#9a9a9a', '#202020', '#2a2a2a'], kind: 'metal' },
+    hockeyStick: { colors: ['#1c1c1c', '#f2f2f2', '#d13b2a'], kind: 'carbon' },
+    skateboard: { colors: ['#c89a62', '#1a1a1a', '#f0efe6'], kind: 'wood' },
+    dumbbell: { colors: ['#1c1c1c', '#c9c9c9', '#1c1c1c'], kind: 'rubber' },
+    kettlebell: { colors: ['#2a2a2a', '#2a2a2a', '#d13b2a'], kind: 'paint' },
+    barbell: { colors: ['#c9c9c9', '#1c1c1c', '#1d4f9c'], kind: 'metal' },
+    frisbee: { colors: ['#e8542a', '#e8542a', '#f2f2f2'], kind: 'plastic' },
+};
+export const ITEM_LIST = Object.keys(ITEMS);
+export const MATERIALS = ['auto', 'wood', 'metal', 'carbon', 'plastic', 'paint'];
+export function createUniforms() { return createCommonUniforms(); }
+export function applyConfig(u, c, mats = undefined) {
+    applyCommonConfig(u, c, mats);
+    const I = ITEMS[c.item] || ITEMS.tennisRacquet;
+    if (c.naturalColors !== false) {
+        setColor(u.uColor, I.colors[0]);
+        setColor(u.uSecondaryColor, I.colors[1]);
+        setColor(u.uAccentColor, I.colors[2]);
+    }
+}
+// ---------------------------------------------------------------------------- builders (every part: geometry + material spec)
+// material spec: { kind, slot (0 main, 1 grip, 2 accent, 3 own tint), tint, roughness, metalness, axis }
+const M = {
+    main: (kind, axis = undefined, extra = undefined) => Object.assign({ kind, slot: 0, tint: '#ffffff', roughness: kind === 'wood' ? 0.6 : 0.35, metalness: kind === 'metal' ? 1 : 0, axis: axis || [1, 0, 0] }, extra),
+    grip: (extra = undefined) => Object.assign({ kind: 'rubber', slot: 1, tint: '#ffffff', roughness: 0.85, axis: [1, 0, 0] }, extra),
+    accent: (kind, extra = undefined) => Object.assign({ kind, slot: 2, tint: '#ffffff', roughness: 0.45, metalness: kind === 'metal' ? 1 : 0, axis: [1, 0, 0] }, extra),
+    own: (kind, tint, extra = undefined) => Object.assign({ kind, slot: 3, tint, roughness: 0.4, metalness: kind === 'metal' ? 1 : 0, axis: [1, 0, 0] }, extra),
+};
+const R = (q) => Math.round(12 + 12 * q);
+/** An ellipse in the XZ plane (lying flat) as a closed tube; a = half-length along x, b = half-width along z. */
+function hoop(a, b, r, q) {
+    const pts = [];
+    const n = Math.round(40 + 24 * q);
+    for (let i = 0; i < n; i++) {
+        const t = (i / n) * Math.PI * 2;
+        pts.push([a * Math.cos(t), 0, b * Math.sin(t)]);
+    }
+    return tube(pts, r, n * 2, 8 + Math.round(4 * q), true);
+}
+/** A string bed inside the ellipse (a, b): `mains` strings along x, `crosses` along z, thickness t. */
+function stringBed(a, b, mains, crosses, t, y) {
+    const parts = [];
+    const inner = 0.985;
+    for (let i = 0; i < mains; i++) {
+        const z = -b * 0.9 + (i + 0.5) / mains * 2 * b * 0.9;
+        const hx = a * inner * Math.sqrt(Math.max(0, 1 - (z / (b * inner)) ** 2));
+        parts.push(box(hx * 2, t, t, [0, y, z]));
+    }
+    for (let i = 0; i < crosses; i++) {
+        const x = -a * 0.9 + (i + 0.5) / crosses * 2 * a * 0.9;
+        const hz = b * inner * Math.sqrt(Math.max(0, 1 - (x / (a * inner)) ** 2));
+        parts.push(box(t, t, hz * 2, [x, y, 0]));
+    }
+    return mergeGeos(parts);
+}
+/** An octagonal grip along x from x0 to x1. */
+function gripOct(x0, x1, r) { const g = new THREE.CylinderGeometry(r, r, x1 - x0, 8, 1); g.rotateZ(-Math.PI / 2); g.rotateX(Math.PI / 8); g.translate((x0 + x1) / 2, 0, 0); return g; }
+const BUILDERS = {
+    tennisRacquet(c, q) {
+        // head 0.34 × 0.26 (≈ 100 sq in), 16 × 19 strings, throat bridge, 0.2 m grip; lying flat
+        const a = 0.17, b = 0.13, y = 0.012;
+        const frame = [hoop(a, b, 0.011, q)];
+        frame.push(tube([[-a * 0.75, 0, b * 0.62], [-a - 0.06, 0, 0.012], [-a - 0.2, 0, 0.012]], 0.009, 12, 8));
+        frame.push(tube([[-a * 0.75, 0, -b * 0.62], [-a - 0.06, 0, -0.012], [-a - 0.2, 0, -0.012]], 0.009, 12, 8));
+        frame.push(box(0.03, 0.02, 0.05, [-a - 0.08, 0, 0]));
+        const fr = mergeGeos(frame);
+        fr.translate(0, y, 0);
+        const grip = gripOct(-a - 0.4, -a - 0.2, 0.016);
+        grip.translate(0, y, 0);
+        const cap = box(0.012, 0.034, 0.034, [-a - 0.405, y, 0]);
+        return [[fr, M.main(c.material === 'auto' ? 'carbon' : c.material, [1, 0, 0])], [grip, M.grip()], [cap, M.own('plastic', '#1a1a1a')], [stringBed(a, b, 16, 19, 0.0014, y), M.accent('plastic', { roughness: 0.5 })]];
+    },
+    badmintonRacquet(c, q) {
+        const a = 0.125, b = 0.095, y = 0.008;
+        const frame = [hoop(a, b, 0.0055, q), tube([[-a + 0.005, 0, 0], [-a - 0.05, 0, 0], [-a - 0.3, 0, 0]], 0.0045, 8, 8), box(0.07, 0.012, 0.03, [-a - 0.03, 0, 0])];
+        const fr = mergeGeos(frame);
+        fr.translate(0, y, 0);
+        const grip = gripOct(-a - 0.47, -a - 0.3, 0.012);
+        grip.translate(0, y, 0);
+        return [[fr, M.main(c.material === 'auto' ? 'carbon' : c.material)], [grip, M.grip()], [stringBed(a, b, 22, 22, 0.0007, y), M.accent('plastic', { roughness: 0.5 })]];
+    },
+    tableTennisPaddle(c, q) {
+        // blade 0.15 × 0.16, 6 mm, red rubber on top, black underneath, flared handle; lying flat
+        const blade = new THREE.CylinderGeometry(0.078, 0.078, 0.006, R(q) * 2);
+        blade.scale(1, 1, 1.07);
+        blade.translate(0.0, 0.0065, 0);
+        const top = new THREE.CylinderGeometry(0.075, 0.075, 0.0025, R(q) * 2);
+        top.scale(1, 1, 1.07);
+        top.translate(0, 0.0105, 0);
+        const bot = new THREE.CylinderGeometry(0.075, 0.075, 0.0025, R(q) * 2);
+        bot.scale(1, 1, 1.07);
+        bot.translate(0, 0.00225, 0);
+        const handle = lathe([[0.012, 0], [0.013, 0.03], [0.016, 0.1]], 10);
+        handle.rotateZ(Math.PI / 2);
+        handle.scale(1, 1, 0.75);
+        handle.translate(-0.075, 0.0065, 0);
+        return [[mergeGeos([blade, handle]), M.main('wood', [1, 0, 0], { roughness: 0.55 })], [top, M.accent('rubber', { roughness: 0.7 })], [bot, M.grip({ roughness: 0.7 })]];
+    },
+    baseballBat(c, q) {
+        // 0.84 m, knob 52 mm, handle 26 mm, barrel 66 mm; lying along x
+        const g = lathe([[0.0, 0], [0.026, 0], [0.026, 0.012], [0.015, 0.02], [0.013, 0.05], [0.013, 0.28], [0.016, 0.4], [0.024, 0.52], [0.031, 0.64], [0.033, 0.72], [0.033, 0.82], [0.028, 0.835], [0.0, 0.84]], R(q) * 2);
+        g.rotateZ(-Math.PI / 2);
+        g.translate(-0.42, 0.033, 0);
+        const tape = new THREE.CylinderGeometry(0.0145, 0.0145, 0.24, 12);
+        tape.rotateZ(-Math.PI / 2);
+        tape.translate(-0.42 + 0.17, 0.033, 0);
+        return [[g, M.main(c.material === 'auto' ? 'wood' : c.material, [1, 0, 0], { roughness: 0.5 })], [tape, M.grip({ kind: 'fabric' })]];
+    },
+    cricketBat(c, q) {
+        // blade 0.55 × 0.108 with a spine, shoulders, 0.3 m cane handle with a rubber grip; lying face up
+        const sh = new THREE.Shape();
+        sh.moveTo(-0.054, 0);
+        sh.lineTo(0.054, 0);
+        sh.lineTo(0.054, 0.012);
+        sh.lineTo(0.0, 0.042);
+        sh.lineTo(-0.054, 0.012);
+        sh.closePath();
+        const blade = new THREE.ExtrudeGeometry(sh, { depth: 0.55, bevelEnabled: true, bevelThickness: 0.004, bevelSize: 0.004, bevelSegments: 2 });
+        blade.rotateY(Math.PI / 2);
+        blade.translate(-0.275, 0.0, 0); // along x, face (flat side) down… turn it face up:
+        blade.rotateX(Math.PI);
+        blade.translate(0, 0.042, 0);
+        const shoulder = lathe([[0.0, 0], [0.03, 0], [0.02, 0.04], [0.017, 0.06]], 10);
+        shoulder.rotateZ(Math.PI / 2);
+        shoulder.translate(-0.275, 0.02, 0);
+        const handle = new THREE.CylinderGeometry(0.017, 0.017, 0.3, 10);
+        handle.rotateZ(Math.PI / 2);
+        handle.translate(-0.275 - 0.17, 0.02, 0);
+        return [[mergeGeos([blade, shoulder]), M.main('wood', [1, 0, 0], { roughness: 0.55 })], [handle, M.grip()]];
+    },
+    golfDriver(c, q) { return golfClub(c, q, 'driver'); },
+    golfIron(c, q) { return golfClub(c, q, 'iron'); },
+    golfPutter(c, q) { return golfClub(c, q, 'putter'); },
+    hockeyStick(c, q) {
+        // 1.5 m shaft, blade at 135° in the plane of the ground; lying on its side
+        const shaft = box(1.5, 0.03, 0.02, [-0.75, 0.015, 0]);
+        const bl = new THREE.BoxGeometry(0.33, 0.07, 0.012);
+        bl.rotateY(-0.9);
+        bl.translate(0.13, 0.035, 0.11);
+        const tape = box(0.25, 0.034, 0.024, [-1.37, 0.015, 0]);
+        const bladeTape = new THREE.BoxGeometry(0.2, 0.072, 0.015);
+        bladeTape.rotateY(-0.9);
+        bladeTape.translate(0.17, 0.035, 0.145);
+        return [[mergeGeos([shaft, bl]), M.main(c.material === 'auto' ? 'carbon' : c.material)], [tape, M.grip({ kind: 'fabric' })], [bladeTape, M.accent('fabric')]];
+    },
+    skateboard(c, q) {
+        // A popsicle street deck, 0.81 × 0.205 m (31.9" × 8"), 0.36 m (14") wheelbase, 7-ply 11 mm, on two
+        // trucks and four 54 mm wheels. The deck is a dense parametric surface over its outline, bent into
+        // 18° kicktails (a slope that eases in over a few cm) and a 4 mm concave across, so it reads as a
+        // pressed deck instead of three boxes.
+        const L = 0.81, W = 0.205, flat = 0.3, endR = (L / 2 - flat), T = 0.011, wb = 0.18;
+        const halfW = (x) => { const a = Math.abs(x) - flat; return a <= 0 ? W / 2 : (W / 2) * Math.sqrt(Math.max(0, 1 - (a / endR) ** 2)); };
+        const kick = (x) => { const a = Math.abs(x) - 0.235; return a <= 0 ? 0 : Math.tan(18 * Math.PI / 180) * (Math.sqrt(a * a + 0.03 * 0.03) - 0.03); };
+        const concave = (x, z) => 0.004 * (2 * z / W) ** 2 * (kick(x) > 0 ? 0.5 : 1);
+        const deckY = 0.077; // deck bottom: axle height 27 mm + 50 mm truck
+        const nu = Math.round(48 + 48 * q), nv = Math.round(8 + 6 * q);
+        // u in [-1, 1] along the length (denser at the ends where it bends), v in [-1, 1] across
+        const xu = (u) => Math.sign(u) * Math.pow(Math.abs(u), 0.85) * (L / 2 - 0.0005);
+        const P = (u, v, top, inset) => { const x = xu(u) * (1 - inset), z = v * halfW(x) * (1 - inset * 3); return [x, deckY + kick(x) + concave(x, z) + (top ? T : 0), z]; };
+        const surface = (top, inset, lift) => {
+            const pos = [], idx = [], uv = [];
+            for (let i = 0; i <= nu; i++)
+                for (let j = 0; j <= nv; j++) {
+                    const p = P(-1 + 2 * i / nu, -1 + 2 * j / nv, top, inset);
+                    pos.push(p[0], p[1] + lift, p[2]);
+                    uv.push(p[0], p[2]);
+                }
+            for (let i = 0; i < nu; i++)
+                for (let j = 0; j < nv; j++) {
+                    const k = i * (nv + 1) + j;
+                    if (top)
+                        idx.push(k, k + 1, k + nv + 1, k + 1, k + nv + 2, k + nv + 1);
+                    else
+                        idx.push(k, k + nv + 1, k + 1, k + 1, k + nv + 1, k + nv + 2);
+                }
+            const g = new THREE.BufferGeometry();
+            g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+            g.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+            g.setIndex(idx);
+            g.computeVertexNormals();
+            return g;
+        };
+        // the edge: a strip around the outline from the bottom surface to the top one
+        const rim = () => {
+            const loop = [];
+            for (let i = 0; i <= nu; i++)
+                loop.push([-1 + 2 * i / nu, 1]);
+            for (let i = nu; i >= 0; i--)
+                loop.push([-1 + 2 * i / nu, -1]);
+            const pos = [], idx = [], uv = [];
+            loop.forEach(([u, v], k) => { const a = P(u, v, false, 0), b = P(u, v, true, 0); pos.push(...a, ...b); uv.push(k * 0.01, 0, k * 0.01, T); });
+            for (let k = 0; k < loop.length - 1; k++) {
+                const i = 2 * k;
+                idx.push(i, i + 2, i + 1, i + 1, i + 2, i + 3);
+            }
+            const g = new THREE.BufferGeometry();
+            g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+            g.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+            g.setIndex(idx);
+            g.computeVertexNormals();
+            return g;
+        };
+        const wood = mergeGeos([surface(false, 0, 0), rim(), surface(true, 0, 0)]);
+        const grip = surface(true, 0.004, 0.0006);
+        // trucks: baseplate under the deck, kingpin, bushings, hanger, axle, nuts
+        const metal = [], bush = [], wheels = [], cores = [];
+        const axleY = 0.027, hw = 0.067, axleL = 0.104;
+        const wheel = lathe([[0.0115, -0.016], [0.021, -0.016], [0.025, -0.0152], [0.0268, -0.012], [0.027, -0.006], [0.027, 0.006], [0.0268, 0.012], [0.025, 0.0152], [0.021, 0.016], [0.0115, 0.016]], R(q) * 2);
+        wheel.rotateX(Math.PI / 2);
+        for (const sx of [-1, 1]) {
+            const x = sx * wb;
+            metal.push(box(0.062, 0.007, 0.066, [x, deckY - 0.0035, 0])); // baseplate
+            metal.push(box(0.03, 0.016, 0.032, [x - sx * 0.012, deckY - 0.014, 0])); // pivot cup block
+            metal.push(bar([x + sx * 0.008, deckY - 0.006, 0], [x + sx * 0.002, axleY + 0.012, 0], 0.0045, 10)); // kingpin
+            const b1 = new THREE.CylinderGeometry(0.0135, 0.0135, 0.011, R(q));
+            b1.translate(x + sx * 0.006, axleY + 0.03, 0);
+            bush.push(b1);
+            const b2 = new THREE.CylinderGeometry(0.0125, 0.0125, 0.009, R(q));
+            b2.translate(x + sx * 0.004, axleY + 0.013, 0);
+            bush.push(b2);
+            // hanger: a tapered arm across, thicker in the middle, meeting the pivot
+            metal.push(tube([[x, axleY + 0.002, -hw], [x, axleY + 0.006, -0.03], [x, axleY + 0.012, 0], [x, axleY + 0.006, 0.03], [x, axleY + 0.002, hw]], 0.0085, 24, 10));
+            metal.push(box(0.022, 0.024, 0.05, [x, axleY + 0.016, 0]));
+            metal.push(bar([x - sx * 0.012, axleY + 0.016, 0], [x - sx * 0.014, deckY - 0.016, 0], 0.005, 8)); // pivot
+            metal.push(bar([x, axleY, -axleL], [x, axleY, axleL], 0.004, 10)); // axle
+            for (const sz of [-1, 1]) {
+                const nut = new THREE.CylinderGeometry(0.006, 0.006, 0.006, 6);
+                nut.rotateX(Math.PI / 2);
+                nut.translate(x, axleY, sz * (axleL - 0.003));
+                metal.push(nut);
+                const w = wheel.clone();
+                w.translate(x, axleY, sz * (axleL - 0.022));
+                wheels.push(w);
+                const core = new THREE.CylinderGeometry(0.0112, 0.0112, 0.03, R(q));
+                core.rotateX(Math.PI / 2);
+                core.translate(x, axleY, sz * (axleL - 0.022));
+                cores.push(core);
+            }
+        }
+        wheel.dispose();
+        return [
+            [wood, M.main(c.material === 'auto' ? 'wood' : c.material, [1, 0, 0], { roughness: 0.5 })],
+            [grip, M.grip({ kind: 'fabric', roughness: 1 })],
+            [mergeGeos(metal), M.own('metal', '#b9bcc0', { roughness: 0.35, axis: [0, 0, 1] })],
+            [mergeGeos(bush), M.own('rubber', '#e2b51c', { roughness: 0.6 })],
+            [mergeGeos(wheels), M.accent('plastic', { roughness: 0.45 })],
+            [mergeGeos(cores), M.own('metal', '#3a3a3a', { roughness: 0.4 })],
+        ];
+    },
+    dumbbell(c, q) {
+        // hex heads, knurled handle; the size follows `plates`
+        const s = 0.6 + 0.2 * (c.plates ?? 2);
+        const hr = 0.045 * s, hl = 0.06 * s, hand = 0.13;
+        const heads = [];
+        for (const sx of [-1, 1]) {
+            const h = new THREE.CylinderGeometry(hr, hr, hl, 6);
+            h.rotateZ(Math.PI / 2);
+            h.rotateX(Math.PI / 6);
+            h.translate(sx * (hand / 2 + hl / 2), hr * 0.866, 0);
+            heads.push(h);
+        }
+        const handle = new THREE.CylinderGeometry(0.016, 0.016, hand + 0.01, R(q));
+        handle.rotateZ(Math.PI / 2);
+        handle.translate(0, hr * 0.866, 0);
+        return [[mergeGeos(heads), M.main('rubber', [1, 0, 0], { roughness: 0.8 })], [handle, M.accent('metal', { roughness: 0.4, slot: 1 })]];
+    },
+    kettlebell(c, q) {
+        const s = 0.75 + 0.15 * (c.plates ?? 2);
+        const r = 0.085 * s;
+        const body = new THREE.SphereGeometry(r, R(q) * 2, R(q));
+        body.scale(1, 0.92, 1);
+        body.translate(0, r * 0.88, 0);
+        const base = new THREE.CylinderGeometry(r * 0.55, r * 0.6, r * 0.12, R(q));
+        base.translate(0, r * 0.06, 0);
+        const pts = [];
+        const n = 24;
+        for (let i = 0; i <= n; i++) {
+            const t = (i / n) * Math.PI;
+            pts.push([-r * 0.72 * Math.cos(t), r * 1.45 + r * 0.55 * Math.sin(t) + (i === 0 || i === n ? -r * 0.35 : 0), 0]);
+        }
+        const handle = tube(pts, 0.017 * s, 32, 10);
+        return [[mergeGeos([body, base]), M.main('paint', [0, 1, 0], { roughness: 0.6 })], [handle, M.own('metal', '#8a8a8a', { roughness: 0.45, axis: [0, 1, 0] })]];
+    },
+    barbell(c, q) {
+        // 2.2 m bar on bumper plates (`plates` per side); lying on the plates
+        const n = Math.max(1, Math.round(c.plates ?? 2)), pr = 0.225, pw = 0.05;
+        const y = pr;
+        const barG = new THREE.CylinderGeometry(0.014, 0.014, 2.2, R(q));
+        barG.rotateZ(Math.PI / 2);
+        barG.translate(0, y, 0);
+        const sleeves = [], plates = [], hubs = [];
+        for (const sx of [-1, 1]) {
+            const sl = new THREE.CylinderGeometry(0.025, 0.025, 0.42, R(q));
+            sl.rotateZ(Math.PI / 2);
+            sl.translate(sx * 0.89, y, 0);
+            sleeves.push(sl);
+            const col = new THREE.CylinderGeometry(0.035, 0.035, 0.03, R(q));
+            col.rotateZ(Math.PI / 2);
+            col.translate(sx * 0.68, y, 0);
+            sleeves.push(col);
+            for (let i = 0; i < n; i++) {
+                const x = sx * (0.70 + pw / 2 + i * (pw + 0.004));
+                const p = new THREE.CylinderGeometry(pr, pr, pw, R(q) * 2);
+                p.rotateZ(Math.PI / 2);
+                p.translate(x, y, 0);
+                plates.push(p);
+                const hb = new THREE.CylinderGeometry(0.055, 0.055, pw + 0.004, R(q));
+                hb.rotateZ(Math.PI / 2);
+                hb.translate(x, y, 0);
+                hubs.push(hb);
+            }
+        }
+        return [[mergeGeos([barG, ...sleeves]), M.main('metal', [1, 0, 0], { roughness: 0.35 })], [mergeGeos(plates), M.accent('rubber', { roughness: 0.75 })], [mergeGeos(hubs), M.own('metal', '#9a9a9a', { roughness: 0.4 })]];
+    },
+    frisbee(c, q) {
+        const g = lathe([[0.0, 0.028], [0.06, 0.027], [0.11, 0.022], [0.132, 0.015], [0.137, 0.008], [0.136, 0.0], [0.13, 0.0], [0.128, 0.01], [0.12, 0.016], [0.08, 0.022], [0.0, 0.025]], R(q) * 3);
+        return [[g, M.main('plastic', [0, 1, 0], { roughness: 0.3 })]];
+    },
+};
+function golfClub(c, q, kind) {
+    // lying flat: shaft along x on the ground, head at +x, grip at -x
+    const len = kind === 'driver' ? 1.1 : kind === 'iron' ? 0.95 : 0.86;
+    const y = 0.008;
+    const shaft = new THREE.CylinderGeometry(0.005, 0.007, len, 10);
+    shaft.rotateZ(Math.PI / 2);
+    shaft.translate(0, y, 0);
+    const grip = new THREE.CylinderGeometry(0.011, 0.0125, 0.26, 12);
+    grip.rotateZ(Math.PI / 2);
+    grip.translate(-len / 2 + 0.13, y, 0);
+    const parts = [[shaft, M.own('metal', '#c9c9c9', { roughness: 0.35 })], [grip, M.grip()]];
+    if (kind === 'driver') {
+        const head = new THREE.SphereGeometry(1, R(q) * 2, R(q));
+        head.scale(0.055, 0.032, 0.062);
+        head.translate(len / 2 + 0.03, 0.032, 0.03);
+        const face = box(0.012, 0.05, 0.1, [len / 2 + 0.085, 0.032, 0.03], [0, 0, 0.17]);
+        parts.push([head, M.main(c.material === 'auto' ? 'carbon' : c.material, [1, 0, 0], { roughness: 0.25 })], [face, M.accent('metal', { roughness: 0.4 })]);
+    }
+    else if (kind === 'iron') {
+        const head = new THREE.BoxGeometry(0.03, 0.055, 0.095);
+        head.rotateX(0.35);
+        head.translate(len / 2 + 0.02, 0.028, 0.03);
+        const hosel = new THREE.CylinderGeometry(0.008, 0.009, 0.06, 10);
+        hosel.rotateZ(Math.PI / 2);
+        hosel.translate(len / 2 + 0.01, y, 0);
+        parts.push([mergeGeos([head, hosel]), M.main('metal', [0, 0, 1], { roughness: 0.3 })]);
+    }
+    else {
+        const head = new THREE.BoxGeometry(0.03, 0.028, 0.11);
+        head.translate(len / 2 + 0.02, 0.014, 0.04);
+        const hosel = new THREE.CylinderGeometry(0.008, 0.009, 0.06, 10);
+        hosel.rotateZ(Math.PI / 2);
+        hosel.translate(len / 2 + 0.01, y, 0);
+        parts.push([mergeGeos([head, hosel]), M.main('metal', [0, 0, 1], { roughness: 0.4 })], [box(0.004, 0.02, 0.1, [len / 2 + 0.037, 0.014, 0.04]), M.accent('rubber', { roughness: 0.8 })]);
+    }
+    return parts;
+}
+export function build(u, c) {
+    const q = QUALITY_S[c.quality] || 1;
+    const item = BUILDERS[c.item] ? c.item : 'tennisRacquet';
+    const parts = BUILDERS[item](c, q);
+    const object = new THREE.Group();
+    object.name = item;
+    const geos = [], pairs = [];
+    for (const [geo, spec] of parts) {
+        const pair = partMaterial(u, spec);
+        geos.push(geo);
+        pairs.push(pair);
+        object.add(propMesh(geo, pair, spec.kind));
+    }
+    const mats = pairs.map((p) => p.material);
+    applyConfig(u, c, mats);
+    let verts = 0;
+    for (const g of geos)
+        verts += g.attributes.position.count;
+    return {
+        object, materials: mats,
+        apply: function (cfg) { applyConfig(u, cfg, mats); },
+        update: function (dt) { updateCommon(u, dt); },
+        stats: { parts: parts.length, verts },
+        dispose: function () { geos.forEach((g) => g.dispose()); pairs.forEach(disposePair); },
+    };
+}
+/** Knobs whose change rebuilds the object (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['item', 'material', 'plates', 'quality', 'seed'];

package/dist/components/sports/core/goal.d.ts

@@ -0,0 +1,98 @@
+import * as THREE from 'three';
+/** Natural colours and mesh sizes: the shared table (a court's fixtures read the same one). */
+export declare const GOALS: {
+    footballGoal: {
+        colors: string[];
+        mesh: number;
+    };
+    futsalGoal: {
+        colors: string[];
+        mesh: number;
+    };
+    handballGoal: {
+        colors: string[];
+        mesh: number;
+    };
+    hockeyNet: {
+        colors: string[];
+        mesh: number;
+    };
+    basketballHoop: {
+        colors: string[];
+        mesh: number;
+    };
+    volleyballNet: {
+        colors: string[];
+        mesh: number;
+    };
+    tennisNet: {
+        colors: string[];
+        mesh: number;
+    };
+    badmintonNet: {
+        colors: string[];
+        mesh: number;
+    };
+    pickleballNet: {
+        colors: string[];
+        mesh: number;
+    };
+    padelNet: {
+        colors: string[];
+        mesh: number;
+    };
+    tableTennisNet: {
+        colors: string[];
+        mesh: number;
+    };
+    rugbyPosts: {
+        colors: string[];
+        mesh: number;
+    };
+    americanUprights: {
+        colors: string[];
+        mesh: number;
+    };
+};
+export declare const GOAL_LIST: string[];
+export declare function createUniforms(): {
+    uTime: {
+        value: number;
+    };
+    uColor: {
+        value: THREE.Color;
+    };
+    uSecondaryColor: {
+        value: THREE.Color;
+    };
+    uAccentColor: {
+        value: THREE.Color;
+    };
+    uWear: {
+        value: number;
+    };
+    uGloss: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uSeed: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any, inst?: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: any[];
+    apply: (cfg: any) => void;
+    update: (dt: any) => void;
+    stats: {
+        nets: number;
+        parts: number;
+    };
+    dispose: () => void;
+};
+/** Knobs whose change rebuilds the object (dispose + build); every other knob is a live push through apply. */
+export declare const STRUCTURAL: string[];
+//# sourceMappingURL=goal.d.ts.map

package/dist/components/sports/core/goal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal.d.ts","sourceRoot":"","sources":["../../../../src/components/sports/core/goal.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,+FAA+F;AAC/F,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAc,CAAC;AACjC,eAAO,MAAM,SAAS,UAAa,CAAC;AAEpC,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AAEnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,MAAY,QAKjD;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAezB;AAED,+GAA+G;AAC/G,eAAO,MAAM,UAAU,UAAqD,CAAC"}

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

@@ -0,0 +1,44 @@
+// Emitted from Claude outputs/sports-lab/goal.mjs by gen_family.mjs — edit the lab module and re-emit.
+// sports/core/goal — Goal (type 'sports', config.type 'goal'). Shared core: ../sportsCore (buildGoal: the same builders a court's fixtures use).
+// Construction: a goal, net or hoop at regulation size standing on the ground at its goal line, facing
+// +z: round posts and crossbar, back frame, net panels (back, sides, roof) drawn as anti-aliased knotted
+// mesh on sagging panels (a catenary bow set by netTension — a uniform, so it animates), a basketball
+// backboard with its rim, pad and cone net, nets on posts with their tape bands, rugby / American
+// uprights with pads. Size: real metres; the transform places it.
+import * as THREE from 'three';
+import { createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_S, buildGoal, GOAL_KINDS, GOAL_COLORS, setColor } from '../sportsCore.js';
+/** Natural colours and mesh sizes: the shared table (a court's fixtures read the same one). */
+export const GOALS = GOAL_COLORS;
+export const GOAL_LIST = GOAL_KINDS;
+export function createUniforms() { return createCommonUniforms(); }
+export function applyConfig(u, c, inst = undefined) {
+    applyCommonConfig(u, c, inst && inst.mats);
+    const G = GOALS[c.kind] || GOALS.footballGoal;
+    if (c.naturalColors !== false) {
+        setColor(u.uColor, G.colors[0]);
+        setColor(u.uSecondaryColor, G.colors[1]);
+        setColor(u.uAccentColor, G.colors[2]);
+    }
+    if (inst)
+        inst.goal.apply(c);
+}
+export function build(u, c) {
+    const q = QUALITY_S[c.quality] || 1;
+    const kind = GOALS[c.kind] ? c.kind : 'footballGoal';
+    const G = GOALS[kind];
+    const goal = buildGoal(kind, u, { quality: q, net: c.showNet !== false, mesh: G.mesh * (c.meshSize ?? 1), sag: 1 - (c.netTension ?? 0.6) });
+    const object = new THREE.Group();
+    object.name = kind;
+    object.add(goal.object);
+    const inst = { goal, mats: goal.mats.map((p) => p.material) };
+    applyConfig(u, c, inst);
+    return {
+        object, materials: inst.mats,
+        apply: function (cfg) { applyConfig(u, cfg, inst); },
+        update: function (dt) { updateCommon(u, dt); },
+        stats: { nets: goal.nets.length, parts: goal.mats.length },
+        dispose: function () { goal.dispose(); },
+    };
+}
+/** Knobs whose change rebuilds the object (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['kind', 'showNet', 'meshSize', 'quality', 'seed'];

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

@@ -0,0 +1,11 @@
+export { useSportsInstance } from './useSportsInstance';
+export type { SportsInstance, SportsVariantProps, SportsCore } from './useSportsInstance';
+export type { SportsCourtProps } from './SportsCourt';
+export { default as SportsCourt } from './SportsCourt';
+export type { SportsBallProps } from './SportsBall';
+export { default as SportsBall } from './SportsBall';
+export type { SportsEquipmentProps } from './SportsEquipment';
+export { default as SportsEquipment } from './SportsEquipment';
+export type { SportsGoalProps } from './SportsGoal';
+export { default as SportsGoal } from './SportsGoal';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/sports/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC1F,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AACvD,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC;AACrD,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC/D,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,cAAc,CAAC"}