@johnmorrisdotca/uchusen-rockets 0.0.0-stage → 0.1.0

package/dist/model/materials.d.ts

@@ -0,0 +1,113 @@
+import type { FillName } from "../looks.ts";
+export interface MaterialSpec {
+    color: string;
+    metal: number;
+    rough: number;
+    /** The fill it takes in a drawing. */
+    fill: FillName;
+}
+export declare const MATERIALS: {
+    readonly steel: {
+        readonly color: "#c3c7cb";
+        readonly metal: 1;
+        readonly rough: 0.3;
+        readonly fill: "hull";
+    };
+    readonly tile: {
+        readonly color: "#101114";
+        readonly metal: 0;
+        readonly rough: 0.62;
+        readonly fill: "tile";
+    };
+    readonly "tile-plain": {
+        readonly color: "#101114";
+        readonly metal: 0;
+        readonly rough: 0.6;
+        readonly fill: "tile";
+    };
+    readonly soot: {
+        readonly color: "#17181a";
+        readonly metal: 0.2;
+        readonly rough: 0.85;
+        readonly fill: "dark";
+    };
+    readonly dark: {
+        readonly color: "#1c1d20";
+        readonly metal: 0.4;
+        readonly rough: 0.55;
+        readonly fill: "dark";
+    };
+    readonly bell: {
+        readonly color: "#2c2d31";
+        readonly metal: 0.55;
+        readonly rough: 0.42;
+        readonly fill: "bell";
+    };
+    readonly "bell-inside": {
+        readonly color: "#0a0a0c";
+        readonly metal: 0.2;
+        readonly rough: 0.8;
+        readonly fill: "dark";
+    };
+    readonly "engine-metal": {
+        readonly color: "#6d7075";
+        readonly metal: 0.85;
+        readonly rough: 0.4;
+        readonly fill: "metal";
+    };
+    readonly "engine-pale": {
+        readonly color: "#b9bcc0";
+        readonly metal: 0.6;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+    readonly fin: {
+        readonly color: "#6b6e73";
+        readonly metal: 0.85;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+    readonly "fin-dark": {
+        readonly color: "#2a2b2f";
+        readonly metal: 0.4;
+        readonly rough: 0.55;
+        readonly fill: "dark";
+    };
+    readonly white: {
+        readonly color: "#cfcfca";
+        readonly metal: 0;
+        readonly rough: 0.5;
+        readonly fill: "white";
+    };
+    readonly black: {
+        readonly color: "#141518";
+        readonly metal: 0;
+        readonly rough: 0.45;
+        readonly fill: "dark";
+    };
+    readonly gold: {
+        readonly color: "#c8a24c";
+        readonly metal: 1;
+        readonly rough: 0.28;
+        readonly fill: "metal";
+    };
+    readonly solar: {
+        readonly color: "#10163a";
+        readonly metal: 0.4;
+        readonly rough: 0.22;
+        readonly fill: "dark";
+    };
+    readonly glass: {
+        readonly color: "#141c26";
+        readonly metal: 0.1;
+        readonly rough: 0.08;
+        readonly fill: "dark";
+    };
+    readonly blue: {
+        readonly color: "#1d4f96";
+        readonly metal: 0.25;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+};
+export type MaterialName = keyof typeof MATERIALS;

package/dist/model/materials.js

@@ -0,0 +1,19 @@
+export const MATERIALS = {
+    steel: { color: "#c3c7cb", metal: 1, rough: 0.3, fill: "hull" },
+    tile: { color: "#101114", metal: 0, rough: 0.62, fill: "tile" },
+    "tile-plain": { color: "#101114", metal: 0, rough: 0.6, fill: "tile" },
+    soot: { color: "#17181a", metal: 0.2, rough: 0.85, fill: "dark" },
+    dark: { color: "#1c1d20", metal: 0.4, rough: 0.55, fill: "dark" },
+    bell: { color: "#2c2d31", metal: 0.55, rough: 0.42, fill: "bell" },
+    "bell-inside": { color: "#0a0a0c", metal: 0.2, rough: 0.8, fill: "dark" },
+    "engine-metal": { color: "#6d7075", metal: 0.85, rough: 0.4, fill: "metal" },
+    "engine-pale": { color: "#b9bcc0", metal: 0.6, rough: 0.5, fill: "metal" },
+    fin: { color: "#6b6e73", metal: 0.85, rough: 0.5, fill: "metal" },
+    "fin-dark": { color: "#2a2b2f", metal: 0.4, rough: 0.55, fill: "dark" },
+    white: { color: "#cfcfca", metal: 0, rough: 0.5, fill: "white" },
+    black: { color: "#141518", metal: 0, rough: 0.45, fill: "dark" },
+    gold: { color: "#c8a24c", metal: 1, rough: 0.28, fill: "metal" },
+    solar: { color: "#10163a", metal: 0.4, rough: 0.22, fill: "dark" },
+    glass: { color: "#141c26", metal: 0.1, rough: 0.08, fill: "dark" },
+    blue: { color: "#1d4f96", metal: 0.25, rough: 0.5, fill: "metal" },
+};

package/dist/model/pieces.d.ts

@@ -0,0 +1,91 @@
+import type { Vec3 } from "../framing.ts";
+import type { MaterialName } from "./materials.ts";
+export type { Vec3 };
+export interface Frame {
+    o: Vec3;
+    u: Vec3;
+    v: Vec3;
+    w: Vec3;
+}
+/** A body of revolution: `profile` is [radius, y] points going up the outside (going the other way faces inward). */
+export interface Lathe {
+    kind: "lathe";
+    material: MaterialName;
+    profile: readonly (readonly [number, number])[];
+    at?: readonly [number, number];
+    segs: number;
+    /** The part of the circle it covers at a height, as [from, to] radians; left out: all of it. */
+    arc?: (y: number) => readonly [number, number];
+    /** Heights with a ring of weld line. */
+    welds?: readonly number[];
+    /** Heights with a ring of feature line. */
+    rings?: readonly number[];
+    /** Texture coordinates for the painted look. */
+    uv?: boolean;
+    /** A shell the drawing skips, because a hull's outline already covers it. */
+    only?: "mesh" | "drawing";
+    /** It hangs under the body: drawn over the body from below and behind it from above. */
+    under?: boolean;
+    /** Part of the main body: a drawing draws these first and treats them as the depth others compare with. */
+    body?: boolean;
+    /** Its outline is drawn in a drawing. */
+    outline?: boolean;
+}
+/** A flat outline with a thickness, in a frame: `outline` is [u, v] points, going round; it stands from -thickness/2 to +thickness/2 along w. Convex, or it is drawn as its hull. */
+export interface Plate {
+    kind: "plate";
+    material: MaterialName;
+    /** The material of the +w face, when it differs. */
+    top?: MaterialName;
+    frame: Frame;
+    outline: readonly (readonly [number, number])[];
+    thickness: number;
+    /** Lines on its +w and -w faces, as [u, v] pairs. */
+    ribs?: readonly (readonly [readonly [number, number], readonly [number, number]])[];
+    only?: "mesh" | "drawing";
+    /** No feature lines of its own. */
+    plain?: boolean;
+}
+/** Lines only, in the part's own space. */
+export interface Lines {
+    kind: "lines";
+    weight: "feature" | "weld";
+    paths: readonly (readonly Vec3[])[];
+    only?: "mesh" | "drawing";
+}
+export type Piece = Lathe | Plate | Lines;
+/** A frame standing on the axis: u points outwards at `az` radians, v is up, w is along the circle. */
+export declare function radial(az: number, y?: number, atRadius?: number): Frame;
+/** A frame lying flat: u outwards at `az`, v along the circle, w up. */
+export declare function flat(az: number, y: number, atRadius?: number): Frame;
+export declare const pointOf: (f: Frame, a: number, b: number, c?: number) => Vec3;
+/** A long thin box from a to b, its width along `side`. */
+export declare function strut(material: MaterialName, a: Vec3, b: Vec3, width: number, depth: number, extra?: Partial<Plate>): Plate;
+/** A radius on a profile at a height. */
+export declare function radiusAt(profile: readonly (readonly [number, number])[], y: number): number;
+export interface Buffers {
+    positions: number[];
+    normals: number[];
+    uvs: number[];
+    indices: number[];
+    hasUv: boolean;
+}
+export interface LineBuffers {
+    positions: number[];
+    indices: number[];
+}
+export interface PartMesh {
+    faces: Map<MaterialName, Buffers>;
+    feature: LineBuffers;
+    weld: LineBuffers;
+}
+/** A ring just proud of the surface at a height, so it is not lost in it. */
+export declare function ringPath(piece: Lathe, y: number, lift?: number): Vec3[];
+/** The triangles and lines of a part. */
+export declare function meshOf(pieces: readonly Piece[]): PartMesh;
+export interface Bounds {
+    min: Vec3;
+    max: Vec3;
+}
+/** The box a part's triangles fill. */
+export declare function boundsOf(mesh: PartMesh): Bounds;

package/dist/model/pieces.js

@@ -0,0 +1,223 @@
+/** A frame standing on the axis: u points outwards at `az` radians, v is up, w is along the circle. */
+export function radial(az, y = 0, atRadius = 0) {
+    const u = [Math.sin(az), 0, Math.cos(az)];
+    return { o: [u[0] * atRadius, y, u[2] * atRadius], u, v: [0, 1, 0], w: [u[2], 0, -u[0]] };
+}
+/** A frame lying flat: u outwards at `az`, v along the circle, w up. */
+export function flat(az, y, atRadius = 0) {
+    const u = [Math.sin(az), 0, Math.cos(az)];
+    return { o: [u[0] * atRadius, y, u[2] * atRadius], u, v: [-u[2], 0, u[0]], w: [0, 1, 0] };
+}
+export const pointOf = (f, a, b, c = 0) => [f.o[0] + f.u[0] * a + f.v[0] * b + f.w[0] * c, f.o[1] + f.u[1] * a + f.v[1] * b + f.w[1] * c, f.o[2] + f.u[2] * a + f.v[2] * b + f.w[2] * c];
+/** A long thin box from a to b, its width along `side`. */
+export function strut(material, a, b, width, depth, extra = {}) {
+    const along = [b[0] - a[0], b[1] - a[1], b[2] - a[2]];
+    const length = Math.hypot(...along) || 1;
+    const u = [along[0] / length, along[1] / length, along[2] / length];
+    // any direction across it, keeping the same one for the same struts
+    const seed = Math.abs(u[1]) > 0.9 ? [Math.hypot(a[0], a[2]) > 1e-6 ? a[0] : 1, 0, a[2]] : [0, 1, 0];
+    const raw = [u[1] * seed[2] - u[2] * seed[1], u[2] * seed[0] - u[0] * seed[2], u[0] * seed[1] - u[1] * seed[0]];
+    const l = Math.hypot(...raw) || 1;
+    const v = [raw[0] / l, raw[1] / l, raw[2] / l];
+    const w = [u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0]];
+    return { kind: "plate", material, frame: { o: a, u, v, w }, outline: [[0, -width / 2], [length, -width / 2], [length, width / 2], [0, width / 2]], thickness: depth, plain: true, ...extra };
+}
+/** A radius on a profile at a height. */
+export function radiusAt(profile, y) {
+    for (let i = 0; i + 1 < profile.length; i++) {
+        const [r0, y0] = profile[i];
+        const [r1, y1] = profile[i + 1];
+        if (y >= Math.min(y0, y1) && y <= Math.max(y0, y1))
+            return y1 === y0 ? Math.max(r0, r1) : r0 + ((r1 - r0) * (y - y0)) / (y1 - y0);
+    }
+    return 0;
+}
+const newBuffers = () => ({ positions: [], normals: [], uvs: [], indices: [], hasUv: false });
+function buffersOf(mesh, material) {
+    let b = mesh.faces.get(material);
+    if (!b) {
+        b = newBuffers();
+        mesh.faces.set(material, b);
+    }
+    return b;
+}
+/** A lathe's triangles. Each segment has its own vertices where the profile turns sharply and shares them where it runs smoothly. */
+function latheFaces(mesh, piece) {
+    const out = buffersOf(mesh, piece.material);
+    const [cx, cz] = piece.at ?? [0, 0];
+    const { profile, segs, arc } = piece;
+    if (piece.uv)
+        out.hasUv = true;
+    const normalOf = (i) => {
+        const [r0, y0] = profile[i];
+        const [r1, y1] = profile[i + 1];
+        const l = Math.hypot(r1 - r0, y1 - y0) || 1;
+        return [(y1 - y0) / l, -(r1 - r0) / l];
+    };
+    const SMOOTH = Math.cos((40 * Math.PI) / 180);
+    // the span round the circle: the widest of the stations, so vertex counts agree
+    const spans = profile.map(([, y]) => (arc ? arc(y)[1] - arc(y)[0] : 2 * Math.PI));
+    const span = Math.max(...spans);
+    const n = Math.max(2, Math.ceil((segs * span) / (2 * Math.PI)));
+    for (let s = 0; s + 1 < profile.length; s++) {
+        const nHere = normalOf(s);
+        const smoothWith = (other) => {
+            if (other < 0 || other + 1 >= profile.length)
+                return nHere;
+            const nb = normalOf(other);
+            if (nHere[0] * nb[0] + nHere[1] * nb[1] < SMOOTH)
+                return nHere;
+            const l = Math.hypot(nHere[0] + nb[0], nHere[1] + nb[1]) || 1;
+            return [(nHere[0] + nb[0]) / l, (nHere[1] + nb[1]) / l];
+        };
+        const base = out.positions.length / 3;
+        for (const [station, normal] of [
+            [s, smoothWith(s - 1)],
+            [s + 1, smoothWith(s + 1)],
+        ]) {
+            const [r, y] = profile[station];
+            const [a0, a1] = arc ? arc(y) : [0, 2 * Math.PI];
+            for (let j = 0; j <= n; j++) {
+                const a = a0 + ((a1 - a0) * j) / n;
+                const sa = Math.sin(a);
+                const ca = Math.cos(a);
+                out.positions.push(cx + r * sa, y, cz + r * ca);
+                out.normals.push(normal[0] * sa, normal[1], normal[0] * ca);
+                // u: round the hull; v: height over a hundred metres, so one picture repeats the same on every part
+                // an arc that starts on the far side of the windward line is shifted a half turn, so it stays between 0 and 1
+                out.uvs.push(a / (2 * Math.PI) + (a0 < 0 ? 0.5 : 0), y / 100);
+            }
+        }
+        const row = n + 1;
+        for (let j = 0; j < n; j++) {
+            const a = base + j;
+            const b = base + j + 1;
+            const c = base + row + j;
+            const d = base + row + j + 1;
+            // going up the outside faces outward
+            out.indices.push(a, b, d, a, d, c);
+        }
+    }
+}
+const addPath = (lines, path) => {
+    const base = lines.positions.length / 3;
+    for (const p of path)
+        lines.positions.push(p[0], p[1], p[2]);
+    for (let i = 0; i + 1 < path.length; i++)
+        lines.indices.push(base + i, base + i + 1);
+};
+/** A ring just proud of the surface at a height, so it is not lost in it. */
+export function ringPath(piece, y, lift = 0.012) {
+    const [cx, cz] = piece.at ?? [0, 0];
+    const r = radiusAt(piece.profile, y) + lift;
+    const [a0, a1] = piece.arc ? piece.arc(y) : [0, 2 * Math.PI];
+    const n = Math.max(2, Math.ceil((piece.segs * (a1 - a0)) / (2 * Math.PI)));
+    const path = [];
+    for (let j = 0; j <= n; j++) {
+        const a = a0 + ((a1 - a0) * j) / n;
+        path.push([cx + r * Math.sin(a), y, cz + r * Math.cos(a)]);
+    }
+    return path;
+}
+function plateFaces(mesh, piece) {
+    const { frame, outline, thickness } = piece;
+    const half = thickness / 2;
+    const n = outline.length;
+    const addFan = (material, c, normal, reverse) => {
+        const out = buffersOf(mesh, material);
+        const base = out.positions.length / 3;
+        for (const [a, b] of outline) {
+            out.positions.push(...pointOf(frame, a, b, c));
+            out.normals.push(...normal);
+            out.uvs.push(0, 0);
+        }
+        for (let i = 1; i + 1 < n; i++) {
+            if (reverse)
+                out.indices.push(base, base + i + 1, base + i);
+            else
+                out.indices.push(base, base + i, base + i + 1);
+        }
+    };
+    // the turn of the outline: which way round decides which face is outward
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const [a0, b0] = outline[i];
+        const [a1, b1] = outline[(i + 1) % n];
+        area += a0 * b1 - a1 * b0;
+    }
+    const ccw = area > 0;
+    // u x v against w: a frame may be either hand
+    const hand = frame.u[1] * frame.v[2] - frame.u[2] * frame.v[1];
+    const hand2 = frame.u[2] * frame.v[0] - frame.u[0] * frame.v[2];
+    const hand3 = frame.u[0] * frame.v[1] - frame.u[1] * frame.v[0];
+    const right = hand * frame.w[0] + hand2 * frame.w[1] + hand3 * frame.w[2] > 0;
+    addFan(piece.top ?? piece.material, half, frame.w, ccw !== right);
+    addFan(piece.material, -half, [-frame.w[0], -frame.w[1], -frame.w[2]], ccw === right);
+    const out = buffersOf(mesh, piece.material);
+    for (let i = 0; i < n; i++) {
+        const [a0, b0] = outline[i];
+        const [a1, b1] = outline[(i + 1) % n];
+        const du = a1 - a0;
+        const dv = b1 - b0;
+        const sign = ccw ? 1 : -1;
+        const nu = dv * sign;
+        const nv = -du * sign;
+        const l = Math.hypot(nu, nv) || 1;
+        const normal = [(frame.u[0] * nu + frame.v[0] * nv) / l, (frame.u[1] * nu + frame.v[1] * nv) / l, (frame.u[2] * nu + frame.v[2] * nv) / l];
+        const base = out.positions.length / 3;
+        for (const p of [pointOf(frame, a0, b0, -half), pointOf(frame, a1, b1, -half), pointOf(frame, a1, b1, half), pointOf(frame, a0, b0, half)]) {
+            out.positions.push(...p);
+            out.normals.push(...normal);
+            out.uvs.push(0, 0);
+        }
+        if (right)
+            out.indices.push(base, base + 1, base + 2, base, base + 2, base + 3);
+        else
+            out.indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+    }
+}
+/** The triangles and lines of a part. */
+export function meshOf(pieces) {
+    const mesh = { faces: new Map(), feature: { positions: [], indices: [] }, weld: { positions: [], indices: [] } };
+    for (const piece of pieces) {
+        if (piece.only === "drawing")
+            continue;
+        if (piece.kind === "lathe") {
+            latheFaces(mesh, piece);
+            for (const y of piece.rings ?? [])
+                addPath(mesh.feature, ringPath(piece, y));
+            for (const y of piece.welds ?? [])
+                addPath(mesh.weld, ringPath(piece, y));
+        }
+        else if (piece.kind === "plate") {
+            plateFaces(mesh, piece);
+            if (!piece.plain) {
+                const half = piece.thickness / 2 + 0.006;
+                for (const c of [half, -half])
+                    addPath(mesh.feature, [...piece.outline, piece.outline[0]].map(([a, b]) => pointOf(piece.frame, a, b, c)));
+                for (const [p, q] of piece.ribs ?? [])
+                    for (const c of [half, -half])
+                        addPath(mesh.weld, [pointOf(piece.frame, p[0], p[1], c), pointOf(piece.frame, q[0], q[1], c)]);
+            }
+        }
+        else {
+            for (const path of piece.paths)
+                addPath(piece.weight === "feature" ? mesh.feature : mesh.weld, path);
+        }
+    }
+    return mesh;
+}
+/** The box a part's triangles fill. */
+export function boundsOf(mesh) {
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    for (const b of mesh.faces.values())
+        for (let i = 0; i < b.positions.length; i += 3)
+            for (let c = 0; c < 3; c++) {
+                if (b.positions[i + c] < min[c])
+                    min[c] = b.positions[i + c];
+                if (b.positions[i + c] > max[c])
+                    max[c] = b.positions[i + c];
+            }
+    return { min, max };
+}

package/dist/model/registry.d.ts

@@ -0,0 +1,8 @@
+import type { PartRecord } from "../parts.ts";
+import type { Piece } from "./pieces.ts";
+export interface PartEntry {
+    record: PartRecord;
+    pieces: () => Piece[];
+}
+export declare const PART_ENTRIES: readonly PartEntry[];
+export declare const partEntry: (id: string) => PartEntry | undefined;

package/dist/model/registry.js

@@ -0,0 +1,104 @@
+// Every part there is, with its record and how to make its pieces. A new rocket adds its rows here and nothing else changes.
+import { DRAGON_VARIANTS } from "../data/dragon.js";
+import { FALCON_9_VARIANTS } from "../data/falcon.js";
+import { STARSHIP_VARIANTS } from "../data/starship.js";
+import { capsule, centreCore, DRAGON_DRAWS, falconFairing, falconFirstStage, FALCON_DRAWS, falconSecondStage, grasshopper, merlin, sideBooster, trunk } from "./falcon.js";
+import { boosterPieces, flap, gridFin, raptor, shipPieces, STARSHIP_DRAWS } from "./starship.js";
+const blankFigure = { value: null, source: null, note: "No source gives this part's size: it is drawn from photographs." };
+const STAGE = "stage";
+/** Which licensed model paints which part. */
+const PAINTED = {
+    "starship-v3-booster": { file: "starship-v3-booster.glb", credit: "clarence365-block3" },
+    "starship-v3-ship": { file: "starship-v3-ship.glb", credit: "clarence365-block3" },
+    "starship-v1-flight1-booster": { file: "starship-v1-flight1-booster.glb", credit: "clarence365-s24b7" },
+    "starship-v1-flight1-ship": { file: "starship-v1-flight1-ship.glb", credit: "clarence365-s24b7" },
+    "starship-2019-ship": { file: "starship-2019-ship.glb", credit: "martiandays-2019" },
+    "falcon-9-block-5-first-stage": { file: "falcon-9-block-5-first-stage.glb", credit: "stanley-falcon-9" },
+    "falcon-9-block-5-second-stage": { file: "falcon-9-block-5-second-stage.glb", credit: "stanley-falcon-9" },
+    "falcon-9-block-5-fairing": { file: "falcon-9-block-5-fairing.glb", credit: "stanley-falcon-9" },
+    "dragon-dragon-2-capsule": { file: "dragon-dragon-2-capsule.glb", credit: "kubaha-dragon-2" },
+    "dragon-dragon-2-trunk": { file: "dragon-dragon-2-trunk.glb", credit: "kubaha-dragon-2" },
+    "dragon-dragon-1-capsule": { file: "dragon-dragon-1-capsule.glb", credit: "progressth-dragon-1" },
+    "dragon-dragon-1-trunk": { file: "dragon-dragon-1-trunk.glb", credit: "progressth-dragon-1" },
+    "falcon-heavy-falcon-heavy-centre": { file: "falcon-heavy-falcon-heavy-centre.glb", credit: "antonio-falcon-heavy" },
+    "falcon-heavy-falcon-heavy-side-left": { file: "falcon-heavy-falcon-heavy-side-left.glb", credit: "antonio-falcon-heavy" },
+    "falcon-heavy-falcon-heavy-side-right": { file: "falcon-heavy-falcon-heavy-side-right.glb", credit: "antonio-falcon-heavy" },
+    "grasshopper-grasshopper-vehicle": { file: "grasshopper-grasshopper-vehicle.glb", credit: "echo3-grasshopper" },
+};
+const DRAWN_FROM = {
+    v1: "This package's code, sized from the block table; parts' proportions judged from photographs of Block 1 and from Clarence365's Ship 24 and Booster 7.",
+    "v1-flight1": "This package's code for the two line looks, Clarence365's Ship 24 and Booster 7 for the painted look, both at the sourced sizes.",
+    v2: "This package's code, sized from the block table; parts' proportions judged from photographs and the documented flap changes. No licensed model shows Block 2.",
+    v3: "This package's code for the two line looks, proportions measured from Clarence365's Block 3 at the sourced sizes; Clarence365's model for the painted look.",
+    v4: "This package's code: Block 3's details on Block 4's sourced sizes. Thin evidence: no source shows its parts.",
+    "2019": "This package's code for the two line looks, proportions measured from MartianDays' model; MartianDays' model for the painted look. An artist's model of a design.",
+};
+const entries = [];
+const KIND_OF_SLOT = { booster: "booster", ship: "ship" };
+function starshipPart(variant, slot) {
+    const draw = STARSHIP_DRAWS[variant.id];
+    const id = `starship-${variant.id}-${slot}`;
+    const height = slot === "booster" ? draw.boosterHeight : draw.shipHeight;
+    const diameter = draw.radius * 2;
+    return {
+        record: {
+            id,
+            kind: KIND_OF_SLOT[slot],
+            name: `${slot === "booster" ? "Super Heavy" : "Ship"}, ${variant.name}`,
+            rocket: "starship",
+            trueTo: [variant.id],
+            height,
+            diameter,
+            sourced: { height: variant.facts.parts[slot] ?? blankFigure, diameter: variant.facts.diameter },
+            joints: slot === "booster" ? { top: { kind: STAGE, y: height, diameter } } : { bottom: { kind: STAGE, y: 0, diameter } },
+            painted: PAINTED[id] ?? null,
+            drawnFrom: DRAWN_FROM[variant.id],
+        },
+        pieces: () => (slot === "booster" ? boosterPieces(draw) : shipPieces(draw)),
+    };
+}
+for (const variant of STARSHIP_VARIANTS)
+    for (const slot of variant.slots)
+        entries.push(starshipPart(variant, slot));
+/** A small part on its own: nothing to mate with, sizes as drawn. */
+function detail(id, kind, name, height, diameter, sourced, pieces) {
+    return { record: { id, kind, name, rocket: "starship", trueTo: [], height, diameter, sourced, joints: {}, painted: null, drawnFrom: "This package's code." }, pieces };
+}
+// ---------------------------------------------------------------------------------------------------------------------------------
+// Falcon 9, Dragon, Falcon Heavy and Grasshopper
+const facts = (variants, id, slot) => {
+    const variant = variants.find((one) => one.id === id);
+    const height = variant?.facts.parts[slot];
+    return { height: height?.brief ? { ...blankFigure, note: `${height.value} m, ${height.brief}.` } : (height ?? blankFigure), diameter: variant?.facts.diameter ?? blankFigure };
+};
+const FROM_CODE = "This package's code, sized from sourced totals; parts' proportions judged from photographs. No licensed model shows this version.";
+const FROM_F9 = "This package's code for the two line looks, proportions taken from Stanley Creative's Falcon 9 at the sourced sizes; Stanley Creative's model for the painted look. It shows Block 5: black interstage and legs, grid fins.";
+for (const id of Object.keys(FALCON_DRAWS)) {
+    const d = FALCON_DRAWS[id];
+    const painted = (slot) => PAINTED[`falcon-9-${id}-${slot}`] ?? null;
+    const drawnFrom = id === "block-5" ? FROM_F9 : FROM_CODE;
+    entries.push({ record: { id: `falcon-9-${id}-first-stage`, kind: "first-stage", name: `First stage, Falcon 9 ${id}`, rocket: "falcon-9", trueTo: id === "block-5" ? [id, "block-5-dragon-2"] : [id], height: d.first.height, diameter: 3.7, sourced: facts(FALCON_9_VARIANTS, id, "first-stage"), joints: { top: { kind: "stage", y: d.first.height, diameter: 3.7 } }, painted: painted("first-stage"), drawnFrom }, pieces: () => falconFirstStage(id) }, { record: { id: `falcon-9-${id}-second-stage`, kind: "second-stage", name: `Second stage, Falcon 9 ${id}`, rocket: "falcon-9", trueTo: id === "block-5" ? [id, "block-5-dragon-2"] : [id], height: d.second.height, diameter: 3.7, sourced: facts(FALCON_9_VARIANTS, id, "second-stage"), joints: { bottom: { kind: "stage", y: d.second.joint, diameter: 3.7 }, top: { kind: "stage", y: d.second.height, diameter: 3.7 } }, painted: painted("second-stage"), drawnFrom }, pieces: () => falconSecondStage(id) }, { record: { id: `falcon-9-${id}-fairing`, kind: "fairing", name: `Fairing, Falcon 9 ${id}`, rocket: "falcon-9", trueTo: [id], height: d.fairing.height, diameter: d.fairing.radius * 2, sourced: { height: facts(FALCON_9_VARIANTS, id, "fairing").height, diameter: blankFigure }, joints: { bottom: { kind: "stage", y: 0, diameter: 3.7 } }, painted: painted("fairing"), drawnFrom }, pieces: () => falconFairing(id) });
+}
+const DRAGON_FROM = {
+    "dragon-1": "This package's code for the two line looks, proportions taken from ProgressTH's model; ProgressTH's model for the painted look. It shows the original Dragon 1, with solar wings, not Cargo Dragon 2.",
+    "dragon-2": "This package's code for the two line looks, proportions taken from KUBAHA's model; KUBAHA's model for the painted look. It shows Crew Dragon, with windows.",
+};
+for (const variant of DRAGON_VARIANTS) {
+    const d = DRAGON_DRAWS[variant.id];
+    const trueTo = variant.id === "dragon-2" ? [variant.id, "block-5-dragon-2"] : [variant.id];
+    const joint = 3.7;
+    entries.push({ record: { id: `dragon-${variant.id}-trunk`, kind: "trunk", name: `Trunk, ${variant.name}`, rocket: "dragon", trueTo, height: d.trunk, diameter: d.trunkRadius * 2, sourced: { height: variant.facts.parts.trunk, diameter: blankFigure }, joints: { bottom: { kind: "stage", y: 0, diameter: joint }, top: { kind: "stage", y: d.trunk, diameter: joint } }, painted: PAINTED[`dragon-${variant.id}-trunk`] ?? null, drawnFrom: DRAGON_FROM[variant.id] }, pieces: () => trunk(d) }, { record: { id: `dragon-${variant.id}-capsule`, kind: "capsule", name: `Capsule, ${variant.name}`, rocket: "dragon", trueTo, height: d.capsule, diameter: d.baseRadius * 2, sourced: { height: variant.facts.parts.capsule, diameter: variant.facts.diameter }, joints: { bottom: { kind: "stage", y: d.nest, diameter: joint } }, painted: PAINTED[`dragon-${variant.id}-capsule`] ?? null, drawnFrom: DRAGON_FROM[variant.id] }, pieces: () => capsule(d) });
+}
+const FH_FROM = "This package's code for the two line looks, proportions taken from Antonio_Adams's low-poly model at the sourced sizes; that model for the painted look. It shows the whole vehicle in one shell, so its centre core, upper stage and fairing stay one part.";
+const FH_SIDE_HEIGHT = 45.6;
+const FH_OFFSET = 4.25;
+const figure = (value, source) => ({ value, source });
+entries.push({ record: { id: "falcon-heavy-falcon-heavy-centre", kind: "first-stage", name: "Falcon Heavy centre core, with its upper stage and fairing", rocket: "falcon-heavy", trueTo: ["falcon-heavy"], height: 70, diameter: 5.2, sourced: { height: figure(70, "wikipedia-falcon-heavy"), diameter: { ...blankFigure, note: "3.7 m the core; 5.2 m the fairing." } }, joints: {}, painted: PAINTED["falcon-heavy-falcon-heavy-centre"], drawnFrom: FH_FROM }, pieces: () => centreCore(70, 1.85) }, { record: { id: "falcon-heavy-falcon-heavy-side-left", kind: "first-stage", name: "Falcon Heavy side booster, left", rocket: "falcon-heavy", trueTo: ["falcon-heavy"], height: FH_SIDE_HEIGHT, diameter: 3.7, strapOn: { x: -FH_OFFSET, z: 0 }, sourced: { height: blankFigure, diameter: figure(3.7, "wikipedia-falcon-heavy") }, joints: {}, painted: PAINTED["falcon-heavy-falcon-heavy-side-left"], drawnFrom: FH_FROM }, pieces: () => sideBooster(FH_SIDE_HEIGHT, 1.85, -1) }, { record: { id: "falcon-heavy-falcon-heavy-side-right", kind: "first-stage", name: "Falcon Heavy side booster, right", rocket: "falcon-heavy", trueTo: ["falcon-heavy"], height: FH_SIDE_HEIGHT, diameter: 3.7, strapOn: { x: FH_OFFSET, z: 0 }, sourced: { height: blankFigure, diameter: figure(3.7, "wikipedia-falcon-heavy") }, joints: {}, painted: PAINTED["falcon-heavy-falcon-heavy-side-right"], drawnFrom: FH_FROM }, pieces: () => sideBooster(FH_SIDE_HEIGHT, 1.85, 1) }, { record: { id: "grasshopper-grasshopper-vehicle", kind: "test-vehicle", name: "Grasshopper, test vehicle", rocket: "grasshopper", trueTo: ["grasshopper"], height: 32, diameter: 3.2, sourced: { height: figure(32, "wikipedia-grasshopper"), diameter: blankFigure }, joints: {}, painted: PAINTED["grasshopper-grasshopper-vehicle"], drawnFrom: "This package's code for the two line looks, proportions taken from Echo_3's low-poly model at the sourced height; that model for the painted look." }, pieces: () => grasshopper(32) });
+const RAPTOR_DIAMETER = { value: 1.3, source: "wikipedia-raptor", note: "The family's engine diameter." };
+const RAPTOR_LENGTH = { value: 3.1, source: "wikipedia-raptor", note: "The family's length." };
+const b3 = STARSHIP_DRAWS.v3;
+const b2 = STARSHIP_DRAWS.v2;
+entries.push(detail("raptor-sea-level", "engine", "Raptor, sea-level", 3.1, 1.24, { height: RAPTOR_LENGTH, diameter: RAPTOR_DIAMETER }, () => raptor([0, 0], 0, "sea")), detail("raptor-vacuum", "engine", "Raptor, vacuum", 4.4, 2.3, { height: blankFigure, diameter: blankFigure }, () => raptor([0, 0], 0, "vacuum")), detail("grid-fin-four", "fin", "Grid fin, Blocks 1 and 2", 0.9, 2.9, { height: blankFigure, diameter: blankFigure }, () => gridFin(90, 0, b2.radius, b2.fins.reach, b2.fins.width, b2.fins.thick, false)), detail("grid-fin-three", "fin", "Grid fin, Block 3", 0.9, 3.4, { height: blankFigure, diameter: blankFigure }, () => gridFin(90, 0, b3.radius, b3.fins.reach, b3.fins.width, b3.fins.thick, true)), detail("flap-aft", "flap", "Aft flap", 11.6, 3.8, { height: blankFigure, diameter: blankFigure }, () => [flap(b3.aft, 1)]), detail("flap-forward", "flap", "Forward flap, Blocks 2 and 3", 8.1, 4.7, { height: blankFigure, diameter: blankFigure }, () => [flap(b3.forward, 1)]), detail("merlin-sea-level", "engine", "Merlin, sea-level", 2, 0.92, { height: blankFigure, diameter: blankFigure }, () => merlin([0, 0], 0, 0.46, 2)));
+export const PART_ENTRIES = entries;
+const byId = new Map(entries.map((entry) => [entry.record.id, entry]));
+export const partEntry = (id) => byId.get(id);

package/dist/model/starship.d.ts

@@ -0,0 +1,67 @@
+import { type Piece, type Plate } from "./pieces.ts";
+export interface FlapDraw {
+    /** Where its root is, degrees round from the windward side. */
+    az: number;
+    /** [radius, height] points of its outline. */
+    outline: readonly (readonly [number, number])[];
+    thickness: number;
+}
+export interface EngineDraw {
+    ring: number;
+    count: number;
+    /** Degrees to the first engine. */
+    start: number;
+    type: "sea" | "vacuum";
+}
+export interface StarshipDraw {
+    radius: number;
+    boosterHeight: number;
+    shipHeight: number;
+    /** Where the booster's steel starts over its engines. */
+    boosterSkirt: number;
+    /** The bay's ceiling. */
+    boosterBay: number;
+    /** Whether a skirt shields the engines (Blocks 1 and 2) or they stand bare (Block 3). */
+    shielded: boolean;
+    ring: {
+        height: number;
+        struts: number;
+        integrated: boolean;
+    };
+    fins: {
+        az: readonly number[];
+        y: number;
+        reach: number;
+        width: number;
+        thick: number;
+        octagon: boolean;
+    };
+    chines: {
+        az: readonly number[];
+        from: number;
+        to: number;
+        out: number;
+    };
+    boosterEngines: readonly EngineDraw[];
+    shipEngines: readonly EngineDraw[];
+    noseStart: number;
+    /** Degrees each way from the windward line that tiles cover, by height. */
+    tile: readonly (readonly [number, number])[];
+    forward: FlapDraw;
+    aft: FlapDraw;
+    /** Payload door on the leeward side, as [from, to] heights. */
+    door: readonly [number, number] | null;
+    /** Block 3's docking ports. */
+    docking: boolean;
+}
+export declare const STARSHIP_DRAWS: Readonly<Record<string, StarshipDraw>>;
+/** One Raptor from its exit up: the bell, its dark inside and the machinery over it. Its origin is the middle of its exit. */
+export declare function raptor(at: readonly [number, number], y: number, type: "sea" | "vacuum"): Piece[];
+/** A grid fin held out flat: a frame and a lattice, u outwards and v along the circle. */
+export declare function gridFin(azDeg: number, y: number, rootRadius: number, reach: number, width: number, thick: number, octagon: boolean): Piece[];
+/** A flap's plate, tiled on its windward face. `outline` is [radius, height]. */
+export declare function flap(draw: FlapDraw, side: 1 | -1): Plate;
+/** Super Heavy: its base on the axis at the bells' exit. */
+export declare function boosterPieces(d: StarshipDraw): Piece[];
+/** The ship: its base on the axis at the bottom of its skirt. */
+export declare function shipPieces(d: StarshipDraw): Piece[];