@3driseai/3drise-viewer 0.1.42 → 0.1.44

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

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

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

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

package/dist/components/sports/SportsGoal.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DEFAULT_SPORTS_OBJECTS, SPORTS_OBJECTS_ANIMATABLE } from '@3driseai/3drise-core';
+import { useSportsInstance } from './useSportsInstance.js';
+import { createUniforms, build, STRUCTURAL } from './core/goal.js';
+// =============================================================================
+// SportsGoal — Goal (type 'sports', config.type 'goal')
+// =============================================================================
+// A regulation goal, net or hoop standing on the ground: football, futsal or handball goal with its sagging net, ice-hockey net, basketball hoop with backboard and pole, volleyball, tennis or badminton net on posts, rugby or American-football uprights, in real metres with wear. Use for pitches, courts, playgrounds, backyards and arenas.
+// The construction lives in core/goal.ts (emitted from the lab); this component wires it into
+// the config pattern through useSportsInstance.
+const CORE = {
+    DEFAULTS: DEFAULT_SPORTS_OBJECTS.goal,
+    STRUCTURAL,
+    /** Knobs a keyframe or pointer binding may drive per frame — exactly what the push applies. */
+    ANIMATABLE: new Set(SPORTS_OBJECTS_ANIMATABLE.goal.map((p) => p.value)),
+    createUniforms,
+    build,
+};
+const SportsGoal = (props) => {
+    const { rootRef, instance } = useSportsInstance(CORE, props);
+    return (_jsx("group", { ref: rootRef, children: _jsx("primitive", { object: instance.object }) }));
+};
+export default SportsGoal;

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

@@ -0,0 +1,166 @@
+import * as THREE from 'three';
+/** The balls: semi-axes (metres; a along x, b across), natural colours [panel, second panel, seam / stitch], seam width (m), surface roughness. */
+export declare const BALLS: {
+    football: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    basketball: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    tennis: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    baseball: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    volleyball: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    rugby: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    americanFootball: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    golf: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    cricket: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    bowling: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+    beachBall: {
+        a: number;
+        b: number;
+        colors: string[];
+        seam: number;
+        rough: number;
+    };
+};
+export declare const BALL_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;
+    };
+} & {
+    uBall: {
+        value: number;
+    };
+    uAxes: {
+        value: THREE.Vector3;
+    };
+    uSeamW: {
+        value: number;
+    };
+    uSeamDepth: {
+        value: number;
+    };
+    uBulge: {
+        value: number;
+    };
+    uBaseRough: {
+        value: number;
+    };
+    uPanelCol: {
+        value: THREE.Color;
+    };
+    uPanel2Col: {
+        value: THREE.Color;
+    };
+    uSeamCol: {
+        value: THREE.Color;
+    };
+    uCells: {
+        value: THREE.Vector3[];
+    };
+    uSeamPts: {
+        value: any[];
+    };
+    uSeamS: {
+        value: any[];
+    };
+    uSeamLen: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any, mats?: any): void;
+export declare function ballMaterial(u: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+};
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.MeshStandardMaterial[];
+    apply: (cfg: any) => void;
+    update: (dt: any) => void;
+    stats: {
+        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=ball.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ball.d.ts","sourceRoot":"","sources":["../../../../src/components/sports/core/ball.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,mJAAmJ;AACnJ,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjB,CAAC;AACF,eAAO,MAAM,SAAS,UAAqB,CAAC;AAyC5C,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO7B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,MAAY,QAWjD;AAiHD,wBAAgB,YAAY,CAAC,CAAC,KAAA;;;EAuK7B;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EAqBzB;AAED,+GAA+G;AAC/G,eAAO,MAAM,UAAU,UAA+B,CAAC"}

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

@@ -0,0 +1,402 @@
+// Emitted from Claude outputs/sports-lab/ball.mjs by gen_family.mjs — edit the lab module and re-emit.
+// sports/core/ball — Ball (type 'sports', config.type 'ball'). Shared core: ../sportsCore.
+// Construction: one ball at its real diameter, resting on the ground, with its panels and seams
+// built from the geometry of each ball rather than painted: a truncated icosahedron as a spherical
+// Voronoi of 32 cells (football), two great circles and two lobe loops (basketball), the figure-of-
+// eight seam curve of a tennis ball and a baseball (with its V stitches laid along the arc length),
+// 18 cube-face strips (volleyball), a prolate spheroid with four panel seams and laces (rugby,
+// American football), 332 dimples found by an inverse spherical Fibonacci lattice (golf), an
+// equatorial six-row stitched seam (cricket), a marbled resin with three finger holes (bowling) and
+// six gores (beach ball). Seams are grooves (height → bump), panels puff out between them, wear
+// scuffs the leather and dirties the grooves. Size: real metres; the transform places it.
+import * as THREE from 'three';
+import { createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_S, litMaterial, propMesh, disposePair, setColor } from '../sportsCore.js';
+/** The balls: semi-axes (metres; a along x, b across), natural colours [panel, second panel, seam / stitch], seam width (m), surface roughness. */
+export const BALLS = {
+    football: { a: 0.11, b: 0.11, colors: ['#f2f2f0', '#1c1c1e', '#2a2a2c'], seam: 0.0035, rough: 0.5 },
+    basketball: { a: 0.121, b: 0.121, colors: ['#c8622a', '#c8622a', '#1a1a1a'], seam: 0.006, rough: 0.75 },
+    tennis: { a: 0.0335, b: 0.0335, colors: ['#d3e22b', '#d3e22b', '#f4f4e8'], seam: 0.004, rough: 1.0 },
+    baseball: { a: 0.037, b: 0.037, colors: ['#f1ece2', '#f1ece2', '#b8242a'], seam: 0.0012, rough: 0.55 },
+    volleyball: { a: 0.105, b: 0.105, colors: ['#f4f4f0', '#2d5fb0', '#1a1a1a'], seam: 0.003, rough: 0.5 },
+    rugby: { a: 0.15, b: 0.095, colors: ['#f0efe9', '#1d4f9c', '#2a2a2a'], seam: 0.003, rough: 0.65 },
+    americanFootball: { a: 0.14, b: 0.085, colors: ['#7a3b1e', '#f2f2f2', '#f4f4f4'], seam: 0.003, rough: 0.7 },
+    golf: { a: 0.02135, b: 0.02135, colors: ['#f6f6f4', '#f6f6f4', '#9a9a9a'], seam: 0.0, rough: 0.35 },
+    cricket: { a: 0.036, b: 0.036, colors: ['#8d1f1f', '#8d1f1f', '#f4f0e6'], seam: 0.0015, rough: 0.35 },
+    bowling: { a: 0.109, b: 0.109, colors: ['#1b2a5c', '#7a3b9c', '#101010'], seam: 0.0, rough: 0.1 },
+    beachBall: { a: 0.2, b: 0.2, colors: ['#e23a2e', '#2b6fd1', '#f2c230'], seam: 0.002, rough: 0.25 },
+};
+export const BALL_LIST = Object.keys(BALLS);
+// ---------------------------------------------------------------------------- CPU tables shared with the shader
+/** The 32 cell centres of a truncated icosahedron: 12 icosahedron vertices (pentagons) then 20 face centres (hexagons). */
+function footballCells() {
+    const t = (1 + Math.sqrt(5)) / 2;
+    const V = [[-1, t, 0], [1, t, 0], [-1, -t, 0], [1, -t, 0], [0, -1, t], [0, 1, t], [0, -1, -t], [0, 1, -t], [t, 0, -1], [t, 0, 1], [-t, 0, -1], [-t, 0, 1]]
+        .map((v) => new THREE.Vector3(...v).normalize());
+    const F = [[0, 11, 5], [0, 5, 1], [0, 1, 7], [0, 7, 10], [0, 10, 11], [1, 5, 9], [5, 11, 4], [11, 10, 2], [10, 7, 6], [7, 1, 8], [3, 9, 4], [3, 4, 2], [3, 2, 6], [3, 6, 8], [3, 8, 9], [4, 9, 5], [2, 4, 11], [6, 2, 10], [8, 6, 7], [9, 8, 1]];
+    const cells = V.slice();
+    for (const [a, b, c] of F)
+        cells.push(V[a].clone().add(V[b]).add(V[c]).normalize());
+    // tilt so a pentagon does not sit exactly on the pole / toward the camera
+    const q = new THREE.Quaternion().setFromEuler(new THREE.Euler(0.3, 0.2, 0.1));
+    return cells.map((c) => c.applyQuaternion(q));
+}
+/**
+ * The seam of a tennis ball / baseball: where two dumbbell-shaped pieces meet. Thompson's curve
+ *   x = a cos t + b cos 3t,  y = a sin t − b sin 3t,  z = 2√(ab) sin 2t,  a + b = 1
+ * lies exactly on the unit sphere (x² + y² + z² = a² + b² + 2ab = 1) and splits it into two congruent
+ * halves; b sets how deep the lobes reach (≈ 0.29 matches a tennis ball, a baseball is close to it).
+ * N samples + their arc length.
+ */
+function seamCurve(N, b) {
+    const a = 1 - b, c = 2 * Math.sqrt(a * b);
+    const pts = [], s = [];
+    let len = 0, prev = null;
+    for (let i = 0; i < N; i++) {
+        const t = (i / N) * Math.PI * 2;
+        const p = new THREE.Vector3(a * Math.cos(t) + b * Math.cos(3 * t), a * Math.sin(t) - b * Math.sin(3 * t), c * Math.sin(2 * t)).normalize();
+        if (prev)
+            len += p.distanceTo(prev);
+        s.push(len);
+        pts.push(p);
+        prev = p;
+    }
+    len += pts[0].distanceTo(prev);
+    // tilt so the ball does not show the curve exactly edge-on from the default camera
+    const q = new THREE.Quaternion().setFromEuler(new THREE.Euler(0.5, 0.35, 0.2));
+    for (const p of pts)
+        p.applyQuaternion(q);
+    return { pts, s, len };
+}
+const CELLS = footballCells();
+const SEAM = seamCurve(96, 0.29);
+export function createUniforms() {
+    return Object.assign(createCommonUniforms(), {
+        uBall: { value: 0 }, uAxes: { value: new THREE.Vector3(0.11, 0.11, 0.11) }, uSeamW: { value: 0.0035 }, uSeamDepth: { value: 1 }, uBulge: { value: 0.5 },
+        uBaseRough: { value: 0.5 },
+        uPanelCol: { value: new THREE.Color() }, uPanel2Col: { value: new THREE.Color() }, uSeamCol: { value: new THREE.Color() },
+        uCells: { value: CELLS }, uSeamPts: { value: SEAM.pts }, uSeamS: { value: SEAM.s }, uSeamLen: { value: SEAM.len },
+    });
+}
+export function applyConfig(u, c, mats = undefined) {
+    applyCommonConfig(u, c, mats);
+    const B = BALLS[c.sport] || BALLS.football;
+    const nat = c.naturalColors !== false;
+    setColor(u.uPanelCol, nat ? B.colors[0] : c.color);
+    setColor(u.uPanel2Col, nat ? B.colors[1] : c.secondaryColor);
+    setColor(u.uSeamCol, nat ? B.colors[2] : c.accentColor);
+    if (c.sport !== undefined) {
+        u.uBall.value = Math.max(0, BALL_LIST.indexOf(c.sport));
+        u.uAxes.value.set(B.a, B.b, B.b);
+        u.uBaseRough.value = B.rough;
+    }
+    if (c.seamWidth !== undefined)
+        u.uSeamW.value = B.seam * c.seamWidth;
+    if (c.seamDepth !== undefined)
+        u.uSeamDepth.value = c.seamDepth;
+    if (c.bulge !== undefined)
+        u.uBulge.value = c.bulge;
+}
+// ---------------------------------------------------------------------------- GLSL
+// Shared by the vertex (panel bulge) and the fragment: the seam distance of every ball in metres on
+// the unit direction n (object space, normalised by the semi-axes).
+const BALL_GLSL = /* glsl */ `
+uniform float uBall, uSeamW, uSeamDepth, uBulge, uBaseRough, uSeamLen;
+uniform vec3 uAxes, uPanelCol, uPanel2Col, uSeamCol;
+uniform vec3 uCells[32];
+uniform vec3 uSeamPts[96];
+uniform float uSeamS[96];
+const float PI_B = 3.14159265;
+float gcDist(vec3 n, vec3 axis) { return asin(clamp(abs(dot(n, axis)), 0.0, 1.0)); }   // angular distance to a great circle
+// basketball lobe loop around the side point s: radius ρ0(ψ) = 0.70 + 0.73 sin²ψ
+float lobeDist(vec3 n, vec3 s) {
+    float rho = acos(clamp(dot(n, s), -1.0, 1.0));
+    vec3 e1 = vec3(0.0, 1.0, 0.0), e2 = cross(s, e1);
+    float psi = atan(dot(n, e1), dot(n, e2));
+    float sp = sin(psi);
+    return abs(rho - (0.70 + 0.73 * sp * sp));
+}
+// nearest point on the sampled seam curve: chord distance and the arc length there (both unit-sphere)
+void seamCurve(vec3 n, out float dist, out float along, out float side) {
+    float best = 1e9; int bi = 0;
+    for (int i = 0; i < 96; i++) { float d = dot(n - uSeamPts[i], n - uSeamPts[i]); if (d < best) { best = d; bi = i; } }
+    int i0 = bi, i1 = (bi + 1) % 96, im = (bi + 95) % 96;
+    // refine on the two neighbouring segments
+    vec3 a = uSeamPts[i0], b = uSeamPts[i1], c = uSeamPts[im];
+    vec3 ab = b - a; float tb = clamp(dot(n - a, ab) / dot(ab, ab), 0.0, 1.0); vec3 pb = a + ab * tb;
+    vec3 ac = c - a; float tc = clamp(dot(n - a, ac) / dot(ac, ac), 0.0, 1.0); vec3 pc = a + ac * tc;
+    float db = length(n - pb), dc = length(n - pc);
+    vec3 p = db < dc ? pb : pc; vec3 tang = db < dc ? ab : -ac;
+    dist = min(db, dc);
+    along = db < dc ? uSeamS[i0] + tb * length(ab) : uSeamS[i0] - tc * length(ac);
+    side = sign(dot(cross(normalize(tang), p), n - p));
+}
+// inverse spherical Fibonacci lattice (I. Quilez): nearest of N points to n, returns its squared distance
+float sfNearest(vec3 p, float n) {
+    const float PHI = 1.61803398875;
+    float m = 1.0 - 1.0 / n;
+    float phi = min(atan(p.y, p.x), PI_B), cosTheta = p.z;
+    float k = max(2.0, floor(log(n * PI_B * sqrt(5.0) * (1.0 - cosTheta * cosTheta)) / log(PHI + 1.0)));
+    float Fk = pow(PHI, k) / sqrt(5.0);
+    vec2 F = vec2(floor(Fk + 0.5), floor(Fk * PHI + 0.5));
+    vec2 ka = 2.0 * F / n; vec2 kb = 2.0 * PI_B * (fract((F + 1.0) * PHI) - (PHI - 1.0));
+    mat2 iB = mat2(ka.y, -ka.x, kb.y, -kb.x) / (ka.y * kb.x - ka.x * kb.y);
+    vec2 c = floor(iB * vec2(phi, cosTheta - m));
+    float d = 8.0;
+    for (int s = 0; s < 4; s++) {
+        vec2 uv = vec2(float(s - 2 * (s / 2)), float(s / 2));
+        float i = dot(F, uv + c);
+        float ph = 2.0 * PI_B * fract(i * PHI);
+        float ct = m - 2.0 * i / n;
+        float st = sqrt(1.0 - ct * ct);
+        vec3 q = vec3(cos(ph) * st, sin(ph) * st, ct);
+        d = min(d, dot(q - p, q - p));
+    }
+    return d;
+}
+// The seam distance (metres) and which panel we are on (0 main, 1 second, 2 third) for the panelled balls.
+float seamDist(vec3 n, out float panel) {
+    panel = 0.0;
+    int b = int(uBall + 0.5);
+    float r = uAxes.y;
+    if (b == 0) {                                  // football: spherical Voronoi of 32 cells, pentagons biased smaller
+        float a1 = 1e9, a2 = 1e9; int c1 = 0;
+        for (int i = 0; i < 32; i++) {
+            float a = acos(clamp(dot(n, uCells[i]), -1.0, 1.0)) + (i < 12 ? 0.045 : 0.0);
+            if (a < a1) { a2 = a1; a1 = a; c1 = i; } else if (a < a2) a2 = a;
+        }
+        panel = c1 < 12 ? 1.0 : 0.0;
+        return (a2 - a1) * 0.5 * r;
+    } else if (b == 1) {                           // basketball: equator, meridian, two lobe loops
+        float d = min(gcDist(n, vec3(0, 1, 0)), gcDist(n, vec3(1, 0, 0)));
+        d = min(d, min(lobeDist(n, vec3(0, 0, 1)), lobeDist(n, vec3(0, 0, -1))));
+        return d * r;
+    } else if (b == 2 || b == 3) {                 // tennis / baseball: the figure-of-eight curve
+        float d, s, sd; seamCurve(n, d, s, sd);
+        return d * r;
+    } else if (b == 4) {                           // volleyball: 6 cube faces × 3 strips, strips turned on alternate faces
+        vec3 an = abs(n);
+        float axis = an.x >= an.y && an.x >= an.z ? 0.0 : an.y >= an.z ? 1.0 : 2.0;
+        vec2 uv = axis == 0.0 ? n.yz / an.x : axis == 1.0 ? n.xz / an.y : n.xy / an.z;    // gnomonic, -1..1
+        float sgn = axis == 0.0 ? sign(n.x) : axis == 1.0 ? sign(n.y) : sign(n.z);
+        vec2 ang = atan(uv);                                                               // -45°..45°
+        float edge = 0.7854 - max(abs(ang.x), abs(ang.y));                                 // to the face edge
+        float flip = mod(axis + (sgn > 0.0 ? 0.0 : 1.0), 2.0);                             // which way the strips run
+        float t = flip < 0.5 ? ang.x : ang.y;
+        float strip = floor((t + 0.7854) / 0.5236);                                        // 3 strips of 30°
+        float ds = abs(mod(t + 0.7854, 0.5236) - 0.2618);
+        ds = 0.2618 - ds;                                                                  // to the strip seam
+        panel = strip == 1.0 ? 1.0 : 0.0;
+        return min(edge, ds) * r;
+    } else if (b == 5 || b == 6) {                 // rugby / american: four panel seams around the long axis (x)
+        float phi = atan(n.z, n.y);
+        float d = abs(mod(phi + PI_B * 0.25, PI_B * 0.5) - PI_B * 0.25);                   // to the nearest of 4 meridians
+        float lat = asin(clamp(n.x, -1.0, 1.0));
+        return d * cos(lat) * r;
+    } else if (b == 8) {                           // cricket: the equatorial seam (x = 0)
+        return gcDist(n, vec3(1, 0, 0)) * r;
+    } else if (b == 10) {                          // beach ball: six gores
+        float phi = atan(n.z, n.x);
+        float d = abs(mod(phi + PI_B / 6.0, PI_B / 3.0) - PI_B / 6.0);
+        float gore = floor((phi + PI_B) / (PI_B / 3.0) + 0.5);
+        panel = mod(gore, 2.0) < 0.5 ? 0.0 : (mod(gore, 6.0) < 2.5 ? 1.0 : (mod(gore, 6.0) < 4.5 ? 2.0 : 3.0));
+        float lat = asin(clamp(n.y, -1.0, 1.0));
+        float cap = 1.25 - abs(lat);                                                       // polar caps
+        return min(d * cos(lat), abs(cap)) * r;
+    }
+    return 1e9;
+}
+`;
+export function ballMaterial(u) {
+    return litMaterial(u, {
+        name: 'ball', roughness: 0.5, metalness: 0, envMapIntensity: 0.7,
+        vPars: BALL_GLSL,
+        vCode: /* glsl */ `
+    {
+        // panels puff out between the seams (a leather ball is stitched and inflated), seams stay on the sphere
+        vec3 nn = normalize(position / uAxes);
+        float pnl; float sd = seamDist(nn, pnl);
+        float w = max(uSeamW, 0.002);
+        float puff = smoothstep(0.0, w * 4.0, sd) * (uBall < 0.5 || uBall == 1.0 || uBall == 4.0 ? 1.0 : 0.0);
+        transformed += normal * uBulge * puff * uAxes.y * 0.012;
+    }`,
+        pars: BALL_GLSL + /* glsl */ `
+float ballRough; float ballH;
+// stitch rows: short threads every pitch along s at a lateral offset, as a coverage (0..1) and a height
+float threads(float s, float lat, float pitch, float off, float len, float tw, out float h) {
+    float k = floor(s / pitch); float c = (k + 0.5) * pitch;
+    // a thread runs from (c - len/2, off) to (c + len/2, off + len*0.5): a slanted stitch
+    vec2 a = vec2(c - len * 0.5, off), b = vec2(c + len * 0.5, off + len * 0.6);
+    vec2 p = vec2(s, lat);
+    vec2 ab = b - a; float t = clamp(dot(p - a, ab) / dot(ab, ab), 0.0, 1.0);
+    float d = length(p - a - ab * t);
+    float fw = fwidth(s) + 1e-6;
+    float cov = 1.0 - smoothstep(tw - fw, tw + fw, d);
+    h = cov * tw;
+    return cov;
+}`,
+        color: /* glsl */ `
+    vec3 n = normalize(vObj / uAxes);
+    float r = uAxes.y;
+    int b = int(uBall + 0.5);
+    float pnl; float sd = seamDist(n, pnl);
+    float w = uSeamW;
+    float worn = scuffs(vObj * 1.0, 60.0 / r, 0.5);
+    vec3 col = pnl < 0.5 ? uPanelCol : pnl < 1.5 ? uPanel2Col : pnl < 2.5 ? uSeamCol : vec3(0.95);
+    if (b == 10 && pnl > 2.5) col = vec3(0.95);
+    float rough = uBaseRough;
+    float h = 0.0;
+    // the seam: a groove with a dark floor; seam-coloured thread on the balls that show one
+    float fw = fwidth(sd) * 0.8 + 1e-6;
+    float groove = 1.0 - smoothstep(w * 0.5 - fw, w * 0.5 + fw, sd);
+    float inGroove = 1.0 - smoothstep(0.0, w * 1.2, sd);
+    if (b == 0) {                                  // football: pebbled PU, dark groove, dirt in the seams when worn
+        float peb = snoise3(vObj * 2200.0 / (r / 0.11));
+        col *= 0.93 + 0.1 * peb;
+        col = mix(col, col * 0.35 + uSeamCol * 0.3, groove);
+        h = -inGroove * 0.0012 * uSeamDepth + peb * 0.00004;
+        rough = mix(uBaseRough, 0.85, inGroove) + 0.06 * peb;
+    } else if (b == 1) {                           // basketball: pebble grain, black channels
+        float peb = snoise3(vObj * 1600.0 / (r / 0.12)) * 0.6 + snoise3(vObj * 4800.0 / (r / 0.12)) * 0.4;
+        col *= 0.86 + 0.26 * peb;
+        col = mix(col, uSeamCol, groove);
+        h = -inGroove * 0.0025 * uSeamDepth + peb * 0.00012 * (1.0 - groove);
+        rough = mix(uBaseRough + 0.1 * peb, 0.9, groove);
+    } else if (b == 2) {                           // tennis: felt nap with a sheen at grazing angles; the seam a pale recessed band
+        float d, s, sdn; seamCurve(n, d, s, sdn);
+        float nap = snoise3(vObj * 9000.0) * 0.5 + snoise3(vObj * 2600.0 + 3.0) * 0.5;
+        float band = 1.0 - smoothstep(w * 0.5 - fw, w * 0.5 + fw, sd);
+        col = mix(col * (0.85 + 0.3 * nap), uSeamCol * (0.9 + 0.15 * nap), band);
+        float sheen = pow(1.0 - abs(dot(normalize(vNormal), normalize(vViewPosition))), 2.5);
+        col *= 1.0 + 0.55 * sheen * (1.0 - band);
+        h = -band * 0.0007 * uSeamDepth + nap * 0.00015;
+        rough = 1.0;
+    } else if (b == 3) {                           // baseball: leather, two rows of red V stitches along the seam
+        float d, s, sdn; seamCurve(n, d, s, sdn);
+        float lat = d * r * sdn;                                   // signed lateral distance, metres
+        float sm = s * r;                                          // arc length, metres
+        float pitch = uSeamLen * r / 54.0;                         // 108 stitches = 54 pairs around the curve
+        float h1, h2;
+        float st = max(threads(sm, lat, pitch, 0.0018, pitch * 0.55, 0.0005 * uSeamW / max(uSeamW, 1e-3) + 0.00025, h1),
+                       threads(sm, -lat, pitch, 0.0018, pitch * 0.55, 0.0005 * uSeamW / max(uSeamW, 1e-3) + 0.00025, h2));
+        float grain = snoise3(vObj * 3000.0);
+        col *= 0.95 + 0.08 * grain;
+        float cut = 1.0 - smoothstep(0.0, 0.0012, sd);           // the leather edges meet along the curve
+        col = mix(col, col * 0.75, cut * 0.6);
+        col = mix(col, uSeamCol, st);
+        h = -cut * 0.0004 + max(h1, h2) * 1.4 * uSeamDepth;
+        rough = mix(uBaseRough, 0.7, st);
+    } else if (b == 4) {                           // volleyball: soft leather panels, fine seam lines
+        float grain = snoise3(vObj * 2500.0);
+        col *= 0.95 + 0.08 * grain;
+        col = mix(col, col * 0.4 + uSeamCol * 0.2, groove);
+        h = -inGroove * 0.001 * uSeamDepth;
+        rough = mix(uBaseRough, 0.8, inGroove);
+    } else if (b == 5 || b == 6) {                 // rugby / american: pimpled grain, panel seams, end stripes, laces
+        float pim = snoise3(vObj * 1800.0 / (r / 0.09)) * 0.6 + snoise3(vObj * 5000.0 / (r / 0.09)) * 0.4;
+        col *= 0.9 + 0.2 * pim;
+        float ax = abs(n.x);
+        float stripe = smoothstep(0.58, 0.6, ax) * (1.0 - smoothstep(0.7, 0.72, ax));
+        col = mix(col, uPanel2Col, stripe * (b == 6 ? 1.0 : 0.85));
+        col = mix(col, col * 0.45, groove);
+        h = pim * 0.00014 * (1.0 - groove) - inGroove * 0.0015 * uSeamDepth;
+        rough = uBaseRough + 0.08 * pim;
+        if (b == 6) {
+            // laces: a strip on top (+y meridian) from x = -0.22 to 0.22 of the length, one long lace and eight cross laces
+            float phi = atan(n.z, n.y);
+            float lx = asin(clamp(n.x, -1.0, 1.0)) * uAxes.x;                           // metres along the ball
+            float lz = phi * r;                                                        // metres across the top
+            float inStrip = step(abs(lx), 0.047) * step(abs(lz), 0.014);
+            float longLace = (1.0 - smoothstep(0.0022, 0.0032, abs(lz))) * step(abs(lx), 0.047);
+            float k = floor((lx + 0.047) / 0.0118);
+            float cx = (k + 0.5) * 0.0118 - 0.047;
+            float cross = (1.0 - smoothstep(0.0022, 0.0032, abs(lx - cx))) * step(abs(lz), 0.012) * step(abs(lx), 0.045);
+            float lace = max(longLace, cross);
+            col = mix(col, col * 0.6, inStrip * (1.0 - lace) * 0.5);
+            col = mix(col, uSeamCol, lace);
+            h += lace * 0.0022 - inStrip * 0.0008;
+            rough = mix(rough, 0.6, lace);
+        }
+    } else if (b == 7) {                           // golf: dimples on an inverse Fibonacci lattice
+        float d2 = sfNearest(n, 332.0);
+        float dd = sqrt(d2);
+        float dr = 0.085;
+        float t = clamp(dd / dr, 0.0, 1.0);
+        float dimple = (1.0 - t * t); dimple *= dimple;
+        h = -dimple * 0.0011 * (0.5 + uSeamDepth * 0.5);
+        col *= 0.97 + 0.03 * snoise3(vObj * 20000.0);
+        col *= 1.0 - 0.18 * dimple;                                            // a touch of occlusion in the dimples
+        col = mix(col, col * 0.88, worn * 0.5);
+        rough = uBaseRough + 0.1 * dimple;
+    } else if (b == 8) {                           // cricket: polished red leather, raised equatorial seam with six rows of stitches
+        float lat = asin(clamp(n.x, -1.0, 1.0)) * r;                                  // metres from the seam
+        float lon = atan(n.z, n.y) * r;                                               // metres along it
+        float ridge = 1.0 - smoothstep(0.0, 0.0024, abs(lat));
+        float h1, h2, h3;
+        float st = threads(lon, abs(lat), 0.0032, 0.0025, 0.0018, 0.0004, h1);
+        st = max(st, threads(lon + 0.0016, abs(lat), 0.0032, 0.0048, 0.0018, 0.0004, h2));
+        st = max(st, threads(lon, abs(lat), 0.0032, 0.0071, 0.0018, 0.0004, h3));
+        float quarter = (1.0 - smoothstep(0.0003, 0.0007, gcDist(n, vec3(0, 0, 1)) * r)) * step(0.012, abs(lat));
+        float grain = snoise3(vObj * 4000.0);
+        col *= 0.93 + 0.12 * grain;
+        col = mix(col, col * 0.6, ridge * 0.4 + quarter * 0.5);
+        col = mix(col, uSeamCol, st);
+        h = ridge * 0.0008 * uSeamDepth + max(max(h1, h2), h3) * 1.2 - quarter * 0.0002;
+        rough = mix(uBaseRough, 0.75, max(st, ridge));
+        // polished on one side (the shine side), scuffed on the other
+        rough = mix(rough, 0.6, smoothstep(0.0, 0.3, n.z) * worn);
+    } else if (b == 9) {                           // bowling: marbled resin, three finger holes near the top
+        float swirl = sfbm3(n * 2.5 + uSeed) ;
+        float veins = 1.0 - abs(2.0 * sfbm3(n * 5.0 + vec3(swirl * 2.0)) - 1.0);
+        col = mix(uPanelCol, uPanel2Col, smoothstep(0.35, 0.65, swirl));
+        col = mix(col, col * 1.6, smoothstep(0.85, 0.98, veins) * 0.6);
+        vec3 hA = normalize(vec3(0.0, 0.93, 0.36)), hB = normalize(vec3(0.17, 0.98, -0.08)), hC = normalize(vec3(-0.17, 0.98, -0.08));
+        float holes = min(acos(clamp(dot(n, hA), -1.0, 1.0)) - 0.13, min(acos(clamp(dot(n, hB), -1.0, 1.0)), acos(clamp(dot(n, hC), -1.0, 1.0))) - 0.105);
+        float hole = 1.0 - smoothstep(-0.01, 0.01, holes);
+        col = mix(col, uSeamCol, hole);
+        h = -hole * 0.004;
+        rough = mix(uBaseRough, 0.9, hole) + worn * 0.25;
+    } else {                                       // beach ball: glossy vinyl gores
+        col *= 0.97 + 0.05 * snoise3(vObj * 600.0);
+        col = mix(col, col * 0.6, groove * 0.7);
+        h = -inGroove * 0.0006;
+        rough = uBaseRough + worn * 0.3;
+    }
+    // wear: scuffs lighten leather and rubber, dirt collects in the grooves
+    if (b != 7 && b != 9) {
+        col = mix(col, col * 1.25 + 0.04, worn * 0.6 * (1.0 - groove));
+        col = mix(col, col * 0.55, uWear * 0.6 * inGroove);
+        rough = mix(rough, 0.85, worn * 0.5);
+    }
+    ballRough = clamp(rough / max(uGloss, 0.05), 0.03, 1.0);
+    ballH = h;
+    diffuseColor.rgb *= col;`,
+        rough: 'ballRough',
+        normal: /* glsl */ `normal = bumpNormal(normal, ballH);`,
+    });
+}
+export function build(u, c) {
+    const B = BALLS[c.sport] || BALLS.football;
+    const q = QUALITY_S[c.quality] || 1;
+    const seg = Math.round(56 * Math.sqrt(q)) * 2;
+    const geo = new THREE.SphereGeometry(1, seg, Math.round(seg * 0.6));
+    geo.scale(B.a, B.b, B.b);
+    geo.computeVertexNormals();
+    // centred geometry (the seams and panels are functions of the direction from the centre); the mesh is lifted so it rests on the ground
+    const pair = ballMaterial(u);
+    const mesh = propMesh(geo, pair, 'ball');
+    mesh.position.y = B.b;
+    const object = new THREE.Group();
+    object.name = 'ball';
+    object.add(mesh);
+    const mats = [pair.material];
+    applyConfig(u, c, mats);
+    return {
+        object, materials: mats,
+        apply: function (cfg) { applyConfig(u, cfg, mats); },
+        update: function (dt) { updateCommon(u, dt); },
+        stats: { verts: geo.attributes.position.count },
+        dispose: function () { geo.dispose(); disposePair(pair); },
+    };
+}
+/** Knobs whose change rebuilds the object (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['sport', 'quality', 'seed'];