@johnmorrisdotca/dougu-sports 0.26.0 → 0.28.0

package/dist/emblems/lathe.extras.js

@@ -9,7 +9,7 @@ const pt = (x, y) => `${f(x)} ${f(y)}`;
 export function LATHE_EXTRAS(c, d) {
     const { p, solid, yaw, where, at } = c;
     if (d[0] === "mesh") {
-        const [, y0, y1, n, rows] = d;
+        const [, y0, y1, n, rows, name, width = 0.55] = d;
         let m = "";
         for (let i = 0; i < n; i++) {
             for (const way of [1, -1]) {
@@ -27,7 +27,13 @@ export function LATHE_EXTRAS(c, d) {
                 }
             }
         }
-        return m === "" ? "" : `<path d="${m}" stroke="${mix(c.base.rgb, 0.55)}" stroke-width=".55" stroke-opacity=".9"/>`;
+        if (m === "")
+            return "";
+        if (name === undefined)
+            return `<path d="${m}" stroke="${mix(c.base.rgb, 0.55)}" stroke-width=".55" stroke-opacity=".9"/>`;
+        // An etched net in a tone of its own: a dark line, then the tone laid on it a little to the side.
+        const t = c.tone(name);
+        return `<path d="${m}" transform="translate(.2 .25)" stroke="${mix(c.base.rgb, -0.6)}" stroke-width="${width}" stroke-opacity=".4"/><path d="${m}" stroke="${mix(t.rgb, 0.05)}" stroke-width="${width}"/>`;
     }
     if (d[0] === "patch") {
         const [, y0, y1, deg0, deg1, name] = d;
@@ -57,3 +63,72 @@ export function LATHE_EXTRAS(c, d) {
     };
     return `<path d="M${lerp(y0, u0)}L${lerp(y0, u1)}L${lerp(y1, u1)}L${lerp(y1, u0)}z" fill="${t.fill}" stroke="${t.edge}" stroke-width=".5"/>`;
 }
+const rotate = (v, lz, lx, yaw) => {
+    const [x0, y0, z0] = v;
+    const x1 = x0 * Math.cos(lz) - y0 * Math.sin(lz);
+    const y1 = x0 * Math.sin(lz) + y0 * Math.cos(lz);
+    const y2 = y1 * Math.cos(lx) - z0 * Math.sin(lx);
+    const z2 = y1 * Math.sin(lx) + z0 * Math.cos(lx);
+    return [x1 * Math.cos(yaw) + z2 * Math.sin(yaw), y2, -x1 * Math.sin(yaw) + z2 * Math.cos(yaw)];
+};
+/** The great circles of a basketball's seams, by their normals: the equator, the meridian, and the two curved seams that run from pole to pole at 60 degrees either side of it. */
+const SEAMS = [[0, 1, 0], [1, 0, 0], [Math.cos(Math.PI / 3), 0, -Math.sin(Math.PI / 3)], [Math.cos(Math.PI / 3), 0, Math.sin(Math.PI / 3)]];
+/** Draws the seams of a basketball as grooves (each the front half of a great circle: one elliptical arc), and the specks of a grained finish. */
+export function LATHE_BALL(c) {
+    const { ball, cx, cy } = c;
+    const r = ball.r;
+    const lz = ((ball.lean?.[0] ?? 0) * Math.PI) / 180;
+    const lx = ((ball.lean?.[1] ?? 0) * Math.PI) / 180;
+    const yaw = (c.yaw * Math.PI) / 180;
+    const e = (c.elevation * Math.PI) / 180;
+    const se = Math.sin(e);
+    const ce = Math.cos(e);
+    const view = [0, se, ce];
+    const screen = (v) => [v[0], -v[1] * ce + v[2] * se];
+    const t = c.tone(ball.tone);
+    let m = "";
+    for (const n0 of SEAMS) {
+        const n = rotate(n0, lz, lx, yaw);
+        const facing = n[0] * view[0] + n[1] * view[1] + n[2] * view[2];
+        const limb = [n[1] * view[2] - n[2] * view[1], n[2] * view[0] - n[0] * view[2], n[0] * view[1] - n[1] * view[0]];
+        const size = Math.hypot(...limb);
+        if (size < 0.02)
+            continue;
+        const a = screen([limb[0] / size, limb[1] / size, limb[2] / size]);
+        const near = [view[0] - facing * n[0], view[1] - facing * n[1], view[2] - facing * n[2]];
+        const k = Math.hypot(...near);
+        const mid = screen([near[0] / k, near[1] / k, near[2] / k]);
+        const sweep = a[0] * mid[1] - a[1] * mid[0] > 0 ? 1 : 0;
+        const angle = (Math.atan2(a[1], a[0]) * 180) / Math.PI;
+        m += `M${pt(cx + r * a[0], cy + r * a[1])}A${f(r)} ${f(Math.max(0.05, r * Math.abs(facing)))} ${f(angle)} 0 ${sweep} ${pt(cx - r * a[0], cy - r * a[1])}`;
+    }
+    let out = "";
+    if (m !== "") {
+        if (c.line)
+            out += `<path d="${m}" stroke-width="1.4"/>`;
+        else if (c.flat)
+            out += `<path d="${m}" stroke="${mix(t.rgb, -0.4)}" stroke-width="1"/>`;
+        else {
+            const inlay = ball.seam === undefined ? undefined : c.tone(ball.seam);
+            out += `<path d="${m}" stroke="${mix(t.rgb, -0.5)}" stroke-width="${inlay === undefined ? 0.75 : 0.85}"/>`;
+            out += inlay === undefined ? `<path d="${m}" transform="translate(.35 .4)" stroke="${mix(t.rgb, 0.55)}" stroke-width=".3" stroke-opacity=".8"/>` : `<path d="${m}" stroke="${mix(inlay.rgb, 0.1)}" stroke-width=".42"/>`;
+        }
+    }
+    const grain = ball.grain ?? 0;
+    if (grain > 0 && !c.line) {
+        let dots = "";
+        for (let i = 0; i < grain; i++) {
+            const y = 1 - (2 * (i + 0.5)) / grain;
+            const ring = Math.sqrt(1 - y * y);
+            const theta = i * 2.39996;
+            const p = rotate([ring * Math.cos(theta), y, ring * Math.sin(theta)], lz, lx, yaw);
+            if (p[0] * view[0] + p[1] * view[1] + p[2] * view[2] < 0.12)
+                continue;
+            const [sx, sy] = screen(p);
+            dots += `M${pt(cx + r * sx, cy + r * sy)}h0`;
+        }
+        if (dots !== "")
+            out += `<path d="${dots}" stroke="${mix(t.rgb, -0.5)}" stroke-width=".36" stroke-opacity=".6"/>`;
+    }
+    return out;
+}

package/dist/emblems/lathe.framed.d.ts

@@ -0,0 +1,30 @@
+import { type Rgb } from "./emblem.core.ts";
+import type { FramedCtx } from "./emblem.lathe.ts";
+/** A point or a direction: x to the right, y down, z toward the eye at rest, in the lathe's units about the axis x = 0 (drawn at x = 32). */
+export type V3 = readonly [x: number, y: number, z: number];
+/** The turn and the eye of a drawing: rotate a point about the axis, place it on the page, and say how near the eye it is and whether a direction faces the eye. */
+export declare function viewOf(c: Pick<FramedCtx, "yaw" | "s">): {
+    rot: (v: V3) => V3;
+    at: (r: V3) => readonly [number, number];
+    depth: (r: V3) => number;
+    facing: (n: V3) => number;
+};
+export declare const sub: (a: V3, b: V3) => V3;
+export declare const cross: (a: V3, b: V3) => V3;
+export declare const unit: (a: V3) => V3;
+/** The normal of a facet from its first, middle and last points (a quadrilateral's diagonals). */
+export declare const normalOf: (p: readonly V3[]) => V3;
+/**
+ * How light polished metal is where a facet faces some way: -1 (black) to 1 (white), for a rotated, unit normal and the elevation of the eye `s`. Two sided, because a thin sheet is seen from either side. A polished
+ * surface shows what it mirrors, so the shade is read off a small room: a bright sky above, a dark band at the horizon, a mid floor and a bright window to the upper left. A facet that turns from the sky to the floor
+ * as a band twists runs from white through black to grey, the way chrome does.
+ */
+export declare function chrome(n: V3, s: number): number;
+/** A colour for a shade from `chrome`, kept to a few steps so that neighbouring facets that differ by a hair are one colour. */
+export declare const shadeOf: (rgb: Rgb, v: number, steps?: number) => string;
+/** A smooth curve through a table of `[x, y]` points that never overshoots them (monotone cubic), as a function of x; outside the table it holds the end values. */
+export declare function curve(table: readonly (readonly [number, number])[]): (x: number) => number;
+/** A straight-line table: the value at x between the two points either side of it. */
+export declare function lin(table: readonly (readonly [number, number])[]): (x: number) => number;
+/** The points as a path: a closed polygon, or an open line. */
+export declare const line: (pts: readonly (readonly [number, number])[], closed: boolean, digits?: 1 | 2) => string;

package/dist/emblems/lathe.framed.js

@@ -0,0 +1,98 @@
+// The small 3D that a body of revolution's own `framed` drawer use (`FramedCtx` in emblem.lathe.ts): a point turned by the yaw and placed the way the body's surface is placed, a polished-metal shade for a facet from the way it
+// faces, a smooth curve through a table of measurements, and the paths of polygons. Nothing here knows any one emblem; a body with no framed parts does not take this module. Imports only the core.
+import { mix } from "./emblem.core.js";
+const RAD = Math.PI / 180;
+const one = (n) => String(Math.round(n * 10) / 10 + 0);
+const two = (n) => String(Math.round(n * 100) / 100 + 0);
+/** The turn and the eye of a drawing: rotate a point about the axis, place it on the page, and say how near the eye it is and whether a direction faces the eye. */
+export function viewOf(c) {
+    const cy = Math.cos(c.yaw * RAD);
+    const sy = Math.sin(c.yaw * RAD);
+    const ce = Math.sqrt(1 - c.s * c.s);
+    return {
+        rot: (v) => [v[0] * cy + v[2] * sy, v[1], v[2] * cy - v[0] * sy],
+        at: (r) => [32 + r[0], r[1] + c.s * r[2]],
+        depth: (r) => r[2] * ce - r[1] * c.s,
+        facing: (n) => n[2] * ce - n[1] * c.s,
+    };
+}
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+export const unit = (a) => {
+    const m = Math.hypot(a[0], a[1], a[2]) || 1;
+    return [a[0] / m, a[1] / m, a[2] / m];
+};
+/** The normal of a facet from its first, middle and last points (a quadrilateral's diagonals). */
+export const normalOf = (p) => unit(cross(sub(p[2], p[0]), sub(p[p.length - 1], p[1])));
+const smooth = (x, a, b) => {
+    const t = Math.max(0, Math.min(1, (x - a) / (b - a)));
+    return t * t * (3 - 2 * t);
+};
+/**
+ * How light polished metal is where a facet faces some way: -1 (black) to 1 (white), for a rotated, unit normal and the elevation of the eye `s`. Two sided, because a thin sheet is seen from either side. A polished
+ * surface shows what it mirrors, so the shade is read off a small room: a bright sky above, a dark band at the horizon, a mid floor and a bright window to the upper left. A facet that turns from the sky to the floor
+ * as a band twists runs from white through black to grey, the way chrome does.
+ */
+export function chrome(n, s) {
+    const ce = Math.sqrt(1 - s * s);
+    const eye = [0, -s, ce];
+    let m = n;
+    let d = m[0] * eye[0] + m[1] * eye[1] + m[2] * eye[2];
+    if (d < 0) {
+        m = [-m[0], -m[1], -m[2]];
+        d = -d;
+    }
+    const r = [2 * d * m[0] - eye[0], 2 * d * m[1] - eye[1], 2 * d * m[2] - eye[2]];
+    const up = -r[1];
+    const window = r[2] > 0 ? Math.exp(-(((r[0] + 0.5) / 0.34) ** 2 + ((up - 0.4) / 0.3) ** 2)) : 0;
+    const v = -0.12 + 0.95 * smooth(up, -0.12, 0.4) - 0.6 * Math.exp(-(((up + 0.02) / 0.14) ** 2)) + 0.75 * window;
+    return Math.max(-0.72, Math.min(0.9, v));
+}
+/** A colour for a shade from `chrome`, kept to a few steps so that neighbouring facets that differ by a hair are one colour. */
+export const shadeOf = (rgb, v, steps = 24) => mix(rgb, Math.round(v * steps) / steps);
+/** A smooth curve through a table of `[x, y]` points that never overshoots them (monotone cubic), as a function of x; outside the table it holds the end values. */
+export function curve(table) {
+    const n = table.length;
+    const dx = table.slice(1).map((p, i) => p[0] - table[i][0]);
+    const dy = table.slice(1).map((p, i) => p[1] - table[i][1]);
+    const m = dy.map((d, i) => d / dx[i]);
+    const t = table.map((_, i) => (i === 0 ? m[0] : i === n - 1 ? m[n - 2] : m[i - 1] * m[i] <= 0 ? 0 : (2 * m[i - 1] * m[i]) / (m[i - 1] + m[i])));
+    return (x) => {
+        const first = table[0];
+        const last = table[n - 1];
+        if (x <= first[0])
+            return first[1];
+        if (x >= last[0])
+            return last[1];
+        let i = 0;
+        while (x > table[i + 1][0])
+            i++;
+        const a = table[i];
+        const w = dx[i];
+        const u = (x - a[0]) / w;
+        const u2 = u * u;
+        const u3 = u2 * u;
+        return (2 * u3 - 3 * u2 + 1) * a[1] + (u3 - 2 * u2 + u) * w * t[i] + (-2 * u3 + 3 * u2) * table[i + 1][1] + (u3 - u2) * w * t[i + 1];
+    };
+}
+/** A straight-line table: the value at x between the two points either side of it. */
+export function lin(table) {
+    return (x) => {
+        const first = table[0];
+        if (x <= first[0])
+            return first[1];
+        for (let i = 1; i < table.length; i++) {
+            const b = table[i];
+            if (x <= b[0]) {
+                const a = table[i - 1];
+                return a[1] + ((b[1] - a[1]) * (x - a[0])) / (b[0] - a[0]);
+            }
+        }
+        return table[table.length - 1][1];
+    };
+}
+/** The points as a path: a closed polygon, or an open line. */
+export const line = (pts, closed, digits = 1) => {
+    const w = digits === 1 ? one : two;
+    return `M${pts.map((p) => `${w(p[0])} ${w(p[1])}`).join("L")}${closed ? "z" : ""}`;
+};

package/dist/emblems/lathe.sculpt.d.ts

@@ -0,0 +1,6 @@
+import type { Part, SculptCtx } from "./emblem.lathe.ts";
+/** Draws the parts of a model: the ones that are `under` the bodies, and the rest, each group from far to near. */
+export declare function LATHE_SCULPT(c: SculptCtx, parts: readonly Part[]): {
+    under: string;
+    over: string;
+};

package/dist/emblems/lathe.sculpt.js

@@ -0,0 +1,320 @@
+// The parts a body of revolution cannot be: a flat cut-out with thickness (a player, a jersey, a plate of glass) and a ribbon that twists as it rises. A cut-out is a silhouette drawn as original paths
+// and extruded; it stands in a plane that turns with the body, so it squeezes by the cosine of the turn, shows its back past a quarter turn (the front mirrored and a little darker) and shows its thickness
+// as a solid edge, widest when it is edge on. A ribbon is a centre line with a width that turns about it, drawn as a strip of shaded quadrilaterals. A model that wants them sets `sculptor: LATHE_SCULPT`;
+// one that does not never imports this file, so its bundle carries none of the code. Plain SVG.
+import { mix } from "./emblem.core.js";
+import { engravingInk, sideText } from "./emblem.engrave.js";
+const CX = 32;
+const RAD = Math.PI / 180;
+const f = (n) => String(Math.round(n * 10) / 10 + 0);
+const CACHE = new Map();
+/** The polygons of a path of absolute `M L H V C Q Z` commands, curves cut into short straight pieces. */
+function polys(d) {
+    const known = CACHE.get(d);
+    if (known !== undefined)
+        return known;
+    const tok = d.match(/[MLHVCQZ]|-?\d*\.?\d+/g) ?? [];
+    const out = [];
+    let cur = [];
+    let cmd = "";
+    let x = 0;
+    let y = 0;
+    let i = 0;
+    const num = () => Number(tok[i++]);
+    while (i < tok.length) {
+        const t = tok[i];
+        if (/[A-Z]/.test(t)) {
+            cmd = t;
+            i++;
+            if (cmd === "Z") {
+                if (cur.length > 0)
+                    out.push(cur);
+                cur = [];
+            }
+            continue;
+        }
+        if (cmd === "M") {
+            x = num();
+            y = num();
+            if (cur.length > 0)
+                out.push(cur);
+            cur = [[x, y]];
+            cmd = "L";
+        }
+        else if (cmd === "L") {
+            x = num();
+            y = num();
+            cur.push([x, y]);
+        }
+        else if (cmd === "H") {
+            x = num();
+            cur.push([x, y]);
+        }
+        else if (cmd === "V") {
+            y = num();
+            cur.push([x, y]);
+        }
+        else if (cmd === "Q") {
+            const [x1, y1, x2, y2] = [num(), num(), num(), num()];
+            const qn = Math.max(2, Math.min(5, Math.ceil(Math.hypot(x2 - x, y2 - y) / 3.4)));
+            for (let k = 1; k <= qn; k++) {
+                const u = k / qn;
+                cur.push([(1 - u) ** 2 * x + 2 * (1 - u) * u * x1 + u * u * x2, (1 - u) ** 2 * y + 2 * (1 - u) * u * y1 + u * u * y2]);
+            }
+            x = x2;
+            y = y2;
+        }
+        else if (cmd === "C") {
+            const [x1, y1, x2, y2, x3, y3] = [num(), num(), num(), num(), num(), num()];
+            const cn = Math.max(2, Math.min(6, Math.ceil(Math.hypot(x3 - x, y3 - y) / 3.3)));
+            for (let k = 1; k <= cn; k++) {
+                const u = k / cn;
+                const a = (1 - u) ** 3;
+                const b = 3 * (1 - u) ** 2 * u;
+                const c = 3 * (1 - u) * u * u;
+                const e = u ** 3;
+                cur.push([a * x + b * x1 + c * x2 + e * x3, a * y + b * y1 + c * y2 + e * y3]);
+            }
+            x = x3;
+            y = y3;
+        }
+        else {
+            i++;
+        }
+    }
+    if (cur.length > 0)
+        out.push(cur);
+    CACHE.set(d, out);
+    return out;
+}
+function drawCut(c, stands) {
+    const { cut, ax, az, dy } = stands[0];
+    const { yaw, s, tone, line, flat } = c;
+    const th = yaw * RAD;
+    const phi = ((cut.rot ?? 0) + yaw) * RAD;
+    const cosP = Math.cos(phi);
+    const sinP = Math.sin(phi);
+    const A = ax * Math.cos(th) + az * Math.sin(th);
+    const B = az * Math.cos(th) - ax * Math.sin(th);
+    if ((cut.decal === true && cosP <= 0.03) || (line && cut.fine === true))
+        return undefined;
+    const t = cut.t ?? 1;
+    const sign = cosP >= 0 ? 1 : -1;
+    const path = (d, depth) => {
+        let out = "";
+        for (const st of stands) {
+            const sa = st.ax * Math.cos(th) + st.az * Math.sin(th);
+            const sb = st.az * Math.cos(th) - st.ax * Math.sin(th);
+            for (const poly of polys(d))
+                out += `M${poly.map(([px, py]) => `${f(CX + sa + (px - CX) * cosP + depth * sinP)} ${f(py + st.dy + s * (sb - (px - CX) * sinP + depth * cosP))}`).join("L")}Z`;
+        }
+        return out;
+    };
+    const near = (sign * t) / 2;
+    const first = cut.layers[0] ?? ["main", ""];
+    const base = tone(first[0]);
+    let svg = "";
+    const reach = t * Math.hypot(sinP, s * cosP);
+    const glass = first[2] === "gl";
+    if (first[1] === "") {
+        // A text only: nothing is drawn but the engraving.
+    }
+    else if (line) {
+        if (reach > 1.3 && Math.abs(sinP) > 0.3)
+            svg += `<path d="${path(first[1], -near)}" stroke-opacity=".6"/>`;
+    }
+    else if (glass) {
+        // Clear glass: its sides are the hull of the front and the back (a block of glass is convex), with the far edges faint inside it.
+        const hull = convexHull(polys(first[1]).flat().flatMap(([px, py]) => [[CX + A + (px - CX) * cosP + near * sinP, py + dy + s * (B - (px - CX) * sinP + near * cosP)], [CX + A + (px - CX) * cosP - near * sinP, py + dy + s * (B - (px - CX) * sinP - near * cosP)]]));
+        svg += `<path d="M${hull.map(([x, y]) => `${f(x)} ${f(y)}`).join("L")}Z" fill="${mix(base.rgb, 0.2)}" fill-opacity=".2" stroke="${base.edge}" stroke-opacity=".5" stroke-width=".4"/>`;
+        if (reach > 0.6)
+            svg += `<path d="${path(first[1], -near)}" stroke="${base.edge}" stroke-opacity=".4" stroke-width=".4"/>`;
+    }
+    else {
+        // The edge: the silhouette moved a little further along the thickness, back to front, so that together they are a solid band.
+        const steps = reach < 0.3 ? 0 : Math.min(cut.n ?? 8, Math.ceil(reach / 0.8));
+        const side = flat ? mix(base.rgb, -0.3) : mix(base.rgb, -0.42);
+        for (let k = 0; k < steps; k++)
+            svg += `<path d="${path(first[1], -near + (2 * near * k) / steps)}" fill="${side}" stroke="${side}" stroke-width="${f(Math.max(0.6, (reach / steps) * 1.3))}"/>`;
+    }
+    for (const [name, d, mode] of cut.layers) {
+        const q = tone(name);
+        if (line) {
+            if (mode === undefined || mode === "gl" || mode === "rf" || mode === "fl")
+                svg += `<path d="${path(d, near)}"/>`;
+            else if (mode === "ln")
+                svg += `<path d="${path(d, near)}" stroke-width="1.1"/>`;
+            continue;
+        }
+        const p = path(d, near);
+        if (mode === undefined)
+            svg += `<path d="${p}" fill="${q.fill}" stroke="${q.edge}" stroke-width=".3"/>`;
+        else if (mode === "dk")
+            svg += `<path d="${p}" fill="${mix(q.rgb, -0.55)}" fill-opacity=".5" stroke="none"/>`;
+        else if (mode === "lt")
+            svg += `<path d="${p}" fill="${mix(q.rgb, 0.55)}" fill-opacity=".55" stroke="none"/>`;
+        else if (mode === "ln")
+            svg += `<path d="${p}" stroke="${q.edge}" stroke-width=".5"/>`;
+        else if (mode === "gl")
+            svg += `<path d="${p}" fill="${mix(q.rgb, 0.35)}" fill-opacity=".3" stroke="${q.edge}" stroke-width=".45"/>`;
+        else if (mode === "fl")
+            svg += `<path d="${p}" fill="${mix(q.rgb, 0.08)}" stroke="${q.edge}" stroke-width=".3"/>`;
+        else if (mode === "rf")
+            svg += `<path d="${p}" fill="${q.fill}" fill-opacity=".8" stroke="${q.edge}" stroke-width=".3"/>`;
+        else
+            svg += `<path d="${p}" fill="#fff" fill-opacity=".6" stroke="none"/>`;
+    }
+    if (sign < 0 && !line && first[1] !== "")
+        svg += `<path d="${path(first[1], near)}" fill="#000" fill-opacity=".22" stroke="none"/>`;
+    if (cut.plate !== undefined && c.words !== "") {
+        const [x0, x1, y0, y1] = cut.plate;
+        const y = (y0 + y1) / 2;
+        const end = (px) => [CX + A + (px - CX) * cosP + near * sinP, y + dy + s * (B - (px - CX) * sinP + near * cosP)];
+        svg += sideText(c.words, x1 - x0, y1 - y0, engravingInk(line ? "line" : flat ? "color" : "metal", base.rgb), end(x0), end(x1), cosP);
+    }
+    return { z: B, svg };
+}
+/** The convex hull of some points (Andrew's monotone chain), counter-clockwise. */
+function convexHull(points) {
+    const sorted = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    const build = (list) => {
+        const out = [];
+        for (const p of list) {
+            while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], p) <= 0)
+                out.pop();
+            out.push(p);
+        }
+        out.pop();
+        return out;
+    };
+    return [...build(sorted), ...build([...sorted].reverse())];
+}
+const cr = (a, b, c, d, t) => 0.5 * (2 * b + (-a + c) * t + (2 * a - 5 * b + 4 * c - d) * t * t + (-a + 3 * b - 3 * c + d) * t * t * t);
+function drawRibbon(c, r) {
+    const { yaw, s, tone, line } = c;
+    const th = yaw * RAD;
+    const base = tone(r.tone);
+    const n = r.steps ?? 14;
+    const k = r.pts.length;
+    const samples = [];
+    for (let i = 0; i <= n; i++) {
+        const u = (i / n) * (k - 1);
+        const j = Math.min(k - 2, Math.floor(u));
+        const t = u - j;
+        const g = (q, m) => r.pts[Math.max(0, Math.min(k - 1, q))][m];
+        const mixed = (m) => cr(g(j - 1, m), g(j, m), g(j + 1, m), g(j + 2, m), t);
+        samples.push({ x: mixed(0), y: mixed(1), z: mixed(2), ph: g(j, 3) + (g(j + 1, 3) - g(j, 3)) * t, w: g(j, 4) + (g(j + 1, 4) - g(j, 4)) * t });
+    }
+    const turned = samples.map((p) => {
+        const phi = (p.ph + yaw) * RAD;
+        const px = p.x * Math.cos(th) + p.z * Math.sin(th);
+        const pz = p.z * Math.cos(th) - p.x * Math.sin(th);
+        return { px, py: p.y, pz, wx: p.w * Math.cos(phi), wz: -p.w * Math.sin(phi) };
+    });
+    const pt = (px, py, pz) => `${f(CX + px)} ${f(py + s * pz)}`;
+    if (line) {
+        let left = "";
+        let right = "";
+        turned.forEach((p, i) => {
+            left += `${i === 0 ? "M" : "L"}${pt(p.px - p.wx, p.py, p.pz - p.wz)}`;
+            right += `${i === 0 ? "M" : "L"}${pt(p.px + p.wx, p.py, p.pz + p.wz)}`;
+        });
+        const a = turned[0];
+        const b = turned[n];
+        const ends = `M${pt(a.px - a.wx, a.py, a.pz - a.wz)}L${pt(a.px + a.wx, a.py, a.pz + a.wz)}M${pt(b.px - b.wx, b.py, b.pz - b.wz)}L${pt(b.px + b.wx, b.py, b.pz + b.wz)}`;
+        return { z: turned.reduce((m, p) => m + p.pz, 0) / turned.length, svg: `<path d="${left}${right}${ends}"/>` };
+    }
+    const L = [-0.5, -0.6, 0.65];
+    const len = Math.hypot(L[0], L[1], L[2]);
+    const quads = [];
+    for (let i = 0; i < n; i++) {
+        const p = turned[i];
+        const q = turned[i + 1];
+        const tx = q.px - p.px;
+        const ty = q.py - p.py;
+        const tz = q.pz - p.pz;
+        const wx = p.wx + q.wx;
+        const wz = p.wz + q.wz;
+        // The normal of the strip: the tangent crossed with the width (which lies flat).
+        const nx = ty * wz;
+        const ny = tz * wx - tx * wz;
+        const nz = -ty * wx;
+        const nl = Math.hypot(nx, ny, nz) || 1;
+        const lambert = Math.abs((nx * L[0] + ny * L[1] + nz * L[2]) / (nl * len));
+        const bucket = Math.round(Math.max(-0.45, Math.min(0.5, (lambert - 0.45) * 1.1)) * 10) / 10;
+        const colour = mix(base.rgb, bucket);
+        quads.push({ z: (p.pz + q.pz) / 2, d: `M${pt(p.px - p.wx, p.py, p.pz - p.wz)}L${pt(p.px + p.wx, p.py, p.pz + p.wz)}L${pt(q.px + q.wx, q.py, q.pz + q.wz)}L${pt(q.px - q.wx, q.py, q.pz - q.wz)}Z`, colour });
+    }
+    quads.sort((a, b) => a.z - b.z);
+    let svg = "";
+    let run = "";
+    let colour = "";
+    for (const q of quads) {
+        if (q.colour !== colour && run !== "") {
+            svg += `<path d="${run}" fill="${colour}" stroke="${colour}" stroke-width=".3"/>`;
+            run = "";
+        }
+        colour = q.colour;
+        run += q.d;
+    }
+    if (run !== "")
+        svg += `<path d="${run}" fill="${colour}" stroke="${colour}" stroke-width=".3"/>`;
+    return { z: turned.reduce((m, p) => m + p.pz, 0) / turned.length, svg };
+}
+function drawBlock(c, b) {
+    const { yaw, s, tone, line } = c;
+    const th = yaw * RAD;
+    const cos = Math.cos(th);
+    const sin = Math.sin(th);
+    const t = tone(b.tone);
+    const up = tone(b.top ?? b.tone);
+    const [x0, x1] = b.x;
+    const [y0, y1] = b.y;
+    const [z0, z1] = b.z;
+    const at = (x, y, z) => `${f(CX + x * cos + z * sin)} ${f(y + s * (z * cos - x * sin))}`;
+    let svg = "";
+    // The four sides, each by the way it faces: the ones that look toward the eye, lit from the left.
+    const faces = [
+        [0, 1, [x0, z1], [x1, z1]],
+        [1, 0, [x1, z1], [x1, z0]],
+        [0, -1, [x1, z0], [x0, z0]],
+        [-1, 0, [x0, z0], [x0, z1]],
+    ];
+    for (const [nx, nz, a, e] of faces) {
+        const facing = nz * cos - nx * sin;
+        if (facing <= 0.01)
+            continue;
+        const lit = -(nx * cos + nz * sin);
+        svg += `<path d="M${at(a[0], y0, a[1])}L${at(e[0], y0, e[1])}L${at(e[0], y1, e[1])}L${at(a[0], y1, a[1])}Z" fill="${line ? "none" : mix(t.rgb, 0.05 + 0.27 * lit)}" stroke="${line ? "currentColor" : t.edge}"/>`;
+    }
+    if (s > 0.02)
+        svg += `<path d="M${at(x0, y0, z0)}L${at(x1, y0, z0)}L${at(x1, y0, z1)}L${at(x0, y0, z1)}Z" fill="${line ? "none" : mix(up.rgb, 0.3)}" stroke="${line ? "currentColor" : b.rim === undefined ? up.edge : mix(tone(b.rim).rgb, 0.2)}"${b.rim === undefined || line ? "" : ' stroke-width=".8"'}/>`;
+    return svg;
+}
+/** Draws the parts of a model: the ones that are `under` the bodies, and the rest, each group from far to near. */
+export function LATHE_SCULPT(c, parts) {
+    const under = [];
+    const over = [];
+    const boxes = [];
+    for (const part of parts) {
+        if (part.kind === "box") {
+            boxes.push(drawBlock(c, part));
+            continue;
+        }
+        if (part.kind === "ribbon") {
+            (part.under === true ? under : over).push(drawRibbon(c, part));
+            continue;
+        }
+        const [x, z] = part.at ?? [0, 0];
+        const stands = [{ cut: part, ax: x, az: z, dy: part.y ?? 0 }, ...(part.copies ?? []).map(([cx, cz, cy]) => ({ cut: part, ax: x + cx, az: z + cz, dy: (part.y ?? 0) + (cy ?? 0) }))];
+        // The copies of a decal are one path (they lie on one face and cannot hide each other); those of a cut-out are drawn one by one, far to near.
+        for (const group of part.decal === true ? [stands] : stands.map((st) => [st])) {
+            const made = drawCut(c, group);
+            if (made !== undefined)
+                (part.under === true ? under : over).push(made);
+        }
+    }
+    const join = (list) => list.sort((a, b) => a.z - b.z).map((p) => p.svg).join("");
+    return { under: join(under), over: boxes.join("") + join(over) };
+}

package/dist/emblems/nba.parts.d.ts

@@ -0,0 +1,27 @@
+import type { Pt } from "./emblem.lathe.ts";
+/** The tones the NBA's postseason trophies share: the ball's silver (and the frosted silver of the earlier conference balls), the black of the rings and feet, and the pale gold of the etched net. */
+export declare const NBA_TONES: {
+    readonly silver: "#d3d8df";
+    readonly frost: "#e6e9ec";
+    readonly dark: "#16171b";
+    readonly etch: "#f0cf66";
+};
+/** The trumpet from its flange down to its foot, in the 64 unit box: the flange's rim is at 24.5 and the foot ends at 61.4. */
+export declare const TRUMPET: readonly Pt[];
+/** The ball's ring of the Western trophy: four bands that cross under the ball and rise round its lower half (the real ones are two rings). */
+export declare const WEST_BAND: readonly [readonly [0, 38.2], readonly [4.2, 37.6], readonly [8.4, 36.2], readonly [12, 33.6], readonly [14.6, 30.4], readonly [15.5, 28.8]];
+/** The Western base from the gold dome down: a black ring, a thin band, a flared black drum, a tall flared skirt and a black foot. In the earlier pair the thin band is black and the skirt polished silver. */
+export declare const westBase: (earlier: boolean) => readonly Pt[];
+/** The Eastern base from its plate down: a plate, three black tiers, a tall drum and a black foot. In the earlier pair the plate and the drum are polished silver. */
+export declare const eastBase: (earlier: boolean) => readonly Pt[];
+/** One of the three posts of the Eastern trophy and its stem and dish, as solids (the posts stand at 0, 120 and 240 degrees). */
+export declare const eastTop: () => ({
+    at: readonly [12.2, number];
+    p: readonly [readonly [33.4, 0.9, 1], readonly [40.6, 0.9, 1]];
+} | {
+    p: readonly [readonly [37.6, 1.2, 1], readonly [40.7, 1.4, 1]];
+    open?: undefined;
+} | {
+    open: boolean;
+    p: readonly [readonly [33.2, 10, 1], readonly [34, 9.7], readonly [36, 7.2], readonly [37.6, 3.2], readonly [38.2, 1.3, 1]];
+})[];

package/dist/emblems/nba.parts.js

@@ -0,0 +1,34 @@
+/** The tones the NBA's postseason trophies share: the ball's silver (and the frosted silver of the earlier conference balls), the black of the rings and feet, and the pale gold of the etched net. */
+export const NBA_TONES = { silver: "#d3d8df", frost: "#e6e9ec", dark: "#16171b", etch: "#f0cf66" };
+/** The trumpet from its flange down to its foot, in the 64 unit box: the flange's rim is at 24.5 and the foot ends at 61.4. */
+export const TRUMPET = [
+    [23, 10.3, 1], [23.2, 11.1], [24.3, 11.25, 1], [24.6, 11.2], [24.6, 9.95],
+    [26, 9.7], [28, 9.15], [30, 8.65], [32, 8.15], [34, 7.65], [36, 7.1], [38, 6.55], [40, 6.05], [42, 5.6], [44, 5.15], [46, 4.8], [48, 4.5], [49.4, 4.4], [50.6, 4.55], [51.8, 5.15], [52.8, 6.3], [53.7, 7.6], [54.4, 8.4], [54.8, 8.6, 1],
+    [54.8, 8.9, 1, "dark"], [56.4, 8.9, 1, "dark"], [56.4, 9.35, 1], [59.8, 9.4, 1], [59.8, 9.5, 1, "dark"], [61.4, 9.5, 1, "dark"],
+];
+/** The ball's ring of the Western trophy: four bands that cross under the ball and rise round its lower half (the real ones are two rings). */
+export const WEST_BAND = [[0, 38.2], [4.2, 37.6], [8.4, 36.2], [12, 33.6], [14.6, 30.4], [15.5, 28.8]];
+/** The Western base from the gold dome down: a black ring, a thin band, a flared black drum, a tall flared skirt and a black foot. In the earlier pair the thin band is black and the skirt polished silver. */
+export const westBase = (earlier) => [
+    [38, 3, 1], [38.5, 8.6], [39.6, 11], [40, 11.4, 1],
+    [40, 13.4, 1, "dark"], [42.2, 13.8, 1, "dark"],
+    [42.2, 14.3, 1, earlier ? "dark" : "main"], [44.8, 14.6, 1, earlier ? "dark" : "main"],
+    [44.8, 15.3, 1, "dark"], [46, 16], [48, 17.6], [50.4, 20, 1, "dark"],
+    [50.4, 20.2, 1, earlier ? "silver" : "main"], [53, 21], [56, 22], [60.6, 23, 1, earlier ? "silver" : "main"],
+    [60.6, 23.3, 1, "dark"], [62.4, 23.4, 1, "dark"],
+];
+/** The Eastern base from its plate down: a plate, three black tiers, a tall drum and a black foot. In the earlier pair the plate and the drum are polished silver. */
+export const eastBase = (earlier) => {
+    const light = earlier ? "silver" : "main";
+    return [
+        [40.6, 10.2, 1, light], [42.2, 10.4, 1, light],
+        [42.2, 12.2, 1, "dark"], [43.8, 12.2, 1, "dark"], [43.8, 14, 1, "dark"], [45.4, 14, 1, "dark"], [45.4, 15.8, 1, "dark"], [47, 15.8, 1, "dark"],
+        [47, 19.2, 1, light], [58.8, 19.5, 1, light],
+        [58.8, 20, 1, "dark"], [60.4, 20.6, 1, "dark"], [62.5, 20.9, 1, "dark"],
+    ];
+};
+/** One of the three posts of the Eastern trophy and its stem and dish, as solids (the posts stand at 0, 120 and 240 degrees). */
+export const eastTop = () => {
+    const post = (deg) => ({ at: [12.2, deg], p: [[33.4, 0.9, 1], [40.6, 0.9, 1]] });
+    return [{ p: [[37.6, 1.2, 1], [40.7, 1.4, 1]] }, { open: true, p: [[33.2, 10, 1], [34, 9.7], [36, 7.2], [37.6, 3.2], [38.2, 1.3, 1]] }, post(0), post(120), post(240)];
+};

package/dist/emblems/trophy/bill-russell-trophy.d.ts

@@ -1,2 +1,2 @@
-/** The Bill Russell NBA Finals Most Valuable Player Trophy: a gold basketball on a flared net goblet over a stepped round foot. */
+/** The Bill Russell NBA Finals Most Valuable Player Trophy: a gold basketball with silver seams in a net-etched gold trumpet over a stepped round foot. */
 export declare const TROPHY_BILL_RUSSELL_TROPHY: import("../emblem.core.ts").Emblem<import("../emblem.lathe.ts").LatheModel>;