@johnmorrisdotca/uchusen-rockets 0.0.0-stage → 0.2.0

package/dist/data/starship.js

@@ -0,0 +1,183 @@
+// Starship's variants as the sources give them. No figure here is measured from a picture or worked out to fill a gap: a blank stays blank. Column layout matters in the Wikipedia table these come from:
+// its "81 m" is Block 4's booster, not Block 3's, which is how one secondary site came to print it for Block 3.
+import { blank } from "./types.js";
+const WP = "wikipedia-starship";
+const SH = "wikipedia-super-heavy";
+const LAUNCHES = "wikipedia-launches";
+const m = (value, source, extra = {}) => ({ value, source, ...extra });
+const said = (value, source, extra = {}) => ({ value, source, ...extra });
+const num = (value, source, extra = {}) => ({ value, source, ...extra });
+const GUNTER_NOTE = "Gunter's Space Page gives one set of figures for every version, 118 m with stages of 68 m and 50 m. It does not change them by version, so the block table is used.";
+export const STARSHIP_VARIANTS = [
+    {
+        id: "v1-flight1",
+        rocket: "starship",
+        name: "Block 1, first flight (Ship 24, Booster 7)",
+        status: "flown",
+        firstFlight: said("2023-04-20", LAUNCHES, { brief: "Starship's first flight", note: "Flight test 1, Booster 7 and Ship 24. Gunter's Space Page calls this version v1.1 and the ringed one v1.2." }),
+        slots: ["booster", "ship"],
+        note: "The one vehicle of flight test 1, with no vented ring: that came with the next flight. Its stated height and its parts do not add up, by 1.7 m: the parts are drawn to the parts' figures, so it is drawn 119.3 m tall.",
+        facts: {
+            height: m(121, "wikipedia-flight-1", { date: "2023-04-20", brief: "as stated; its parts add to 119.3 m", note: "The flight's article says 121 m. Its parts' own figures add to 119.3 m, and the drawing follows the parts." }),
+            diameter: m(9, WP),
+            parts: {
+                booster: m(69, SH, { note: "Wikipedia's infobox: 69 m without the vented interstage. It gives no reference for that figure." }),
+                ship: m(50.3, WP),
+            },
+            engines: {
+                booster: said("33 Raptor 2", SH),
+                ship: said("3 sea-level and 3 vacuum Raptor 2", WP),
+            },
+            more: {
+                gridFins: num(4, "satnews-v3"),
+                forwardFlaps: said("Both at 180 degrees", "wikipedia-ship"),
+            },
+        },
+    },
+    {
+        id: "v1",
+        rocket: "starship",
+        name: "Block 1 with the vented ring (V1)",
+        status: "flown",
+        firstFlight: said("2023-11-18", LAUNCHES, { brief: "first with the ring", note: "Flight test 2, Booster 9 and Ship 25. Block 1 itself first flew on 2023-04-20, without the ring: that is the variant before this one." }),
+        slots: ["booster", "ship"],
+        facts: {
+            height: m(121.3, WP, { date: "2023", others: [{ value: 118, source: "gunter", note: GUNTER_NOTE }] }),
+            diameter: m(9, WP),
+            parts: {
+                booster: m(71, SH, { note: "With the vented interstage. 69 m without it.", others: [{ value: 68, source: "gunter", note: GUNTER_NOTE }] }),
+                ship: m(50.3, WP, { others: [{ value: 50, source: "gunter", note: GUNTER_NOTE }] }),
+            },
+            engines: {
+                booster: said("33 Raptor 2", SH),
+                ship: said("3 sea-level and 3 vacuum Raptor 2", WP),
+            },
+            more: {
+                gridFins: num(4, "satnews-v3", { note: "V3 went from four to three." }),
+                forwardFlaps: said("Both at 180 degrees", "wikipedia-ship"),
+                boosterPropellantT: num(3250, WP, { others: [{ value: 3400, source: SH, note: "The Super Heavy article's infobox gives 3,400 t for Blocks 1 and 2; the block table is used." }] }),
+                shipPropellantT: num(1200, WP),
+                boosterThrustTf: num(7500, WP),
+                shipThrustTf: num(1250, WP),
+                payloadT: num(15, WP),
+            },
+        },
+    },
+    {
+        id: "v2",
+        rocket: "starship",
+        name: "Block 2 (V2)",
+        status: "flown",
+        firstFlight: said("2025-01-16", LAUNCHES, { note: "Flight test 7, Booster 14 and Ship 33." }),
+        slots: ["booster", "ship"],
+        facts: {
+            height: m(123.1, WP, { date: "2025", others: [{ value: 123.3, source: WP, note: "The same article's table says 123.3 m; its infobox says 123.1 m, which is also 71 m plus 52.1 m." }] }),
+            diameter: m(9, WP),
+            parts: {
+                booster: m(71, SH),
+                ship: m(52.1, WP),
+            },
+            engines: {
+                booster: said("33 Raptor 2", SH),
+                ship: said("3 sea-level and 3 vacuum Raptor 2", WP),
+            },
+            more: {
+                gridFins: num(4, "satnews-v3"),
+                forwardFlaps: said("Thinner, moved leeward, angled to about 140 degrees", "wikipedia-ship"),
+                boosterPropellantT: num(3250, WP),
+                shipPropellantT: num(1500, WP),
+                boosterThrustTf: num(7500, WP),
+                shipThrustTf: num(1400, WP),
+                payloadT: num(35, WP),
+            },
+        },
+    },
+    {
+        id: "v3",
+        rocket: "starship",
+        name: "Block 3 (V3)",
+        status: "flown",
+        firstFlight: said("2026-05-22", LAUNCHES, { note: "Flight test 12, Booster 19 and Ship 39." }),
+        slots: ["booster", "ship"],
+        facts: {
+            height: m(124.4, WP, {
+                date: "2026",
+                others: [
+                    { value: 124, source: "spacex-starship", note: "SpaceX's vehicle page, as a search engine quoted it: 124 m (407 ft), rounded. The page itself would not load." },
+                    { value: 124, source: "satnews-v3", note: "About 124 m, roughly 1.5 m taller than V2, from SpaceX's briefing." },
+                ],
+            }),
+            diameter: m(9, SH),
+            parts: {
+                booster: m(72.3, SH, {
+                    date: "2025-05-30",
+                    note: "Wikipedia cites NASASpaceflight, 2025-05-30, which could not be read directly.",
+                    others: [
+                        { value: 72, source: "spacex-starship", note: "SpaceX's page as quoted by a search engine: 72 m (236 ft), rounded." },
+                        { value: 81, source: WP, note: "81 m is Block 4's cell in Wikipedia's table, where colspans shift the columns. A site that printed it for Block 3 misread it: 81 m plus 52.1 m does not make 124.4 m." },
+                    ],
+                }),
+                ship: m(52.1, WP, { others: [{ value: 52, source: "spacex-starship", note: "SpaceX's page as quoted by a search engine: 52 m (171 ft), rounded." }] }),
+            },
+            engines: {
+                booster: said("33 Raptor 3", SH),
+                ship: said("3 sea-level and 3 vacuum Raptor 3", WP),
+            },
+            more: {
+                gridFins: num(3, SH, { note: "In a 90/90/180 degree arrangement. About 50% larger each, by SatNews." }),
+                hotStage: said("Vented interstage and forward dome integrated into the methane tank", SH),
+                docking: said("Docking ports for refuelling", WP),
+                boosterPropellantT: num(3650, WP),
+                shipPropellantT: num(1600, WP),
+                boosterThrustTf: num(8240, WP),
+                shipThrustTf: num(1600, WP),
+                payloadT: num(100, WP),
+            },
+        },
+    },
+    {
+        id: "v4",
+        rocket: "starship",
+        name: "Block 4 (V4), announced",
+        status: "announced",
+        firstFlight: blank("Announced, not built, so it has not flown.", "Not flown"),
+        slots: ["booster", "ship"],
+        note: "Announced, not built: every figure here is a plan, not a measurement. Its height is marked an estimate at the source, and may change. Its drawing is Block 3's details on Block 4's sizes, which is thin evidence: no source shows its parts.",
+        facts: {
+            height: m(142, WP, { brief: "announced, an estimate", note: "Marked an estimate at the source." }),
+            diameter: m(9, WP, { brief: "announced" }),
+            parts: {
+                booster: m(81, WP, { brief: "announced", note: "From the block table, which adds it up to the 142 m it marks an estimate elsewhere. SpaceX's planned high bay is also quoted as clearing vehicles up to 81 m." }),
+                ship: m(61, WP, { brief: "announced", note: "From the block table, which adds it up to the 142 m it marks an estimate elsewhere." }),
+            },
+            engines: {
+                booster: said("33 Raptor 3", "gunter", { brief: "announced" }),
+                ship: said("3 sea-level and 6 vacuum", WP, { brief: "announced", note: "Three more vacuum engines, from a public statement by Elon Musk." }),
+            },
+            more: {
+                gridFins: blank("No source gives it."),
+                boosterPropellantT: num(4050, WP),
+                shipPropellantT: num(2300, WP),
+                boosterThrustTf: num(10000, WP),
+                shipThrustTf: num(2700, WP),
+                payloadT: num(200, WP),
+            },
+        },
+    },
+    {
+        id: "2019",
+        rocket: "starship",
+        name: "2019 design (artist's model)",
+        status: "artist-model",
+        firstFlight: blank("It never flew: this is a design, drawn when it was shown.", "Never flew"),
+        slots: ["ship"],
+        note: "An artist's model of the upper stage shown in September 2019, published on 2019-09-30, not a flown block. It has no booster. The height is the Mk1 prototype's, which was built to that design.",
+        facts: {
+            height: m(50, "spacecom-mk1", { date: "2019-09", note: "Musk's figure for the Mk1 prototype, as a search engine quoted the article." }),
+            diameter: blank("No source read here gives the 2019 design's diameter."),
+            parts: { ship: m(50, "spacecom-mk1", { date: "2019-09" }) },
+            engines: { ship: said("3 sea-level and 3 vacuum", WP, { note: "The design had settled on six Raptors by 2019." }) },
+            more: {},
+        },
+    },
+];

package/dist/data/types.d.ts

@@ -0,0 +1,48 @@
+import type { SourceId } from "./sources.ts";
+export interface Disagreement<T> {
+    value: T;
+    source: SourceId;
+    note: string;
+}
+export interface Figure<T = number> {
+    value: T | null;
+    source: SourceId | null;
+    /** The date the figure is from, where it has one. */
+    date?: string;
+    note?: string;
+    /** A few words that must stay beside the value wherever it is shown, so it cannot be misread: "announced", "in this form". For a blank, what to say in place of a value. */
+    brief?: string;
+    others?: readonly Disagreement<T>[];
+}
+export declare const blank: <T = number>(note?: string, brief?: string) => Figure<T>;
+/** A figure as words for a table: its value and whatever must stay beside it; a blank says why, or that no source gives it. */
+export declare function figureWords(figure: Figure<number | string> | undefined, unit?: string): string;
+export type VariantStatus = "flown" | "announced" | "artist-model" | "test-vehicle";
+export interface VariantFacts {
+    /** Overall height with every part in place, metres. */
+    height: Figure;
+    diameter: Figure;
+    /** Each part's height by its slot, metres. */
+    parts: Readonly<Record<string, Figure>>;
+    /** Engines by slot. */
+    engines: Readonly<Record<string, Figure<string>>>;
+    /** Other facts, each with its own source. */
+    more: Readonly<Record<string, Figure<number | string>>>;
+}
+export interface Variant {
+    /** "v1", "v2" and so on; a label for what is not a numbered version. */
+    id: string;
+    rocket: string;
+    /** What it is called, in a line: "Block 3 (V3)". */
+    name: string;
+    status: VariantStatus;
+    /** When this variant, in this form, first flew. Its `brief` says so when the form is not the block's first. */
+    firstFlight: Figure<string>;
+    /** The parts this variant has, in stacking order from the bottom. */
+    slots: readonly string[];
+    facts: VariantFacts;
+    /** A slot's part when it is not this variant's own: a part shared with another rocket. */
+    partIds?: Readonly<Record<string, string>>;
+    /** What a reader should be told about it. */
+    note?: string;
+}

package/dist/data/types.js

@@ -0,0 +1,8 @@
+export const blank = (note, brief) => ({ value: null, source: null, ...(note ? { note } : {}), ...(brief ? { brief } : {}) });
+/** A figure as words for a table: its value and whatever must stay beside it; a blank says why, or that no source gives it. */
+export function figureWords(figure, unit = "") {
+    if (!figure || figure.value === null)
+        return figure?.brief ?? "No source";
+    const value = typeof figure.value === "number" ? `${figure.value}${unit}` : figure.value;
+    return figure.brief ? `${value}, ${figure.brief}` : value;
+}

package/dist/draw/svg.d.ts

@@ -0,0 +1,26 @@
+import { type Angle, type Vec3 } from "../framing.ts";
+import { type LookName } from "../looks.ts";
+import type { Bounds, Piece } from "../model/pieces.ts";
+type Point = [number, number];
+/** A camera over a picture: perspective by default, or orthographic at a fixed scale for drawings side by side. */
+export interface Camera {
+    project: (p: Vec3) => Point;
+    /** Depth along the view, far is larger. */
+    depth: (p: Vec3) => number;
+    /** The unit vector from a point towards the camera. */
+    toward: (p: Vec3) => Vec3;
+    above: boolean;
+}
+export declare function perspective(bounds: Bounds, angle: Angle, width?: number, height?: number): Camera;
+/** Orthographic, `scale` pixels a metre, the origin at (x0, y0) on the picture. */
+export declare function orthographic(angle: Angle, scale: number, x0: number, y0: number): Camera;
+export interface DrawOptions {
+    look: LookName;
+    /** Weights scale with the drawing's size: 1 at the standard picture. */
+    weight?: number;
+}
+/** One part's picture at `at`, as SVG text in painter's order. */
+export declare function drawPart(pieces: readonly Piece[], at: Vec3, cam: Camera, look: LookName, weight?: number): string;
+/** The picture's gradients and, on the tiled side, a mosaic of hexagons, for a look. */
+export declare function defsOf(look: LookName): string;
+export {};

package/dist/draw/svg.js

@@ -0,0 +1,262 @@
+// The drawings: dark gradient faces, a light outline, a soft halo. Each is made from the same pieces as the mesh, seen from the very camera the 3D view uses, so the drawing turns into the 3D view without a
+// jump. Painter's order: the body first, what hangs under it and what stands behind it by its own depth. Pure: no three.js and no DOM.
+import { axesOf, directionOf, frameFor, PICTURE_H, PICTURE_W, FOV_DEG, deg } from "../framing.js";
+import { LOOKS } from "../looks.js";
+import { MATERIALS } from "../model/materials.js";
+import { pointOf, radiusAt } from "../model/pieces.js";
+const n = (v) => (Math.round(v * 10) / 10).toString();
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+function hull(points) {
+    const p = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    if (p.length < 3)
+        return p;
+    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
+    const half = (list) => {
+        const out = [];
+        for (const q of list) {
+            while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], q) <= 0)
+                out.pop();
+            out.push(q);
+        }
+        out.pop();
+        return out;
+    };
+    return [...half(p), ...half([...p].reverse())];
+}
+const pathOf = (pts, close) => `M${pts.map(([x, y]) => `${n(x)} ${n(y)}`).join("L")}${close ? "Z" : ""}`;
+export function perspective(bounds, angle, width = PICTURE_W, height = PICTURE_H) {
+    const { target, position } = frameFor(bounds.min, bounds.max, angle, width / height);
+    const { right, up, forward } = axesOf(directionOf(angle));
+    const f = 1 / Math.tan(deg(FOV_DEG) / 2);
+    return {
+        project: (p) => {
+            const q = sub(p, position);
+            const z = dot(q, forward);
+            return [width / 2 + (dot(q, right) * f * (height / 2)) / z, height / 2 - (dot(q, up) * f * (height / 2)) / z];
+        },
+        depth: (p) => dot(sub(p, position), forward),
+        toward: (p) => {
+            const q = sub(position, p);
+            const l = Math.hypot(...q) || 1;
+            return [q[0] / l, q[1] / l, q[2] / l];
+        },
+        above: position[1] > target[1] - 1e9 && angle.el >= 0,
+    };
+}
+/** Orthographic, `scale` pixels a metre, the origin at (x0, y0) on the picture. */
+export function orthographic(angle, scale, x0, y0) {
+    const direction = directionOf(angle);
+    const { right, up, forward } = axesOf(direction);
+    return {
+        project: (p) => [x0 + dot(p, right) * scale, y0 - dot(p, up) * scale],
+        depth: (p) => dot(p, forward),
+        toward: () => direction,
+        above: angle.el >= 0,
+    };
+}
+const fillId = (material) => MATERIALS[material].fill;
+function latheItem(piece, cam, at, style, list) {
+    const [cx, cz] = piece.at ?? [0, 0];
+    const profile = piece.profile;
+    const steps = piece.segs > 24 ? 36 : 14;
+    const here = (r, y, a) => [at[0] + cx + r * Math.sin(a), at[1] + y, at[2] + cz + r * Math.cos(a)];
+    const middleY = (profile[0][1] + profile[profile.length - 1][1]) / 2;
+    const middle = [at[0] + cx, at[1] + middleY, at[2] + cz];
+    const axisHere = [at[0], at[1] + middleY, at[2]];
+    const parts = [];
+    const fill = `url(#${fillId(piece.material)})`;
+    // which way a station's surface faces, for what shows
+    const tilt = profile.map(([r, y], i) => {
+        const [r1, y1] = profile[Math.min(i + 1, profile.length - 1)];
+        const [r0, y0] = profile[Math.max(i - 1, 0)];
+        const dr = r1 - r0;
+        const dy = y1 - y0;
+        const l = Math.hypot(dr, dy) || 1;
+        return { r, y, nr: dy / l, ny: -dr / l };
+    });
+    const faces = (i, a) => {
+        const p = here(i.r, i.y, a);
+        const t = cam.toward(p);
+        return i.nr * Math.sin(a) * t[0] + i.ny * t[1] + i.nr * Math.cos(a) * t[2] > 0;
+    };
+    if (piece.arc) {
+        // an arc of a hull: from station to station, only the part that faces the camera
+        const left = [];
+        const right = [];
+        const leftEdge = [];
+        const rightEdge = [];
+        for (const station of tilt) {
+            const [from, to] = piece.arc(station.y);
+            let lo = null;
+            let hi = null;
+            const count = 48;
+            for (let k = 0; k <= count; k++) {
+                const a = from + ((to - from) * k) / count;
+                if (faces(station, a)) {
+                    if (lo === null)
+                        lo = a;
+                    hi = a;
+                }
+            }
+            if (lo === null || hi === null) {
+                leftEdge.push(null);
+                rightEdge.push(null);
+                continue;
+            }
+            left.push(cam.project(here(station.r, station.y, lo)));
+            right.push(cam.project(here(station.r, station.y, hi)));
+            // an edge shows only where it is the arc's own edge, not where the hull turns away
+            leftEdge.push(lo > from + 1e-6 ? null : cam.project(here(station.r, station.y, lo)));
+            rightEdge.push(hi < to - 1e-6 ? null : cam.project(here(station.r, station.y, hi)));
+        }
+        if (left.length > 1) {
+            const shape = pathOf([...left, ...right.reverse()], true);
+            parts.push(`<path d="${shape}" fill="${fill}"/>`);
+            if (piece.material === "tile")
+                parts.push(`<path d="${shape}" fill="url(#hex)"/>`);
+            for (const edge of [leftEdge, rightEdge]) {
+                let run = [];
+                const flush = () => {
+                    if (run.length > 1)
+                        parts.push(`<path d="${pathOf(run, false)}" fill="none" stroke="${style.line}" stroke-width="${n(style.feature)}"/>`);
+                    run = [];
+                };
+                for (const p of edge) {
+                    if (p)
+                        run.push(p);
+                    else
+                        flush();
+                }
+                flush();
+            }
+        }
+    }
+    else if (piece.outline !== false) {
+        const pts = [];
+        for (const [r, y] of profile)
+            for (let k = 0; k < steps; k++)
+                pts.push(cam.project(here(r, y, (k / steps) * 2 * Math.PI)));
+        const shape = hull(pts);
+        parts.push(`<path d="${pathOf(shape, true)}" fill="${fill}"${piece.outline ? ` stroke="${style.line}" stroke-width="${n(style.outline * (piece.under ? 0.55 : 1))}"` : ""}/>`);
+    }
+    // rings: the front of each
+    const ringsOf = (ys, width, opacity) => {
+        if (!ys?.length)
+            return;
+        let d = "";
+        for (const y of ys) {
+            const i = profile.findIndex(([, yy], k) => k + 1 < profile.length && y >= Math.min(yy, profile[k + 1][1]) && y <= Math.max(yy, profile[k + 1][1]));
+            if (i < 0)
+                continue;
+            const r = radiusAt(profile, y);
+            const [r1, y1] = profile[i + 1];
+            const [r0, y0] = profile[i];
+            const l = Math.hypot(r1 - r0, y1 - y0) || 1;
+            const station = { r, y, nr: (y1 - y0) / l, ny: -(r1 - r0) / l };
+            const [from, to] = piece.arc ? piece.arc(y) : [0, 2 * Math.PI];
+            const count = 20;
+            let run = [];
+            const flush = () => {
+                if (run.length > 1)
+                    d += pathOf(run, false);
+                run = [];
+            };
+            for (let k = 0; k <= count; k++) {
+                const a = from + ((to - from) * k) / count;
+                if (faces(station, a))
+                    run.push(cam.project(here(r, y, a)));
+                else
+                    flush();
+            }
+            flush();
+        }
+        if (d)
+            parts.push(`<path d="${d}" fill="none" stroke="${style.line}" stroke-width="${n(width)}"${opacity ?? ""}/>`);
+    };
+    ringsOf(piece.welds, style.weld, ' opacity=".6"');
+    ringsOf(piece.rings, style.feature);
+    if (!parts.length)
+        return;
+    // the body's own pieces: far end first
+    const key = piece.body ? (cam.depth(middle) - cam.depth([at[0], at[1], at[2]])) * 1e-3 : cam.depth(middle) - cam.depth(axisHere);
+    list.push({ key: piece.under ? (cam.above ? 1e6 + key : -1e6 + key - middleY * 0.01) : key, svg: parts.join("") });
+}
+function plateItem(piece, cam, at, style, list) {
+    const place = (a, b, c) => {
+        const p = pointOf(piece.frame, a, b, c);
+        return [p[0] + at[0], p[1] + at[1], p[2] + at[2]];
+    };
+    const half = piece.thickness / 2;
+    const pts = [];
+    for (const [a, b] of piece.outline)
+        pts.push(cam.project(place(a, b, half)), cam.project(place(a, b, -half)));
+    const shape = hull(pts);
+    const centre = piece.outline.reduce((s, p) => [s[0] + p[0] / piece.outline.length, s[1] + p[1] / piece.outline.length], [0, 0]);
+    const c = place(centre[0], centre[1], 0);
+    const seen = cam.toward(c);
+    const facing = dot(piece.frame.w, seen);
+    const faceMat = facing > 0 && piece.top ? piece.top : piece.material;
+    const parts = [`<path d="${pathOf(shape, true)}" fill="url(#${fillId(faceMat)})" stroke="${style.line}" stroke-width="${n(piece.plain ? style.weld : style.feature * 1.1)}"/>`];
+    if (piece.ribs?.length && Math.abs(facing) > 0.35) {
+        const side = facing > 0 ? half : -half;
+        let d = "";
+        for (const [p, q] of piece.ribs)
+            d += pathOf([cam.project(place(p[0], p[1], side)), cam.project(place(q[0], q[1], side))], false);
+        parts.push(`<path d="${d}" fill="none" stroke="${style.line}" stroke-width="${n(style.weld)}"/>`);
+    }
+    const axisHere = [at[0], c[1], at[2]];
+    list.push({ key: cam.depth(c) - cam.depth(axisHere), svg: parts.join("") });
+}
+function linesItem(piece, cam, at, style, list) {
+    let d = "";
+    for (const path of piece.paths) {
+        const pts = path.map(([x, y, z]) => [x + at[0], y + at[1], z + at[2]]);
+        // a line round a hull: only the runs that face the camera
+        let run = [];
+        const flush = () => {
+            if (run.length > 1)
+                d += pathOf(run, false);
+            run = [];
+        };
+        for (const p of pts) {
+            const out = [p[0] - at[0], 0, p[2] - at[2]];
+            const t = cam.toward(p);
+            if (dot(out, t) > 0)
+                run.push(cam.project(p));
+            else
+                flush();
+        }
+        flush();
+    }
+    if (!d)
+        return;
+    list.push({ key: -1e3, svg: `<path d="${d}" fill="none" stroke="${style.line}" stroke-width="${n(piece.weight === "feature" ? style.feature : style.weld)}"/>` });
+}
+/** One part's picture at `at`, as SVG text in painter's order. */
+export function drawPart(pieces, at, cam, look, weight = 1) {
+    const base = LOOKS[look];
+    const style = { line: base.line, outline: base.outline * weight, feature: base.feature * weight, weld: base.weld * weight };
+    const items = [];
+    for (const piece of pieces) {
+        if (piece.only === "mesh")
+            continue;
+        if (piece.kind === "lathe")
+            latheItem(piece, cam, at, style, items);
+        else if (piece.kind === "plate")
+            plateItem(piece, cam, at, style, items);
+        else
+            linesItem(piece, cam, at, style, items);
+    }
+    // far first
+    items.sort((a, b) => b.key - a.key);
+    return items.map((item) => item.svg).join("");
+}
+const HEX_W = 9;
+const HEX_H = 15.6;
+/** The picture's gradients and, on the tiled side, a mosaic of hexagons, for a look. */
+export function defsOf(look) {
+    const { fills, halo } = LOOKS[look];
+    const stops = ([a, b, c]) => `<stop offset="0" stop-color="${a}"/><stop offset=".55" stop-color="${b}"/><stop offset="1" stop-color="${c}"/>`;
+    return `<defs>${Object.keys(fills).map((name) => `<linearGradient id="${name}" x1="0" y1="0" x2="1" y2="0">${stops(fills[name])}</linearGradient>`).join("")}<pattern id="hex" width="${HEX_W}" height="${HEX_H}" patternUnits="userSpaceOnUse"><path d="M4.5 0L9 2.6V7.8L4.5 10.4L0 7.8V2.6ZM4.5 10.4V15.6M0 2.6V0M9 2.6V0" fill="none" stroke="${look === "painted" ? "#3a3d42" : LOOKS[look].line}" stroke-width=".35" opacity=".5"/></pattern>${halo ? '<radialGradient id="halo" cx=".5" cy=".5" r=".5"><stop offset="0" stop-color="#6cd0ff" stop-opacity=".14"/><stop offset="1" stop-color="#6cd0ff" stop-opacity="0"/></radialGradient>' : ""}</defs>`;
+}

package/dist/element/paint.d.ts

@@ -0,0 +1,9 @@
+export declare function canvas(w: number, h: number): HTMLCanvasElement;
+/** One repeat of a stainless hull: panels of slightly different tone, with weld lines between them. Its colour multiplies the steel's. `across` panels wide and `down` rings tall. */
+export declare function paintSteel(across: number, down: number): HTMLCanvasElement;
+/** A mosaic of hexagonal tiles in black with hair-thin gaps. `across` flats wide in one repeat. */
+export declare function paintTiles(across: number): HTMLCanvasElement;
+/** A soft round glow: the pool of light under a rocket. */
+export declare function paintGlow(inner: string, outer: string): HTMLCanvasElement;
+/** A day's sky for reflections, wrapped round a sphere: bright to the horizon, a pale ground, and tall dark and bright streaks, which is what gives a steel hull its long vertical sheen. */
+export declare function paintSky(): HTMLCanvasElement;