@johnmorrisdotca/uchusen-rockets 0.2.2 → 0.4.0

package/dist/model/jupiterc.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const JUPITER_C_BUILDS: readonly StackBuild[];

package/dist/model/jupiterc.js

@@ -0,0 +1,24 @@
+// Jupiter-C in plain shapes, for the line looks: its height and width are sourced, and its outline is measured from NASA's model at that scale. The painted look is NASA's model.
+import { JUPITER_C_WIDE } from "../data/jupiterc.js";
+import { fins, floor, stripes, taper, tube } from "./kit.js";
+const H = 21.3;
+const R = (JUPITER_C_WIDE.value ?? 0) / 2;
+const vehicle = () => [
+    tube("white", R, 0.42, 3.1, { rings: [0.44, 3.08] }),
+    ...stripes("black", R, 0.42, 3.1, [0, 180], 60),
+    floor(R, 0.42),
+    ...fins("engine-pale", R, [45, 135, 225, 315], [[0, 0.9], [0.5, 0.1], [0.55, 0.9], [0, 2.9]], 0.06),
+    tube("steel", R, 3.1, 14.6, { rings: [9.2], welds: [6, 12] }),
+    taper("steel", R, 14.6, 0.47, 18.2, { rings: [14.62] }),
+    taper("steel", 0.47, 18.2, 0.17, 19.4),
+    tube("engine-pale", 0.17, 19.4, H - 0.4),
+    taper("engine-pale", 0.17, H - 0.4, 0.02, H),
+];
+export const JUPITER_C_BUILDS = [
+    {
+        rocket: "jupiter-c",
+        variant: "jupiter-c",
+        drawnFrom: "NASA's model for the painted look, its lettering removed. This package's plain shapes for the two line looks, from the sourced height and width. No lettering is drawn.",
+        parts: [{ slot: "vehicle", kind: "first-stage", name: "Jupiter-C", height: H, diameter: R * 2, sourcedDiameter: JUPITER_C_WIDE, painted: { file: "jupiter-c-vehicle.glb", credit: "nasa-jupiter-c" }, pieces: vehicle }],
+    },
+];

package/dist/model/kit.d.ts

@@ -0,0 +1,36 @@
+import type { MaterialName } from "./materials.ts";
+import { type Lathe, type Piece, type Plate } from "./pieces.ts";
+type Extra = Partial<Omit<Lathe, "kind" | "material" | "profile">>;
+/** A straight tube from y0 to y1. */
+export declare const tube: (material: MaterialName, r: number, y0: number, y1: number, extra?: Extra) => Lathe;
+/** A cone or a step between two radii. */
+export declare const taper: (material: MaterialName, r0: number, y0: number, r1: number, y1: number, extra?: Extra) => Lathe;
+/** A rounded nose from a radius at y0 to a point at y1. `blunt` above 1 is fuller at the shoulder, below 1 is sharper. */
+export declare function nose(material: MaterialName, r: number, y0: number, y1: number, blunt?: number, extra?: Extra): Lathe;
+/** A flat dark floor closing a tube from below. */
+export declare const floor: (r: number, y: number, material?: MaterialName) => Lathe;
+/** Stripes down a hull: `width` degrees wide, each centred on one of `azimuths`, just proud of it. */
+export declare const stripes: (material: MaterialName, r: number, y0: number, y1: number, azimuths: readonly number[], width: number) => Lathe[];
+/** Engines in a ring, the first at `start` degrees. */
+export declare function engineRing(count: number, ringRadius: number, y: number, exit: number, length: number, start?: number): Piece[];
+/** A long box up the side of a hull at `az` degrees: a raceway or a cable tunnel. */
+export declare const raceway: (material: MaterialName, r: number, y0: number, y1: number, az: number, width?: number, depth?: number) => Plate;
+/** Fins on a hull, each a flat outline given as [out from the hull, y] points. */
+export declare const fins: (material: MaterialName, r: number, azimuths: readonly number[], outline: readonly (readonly [number, number])[], thickness?: number) => Plate[];
+/** A straight strut between two points given in cylinder terms: [radius, y, azimuth in degrees]. */
+export declare function brace(material: MaterialName, a: readonly [number, number, number], b: readonly [number, number, number], width?: number): Plate;
+/** An open skirt: a tube seen from outside and from inside, so an engine under it shows from below. */
+export declare const skirt: (material: MaterialName, r: number, y0: number, y1: number, extra?: Extra) => Piece[];
+/** A cone over an engine, off the axis: a fairing at the foot of a stage. */
+export declare const pod: (material: MaterialName, at: readonly [number, number], r0: number, y0: number, r1: number, y1: number, extra?: Extra) => Lathe;
+/** A fairing: straight from the joint, then a rounded nose, with the seam where its halves meet. */
+export declare function fairingShell(material: MaterialName, r: number, height: number, straight: number, blunt?: number, jointRadius?: number): Piece[];
+/** Legs folded against a hull, as dark ribs from the foot up. */
+export declare const foldedLegs: (material: MaterialName, r: number, azimuths: readonly number[], foot: number, top: number, width: number) => Plate[];
+/** Pieces turned round the Y axis by `turn` degrees, then moved along the ground. For putting a whole structure in its place on a map. A lathe's arc and lean are left as they are, so they are for pieces with neither. */
+export declare function moved(pieces: readonly Piece[], x: number, z: number, turn?: number): Piece[];
+/** A box on the ground, `wide` by `deep` and turned `turn` degrees, from y0 to y1. */
+export declare function slab(material: MaterialName, x: number, z: number, wide: number, deep: number, turn: number, y0: number, y1: number, plain?: boolean): Plate;
+/** A road on the ground, from point to point. */
+export declare const road: (material: MaterialName, points: readonly (readonly [number, number])[], width: number, y: number) => Plate[];
+export {};

package/dist/model/kit.js

@@ -0,0 +1,95 @@
+// The small shapes a rocket is put together from, so a new rocket is a table of numbers. Each returns plain pieces: the mesh and the drawing are made from them as for any other part. Pure.
+import { deg } from "../framing.js";
+import { merlin } from "./falcon.js";
+import { pointOf, radial, strut } from "./pieces.js";
+/** A straight tube from y0 to y1. */
+export const tube = (material, r, y0, y1, extra = {}) => ({ kind: "lathe", material, segs: 40, body: true, outline: true, profile: [[r, y0], [r, y1]], ...extra });
+/** A cone or a step between two radii. */
+export const taper = (material, r0, y0, r1, y1, extra = {}) => ({ kind: "lathe", material, segs: 40, body: true, outline: true, profile: [[r0, y0], [r1, y1]], ...extra });
+/** A rounded nose from a radius at y0 to a point at y1. `blunt` above 1 is fuller at the shoulder, below 1 is sharper. */
+export function nose(material, r, y0, y1, blunt = 1.7, extra = {}) {
+    const steps = 10;
+    const profile = [];
+    for (let i = 0; i <= steps; i++) {
+        const t = i / steps;
+        profile.push([r * Math.sqrt(Math.max(0, 1 - t ** (2 * blunt))), y0 + (y1 - y0) * t]);
+    }
+    profile[steps] = [0.001, y1];
+    return { kind: "lathe", material, segs: 40, body: true, outline: true, profile, ...extra };
+}
+/** A flat dark floor closing a tube from below. */
+export const floor = (r, y, material = "soot") => ({ kind: "lathe", material, segs: 32, under: true, profile: [[0, y], [r, y]] });
+/** Stripes down a hull: `width` degrees wide, each centred on one of `azimuths`, just proud of it. */
+export const stripes = (material, r, y0, y1, azimuths, width) => azimuths.map((az) => ({ kind: "lathe", material, segs: 72, body: true, profile: [[r * 1.012, y0], [r * 1.012, y1]], arc: () => [deg(az - width / 2), deg(az + width / 2)] }));
+/** Engines in a ring, the first at `start` degrees. */
+export function engineRing(count, ringRadius, y, exit, length, start = 0) {
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        const a = deg(start + (i * 360) / count);
+        out.push(...merlin([ringRadius * Math.sin(a), ringRadius * Math.cos(a)], y, exit, length));
+    }
+    return out;
+}
+/** A long box up the side of a hull at `az` degrees: a raceway or a cable tunnel. */
+export const raceway = (material, r, y0, y1, az, width = 0.2, depth = 0.1) => {
+    const f = radial(deg(az));
+    return strut(material, pointOf(f, r + depth / 2, y0), pointOf(f, r + depth / 2, y1), width, depth, { plain: false });
+};
+/** Fins on a hull, each a flat outline given as [out from the hull, y] points. */
+export const fins = (material, r, azimuths, outline, thickness = 0.1) => azimuths.map((az) => ({ kind: "plate", material, frame: radial(deg(az)), outline: outline.map(([out, y]) => [r + out, y]), thickness }));
+/** A straight strut between two points given in cylinder terms: [radius, y, azimuth in degrees]. */
+export function brace(material, a, b, width = 0.1) {
+    const at = ([r, y, az]) => [r * Math.sin(deg(az)), y, r * Math.cos(deg(az))];
+    return strut(material, at(a), at(b), width, width);
+}
+/** An open skirt: a tube seen from outside and from inside, so an engine under it shows from below. */
+export const skirt = (material, r, y0, y1, extra = {}) => [tube(material, r, y0, y1, extra), { kind: "lathe", material: "soot", segs: 32, under: true, only: "mesh", profile: [[r * 0.97, y1], [r * 0.97, y0]] }];
+/** A cone over an engine, off the axis: a fairing at the foot of a stage. */
+export const pod = (material, at, r0, y0, r1, y1, extra = {}) => ({ kind: "lathe", material, at, segs: 14, profile: [[r0, y0], [r1, y1]], ...extra });
+/** A fairing: straight from the joint, then a rounded nose, with the seam where its halves meet. */
+export function fairingShell(material, r, height, straight, blunt = 1.4, jointRadius = r) {
+    const shell = nose(material, r, straight, height, blunt);
+    const seam = (a) => shell.profile.map(([x, y]) => [(x * 1.005) * Math.sin(a), y, (x * 1.005) * Math.cos(a)]);
+    return [
+        { ...shell, profile: [[jointRadius, 0], ...shell.profile], rings: [straight] },
+        floor(jointRadius, 0),
+        { kind: "lines", weight: "feature", paths: [seam(deg(90)), seam(deg(-90))] },
+    ];
+}
+/** Legs folded against a hull, as dark ribs from the foot up. */
+export const foldedLegs = (material, r, azimuths, foot, top, width) => azimuths.map((az) => {
+    const f = radial(deg(az));
+    return strut(material, pointOf(f, r + 0.1, foot), pointOf(f, r + 0.1, top), width, 0.3, { plain: false });
+});
+/** Pieces turned round the Y axis by `turn` degrees, then moved along the ground. For putting a whole structure in its place on a map. A lathe's arc and lean are left as they are, so they are for pieces with neither. */
+export function moved(pieces, x, z, turn = 0) {
+    const c = Math.cos(deg(turn));
+    const s = Math.sin(deg(turn));
+    const spin = ([a, b, d]) => [a * c + d * s, b, -a * s + d * c];
+    const at = (p) => {
+        const [a, b, d] = spin(p);
+        return [a + x, b, d + z];
+    };
+    return pieces.map((piece) => {
+        if (piece.kind === "plate")
+            return { ...piece, frame: { o: at(piece.frame.o), u: spin(piece.frame.u), v: spin(piece.frame.v), w: spin(piece.frame.w) } };
+        if (piece.kind === "lines")
+            return { ...piece, paths: piece.paths.map((path) => path.map(at)) };
+        const [a0, d0] = piece.at ?? [0, 0];
+        const [a, , d] = at([a0, 0, d0]);
+        return { ...piece, at: [a, d] };
+    });
+}
+/** A box on the ground, `wide` by `deep` and turned `turn` degrees, from y0 to y1. */
+export function slab(material, x, z, wide, deep, turn, y0, y1, plain = true) {
+    const c = Math.cos(deg(turn));
+    const s = Math.sin(deg(turn));
+    return { kind: "plate", material, frame: { o: [x, (y0 + y1) / 2, z], u: [c, 0, s], v: [-s, 0, c], w: [0, 1, 0] }, outline: [[-wide / 2, -deep / 2], [wide / 2, -deep / 2], [wide / 2, deep / 2], [-wide / 2, deep / 2]], thickness: y1 - y0, plain };
+}
+/** A road on the ground, from point to point. */
+export const road = (material, points, width, y) => points.slice(1).map((b, i) => {
+    const a = points[i];
+    const dx = b[0] - a[0];
+    const dz = b[1] - a[1];
+    return slab(material, (a[0] + b[0]) / 2, (a[1] + b[1]) / 2, Math.hypot(dx, dz) + width, width, (Math.atan2(dz, dx) * 180) / Math.PI, y, y + 0.2);
+});

package/dist/model/landing.d.ts

@@ -0,0 +1,3 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const DRONESHIP_BUILDS: readonly StackBuild[];
+export declare const LANDING_ZONE_BUILDS: readonly StackBuild[];

package/dist/model/landing.js

@@ -0,0 +1,81 @@
+// A drone ship's deck, a landing pad, and a Falcon 9 first stage standing on them with its legs out. The deck's and the pad's sizes are sourced where the data says so; hull, equipment and legs are judged from photographs.
+import { blank } from "../data/types.js";
+import { deg } from "../framing.js";
+import { falconFirstStageBare, FALCON_DRAWS } from "./falcon.js";
+import { brace } from "./kit.js";
+const DECK_L = 91.44;
+const DECK_W = 51.82;
+const HULL_L = DECK_L * 1.18;
+const HULL_W = 30.5;
+const HULL_H = 6;
+const DECK_T = 0.8;
+const DECK_TOP = HULL_H + DECK_T;
+const PAD_R = 85.95 / 2;
+const PAD_T = 0.4;
+const FOOT = 9;
+const LEG_TOP = 10.5;
+const FLAT = (y) => ({ o: [0, y, 0], u: [1, 0, 0], v: [0, 0, 1], w: [0, 1, 0] });
+const box = (material, x0, x1, z0, z1, y0, y1, plain = true) => ({ kind: "plate", material, frame: FLAT((y0 + y1) / 2), outline: [[x0, z0], [x1, z0], [x1, z1], [x0, z1]], thickness: y1 - y0, plain });
+const disc = (material, r, r0, y) => ({ kind: "lathe", material, segs: 72, body: true, profile: [[r, y], [r0, y]] });
+function deck() {
+    const L = DECK_L / 2;
+    const W = DECK_W / 2;
+    const hull = HULL_L / 2;
+    const h = HULL_W / 2;
+    const out = [
+        box("dark", -hull, hull, -h, h, 0, HULL_H, false),
+        { ...box("fin", -L, L, -W, W, HULL_H, DECK_TOP, false), plain: false },
+        // the plain ring: no mark, no name
+        disc("white", 23, 21.8, DECK_TOP + 0.03),
+        // the deck's yellow edge
+        box("yellow", -L, L, W - 0.5, W, DECK_TOP, DECK_TOP + 0.05),
+        box("yellow", -L, L, -W, -W + 0.5, DECK_TOP, DECK_TOP + 0.05),
+    ];
+    // equipment at each end, on the hull; thrusters at the corners
+    for (const side of [1, -1]) {
+        const a = side * (L + 0.6);
+        const b = side * (hull - 0.6);
+        const [lo, hi] = a < b ? [a, b] : [b, a];
+        out.push(box("white", lo, hi, -h + 1, -h + 4, HULL_H, HULL_H + 3));
+        out.push(box("gold", lo, hi, -h + 5, -h + 8, HULL_H, HULL_H + 2.6));
+        out.push(box("white", lo, hi, h - 8, h - 5, HULL_H, HULL_H + 2.6));
+        out.push(box("blue", lo, hi, h - 4, h - 1, HULL_H, HULL_H + 3));
+        for (const z of [1, -1])
+            out.push(box("black", side * L - 3, side * L + 3, z * (h + 0.1), z * (h + 3.2), 1, HULL_H - 0.6));
+    }
+    return out;
+}
+function pad() {
+    return [
+        { kind: "lathe", material: "concrete", segs: 72, body: true, outline: true, profile: [[PAD_R, 0], [PAD_R, PAD_T], [0.001, PAD_T]], rings: [PAD_T] },
+        disc("white", PAD_R * 0.62, PAD_R * 0.6, PAD_T + 0.03),
+    ];
+}
+function landed() {
+    const r = FALCON_DRAWS["block-5"].first.radius;
+    const out = falconFirstStageBare("block-5");
+    for (const az of [45, 135, 225, 315]) {
+        // a leg down from its hinge, a pusher from high on the hull, and a foot
+        out.push(brace("black", [r, 1, az], [FOOT, 0.4, az], 0.55));
+        out.push(brace("black", [r + 0.05, LEG_TOP, az], [FOOT, 0.5, az], 0.28));
+        const a = deg(az);
+        out.push(box("dark", FOOT * Math.sin(a) - 0.7, FOOT * Math.sin(a) + 0.7, FOOT * Math.cos(a) - 0.7, FOOT * Math.cos(a) + 0.7, 0, 0.2));
+    }
+    return out;
+}
+const LANDED_NAME = "First stage, Falcon 9 Block 5, landed with its legs out";
+const NONE = blank("No source read here gives it.");
+const standing = (y) => ({ slot: "landed", kind: "first-stage", name: LANDED_NAME, height: FALCON_DRAWS["block-5"].first.height, diameter: FOOT * 2, place: { x: 0, z: 0, y }, sourcedDiameter: NONE, pieces: landed });
+const SHIP_FROM = "This package's code. Its deck's size is the first barge's, in its article; hull, equipment and legs are judged from photographs. No name, mark or logo is drawn.";
+export const DRONESHIP_BUILDS = ["ocisly", "jrti", "asog"].map((variant) => ({
+    rocket: "droneship",
+    variant,
+    drawnFrom: SHIP_FROM,
+    parts: [{ slot: "deck", kind: "deck", name: "Deck and hull", height: DECK_TOP, diameter: DECK_L, sourcedDiameter: NONE, pieces: deck }, standing(DECK_TOP)],
+}));
+export const LANDING_ZONE_BUILDS = ["lz-1", "lz-4"].map((variant) => ({
+    rocket: "landing-zone",
+    variant,
+    drawnFrom: "This package's code, a plain round pad at the size the source gives for the Cape's; the stage's legs are judged from photographs. No mark is drawn.",
+    parts: [{ slot: "pad", kind: "deck", name: "Landing pad", height: PAD_T, diameter: PAD_R * 2, ...(variant === "lz-4" ? { sourcedDiameter: NONE } : {}), pieces: pad }, standing(PAD_T)],
+}));

package/dist/model/lunarmodule.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const LUNAR_MODULE_BUILDS: readonly StackBuild[];

package/dist/model/lunarmodule.js

@@ -0,0 +1,43 @@
+// The lunar module in plain shapes, for the line looks: its height and widths are sourced, and where its legs and tanks stand is measured from NASA's model at that scale. The painted look is NASA's model.
+import { LM_ASCENT_WIDTH, LM_WIDTH } from "../data/lunarmodule.js";
+import { deg } from "../framing.js";
+import { merlin } from "./falcon.js";
+import { brace, taper, tube } from "./kit.js";
+const WHOLE = 7.04;
+const SCALE = WHOLE / 5.02;
+const DESCENT = 3.96;
+const ASCENT_AT = (2.1 - 0.1) * SCALE;
+const R = 4.22 / 2;
+function descent() {
+    const out = [tube("gold", R, 1.36, 3.25, { segs: 8, rings: [1.38, 3.23] }), { kind: "lathe", material: "soot", segs: 8, under: true, profile: [[0, 1.36], [R, 1.36]] }, ...merlin([0, 0], 0.45, 0.75, 1)];
+    for (const az of [0, 90, 180, 270]) {
+        out.push(brace("gold", [4.2, 0.35, az], [2.1, 2.9, az], 0.14), brace("engine-pale", [3, 1.3, az], [2.1, 1.45, az + 28], 0.07), brace("engine-pale", [3, 1.3, az], [2.1, 1.45, az - 28], 0.07));
+        out.push({ kind: "lathe", material: "gold", at: [4.3 * Math.sin(deg(az)), 4.3 * Math.cos(deg(az))], segs: 12, outline: true, profile: [[0.001, 0], [0.42, 0.04], [0.42, 0.1], [0.001, 0.28]] });
+    }
+    for (const az of [45, 135, 225, 315])
+        out.push(brace("engine-pale", [1.9, 3.25, az], [1.9, DESCENT, az], 0.1));
+    return out;
+}
+function ascent() {
+    const r = (LM_ASCENT_WIDTH.value ?? 0) / 2;
+    const out = [tube("engine-pale", r * 0.92, 0.7, 2.9, { segs: 8, rings: [0.72] }), taper("engine-pale", r * 0.92, 2.9, r * 0.55, 3.35, { segs: 8 }), { kind: "lathe", material: "dark", segs: 8, under: true, profile: [[0, 0.7], [r * 0.92, 0.7]] }];
+    for (const az of [45, 135, 225, 315]) {
+        const a = deg(az);
+        out.push({ kind: "lathe", material: "gold", at: [r * 1.05 * Math.sin(a), r * 1.05 * Math.cos(a)], segs: 8, profile: [[0.08, 1.8], [0.08, 2.25]] });
+    }
+    // the dish and its mast
+    out.push({ kind: "lathe", material: "white", at: [0, -0.6], segs: 14, outline: true, profile: [[0.001, 3.55], [0.45, 3.9], [0.48, 4]] }, brace("engine-pale", [0.6, 3.2, 180], [0.6, 3.6, 180], 0.06), brace("engine-pale", [0.9, 3.2, 90], [0.9, 4.2, 90], 0.03));
+    return out;
+}
+const FROM = "NASA's model for the painted look. This package's plain shapes for the two line looks, from the sourced height and widths; where its parts stand is measured from NASA's model.";
+export const LUNAR_MODULE_BUILDS = [
+    {
+        rocket: "lunar-module",
+        variant: "lunar-module",
+        drawnFrom: FROM,
+        parts: [
+            { slot: "descent", kind: "spacecraft", name: "Descent stage, Apollo lunar module", height: DESCENT, diameter: LM_WIDTH.value ?? 0, sourcedDiameter: LM_WIDTH, painted: { file: "lunar-module-descent.glb", credit: "nasa-lunar-module" }, pieces: descent },
+            { slot: "ascent", kind: "spacecraft", name: "Ascent stage, Apollo lunar module", height: WHOLE - ASCENT_AT, diameter: LM_ASCENT_WIDTH.value ?? 0, place: { x: 0, z: 0, y: ASCENT_AT }, sourcedDiameter: LM_ASCENT_WIDTH, painted: { file: "lunar-module-ascent.glb", credit: "nasa-lunar-module" }, pieces: ascent },
+        ],
+    },
+];

package/dist/model/materials.d.ts

@@ -1,4 +1,15 @@
 import type { FillName } from "../looks.ts";
+/**
+ * One material: its colour, how metal and how rough it is in a 3D view, and the fill group it takes in a drawing.
+ *
+ * @example
+ * ```ts
+ * import { MATERIALS, type MaterialSpec } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const steel: MaterialSpec = MATERIALS.steel;
+ * console.log(steel.color, steel.fill);
+ * ```
+ */
 export interface MaterialSpec {
     color: string;
     metal: number;
@@ -6,6 +17,16 @@ export interface MaterialSpec {
     /** The fill it takes in a drawing. */
     fill: FillName;
 }
+/**
+ * Every material the meshes use, by name. One naming scheme serves every source.
+ *
+ * @example
+ * ```ts
+ * import { MATERIALS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(MATERIALS).length > 5);
+ * ```
+ */
 export declare const MATERIALS: {
     readonly steel: {
         readonly color: "#c3c7cb";
@@ -109,5 +130,58 @@ export declare const MATERIALS: {
         readonly rough: 0.5;
         readonly fill: "metal";
     };
+    readonly foam: {
+        readonly color: "#a9592a";
+        readonly metal: 0;
+        readonly rough: 0.8;
+        readonly fill: "foam";
+    };
+    readonly yellow: {
+        readonly color: "#c9a227";
+        readonly metal: 0.1;
+        readonly rough: 0.6;
+        readonly fill: "metal";
+    };
+    readonly concrete: {
+        readonly color: "#8b8d8a";
+        readonly metal: 0;
+        readonly rough: 0.9;
+        readonly fill: "metal";
+    };
+    readonly ground: {
+        readonly color: "#4d5a41";
+        readonly metal: 0;
+        readonly rough: 1;
+        readonly fill: "dark";
+    };
+    readonly sand: {
+        readonly color: "#c3b58c";
+        readonly metal: 0;
+        readonly rough: 1;
+        readonly fill: "white";
+    };
+    readonly water: {
+        readonly color: "#27475e";
+        readonly metal: 0.1;
+        readonly rough: 0.4;
+        readonly fill: "dark";
+    };
+    readonly red: {
+        readonly color: "#a4322b";
+        readonly metal: 0.1;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
 };
+/**
+ * The name of one material in `MATERIALS`.
+ *
+ * @example
+ * ```ts
+ * import type { MaterialName } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * const name: MaterialName = "steel";
+ * console.log(name);
+ * ```
+ */
 export type MaterialName = keyof typeof MATERIALS;

package/dist/model/materials.js

@@ -1,3 +1,13 @@
+/**
+ * Every material the meshes use, by name. One naming scheme serves every source.
+ *
+ * @example
+ * ```ts
+ * import { MATERIALS } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(Object.keys(MATERIALS).length > 5);
+ * ```
+ */
 export const MATERIALS = {
     steel: { color: "#c3c7cb", metal: 1, rough: 0.3, fill: "hull" },
     tile: { color: "#101114", metal: 0, rough: 0.62, fill: "tile" },
@@ -16,4 +26,11 @@ export const MATERIALS = {
     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" },
+    foam: { color: "#a9592a", metal: 0, rough: 0.8, fill: "foam" },
+    yellow: { color: "#c9a227", metal: 0.1, rough: 0.6, fill: "metal" },
+    concrete: { color: "#8b8d8a", metal: 0, rough: 0.9, fill: "metal" },
+    ground: { color: "#4d5a41", metal: 0, rough: 1, fill: "dark" },
+    sand: { color: "#c3b58c", metal: 0, rough: 1, fill: "white" },
+    water: { color: "#27475e", metal: 0.1, rough: 0.4, fill: "dark" },
+    red: { color: "#a4322b", metal: 0.1, rough: 0.5, fill: "metal" },
 };

package/dist/model/mercury.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const MERCURY_BUILDS: readonly StackBuild[];

package/dist/model/mercury.js

@@ -0,0 +1,19 @@
+// The Mercury spacecraft in a plain shape, for the line looks: its length and width are sourced, and its outline is measured from NASA's model at those scales. The painted look is NASA's model.
+import { MERCURY_WIDE } from "../data/mercury.js";
+const H = 3.3;
+const R = (MERCURY_WIDE.value ?? 0) / 2;
+const capsule = () => [
+    { kind: "lathe", material: "engine-metal", segs: 28, body: true, outline: true, profile: [[0.24, 0], [0.44, 0.12], [0.5, 0.42]], rings: [0.42] },
+    { kind: "lathe", material: "soot", segs: 36, body: true, outline: true, profile: [[0.5, 0.42], [R, 0.55], [R * 0.98, 0.6]] },
+    { kind: "lathe", material: "tile-plain", segs: 36, body: true, outline: true, profile: [[R * 0.98, 0.6], [0.35, 2.15]], welds: [1.1, 1.6] },
+    { kind: "lathe", material: "engine-metal", segs: 28, body: true, outline: true, profile: [[0.35, 2.15], [0.35, 2.75]], rings: [2.17, 2.73] },
+    { kind: "lathe", material: "engine-pale", segs: 28, body: true, outline: true, profile: [[0.35, 2.75], [0.29, 2.95], [0.26, H]], rings: [2.95] },
+];
+export const MERCURY_BUILDS = [
+    {
+        rocket: "mercury",
+        variant: "friendship-7",
+        drawnFrom: "NASA's model for the painted look, with its colours judged from photographs. This package's plain shape for the two line looks, from the sourced length and width. No name or flag is drawn.",
+        parts: [{ slot: "capsule", kind: "capsule", name: "Mercury spacecraft, Friendship 7", height: H, diameter: R * 2, sourcedDiameter: MERCURY_WIDE, painted: { file: "mercury-capsule.glb", credit: "nasa-friendship-7" }, pieces: capsule }],
+    },
+];

package/dist/model/newglenn.d.ts

@@ -0,0 +1,2 @@
+import type { StackBuild } from "./stacks.ts";
+export declare const NEW_GLENN_BUILDS: readonly StackBuild[];

package/dist/model/newglenn.js

@@ -0,0 +1,43 @@
+// New Glenn from a table of numbers: the whole, the two stages and the width are sourced. The fairing is what the whole leaves; the legs, the strakes and the paint are judged from photographs.
+import { deg } from "../framing.js";
+import { engineRing, fairingShell, fins, floor, foldedLegs, skirt, tube } from "./kit.js";
+import { merlin } from "./falcon.js";
+const R = 3.5;
+const FIRST = 57.5;
+const SECOND = 23.4;
+const FAIRING = 98 - FIRST - SECOND;
+function firstStage() {
+    const foot = 3;
+    const skirtFrom = FIRST - 8;
+    return [
+        tube("white", R, foot, skirtFrom, { rings: [foot + 0.02, 17, skirtFrom - 0.02], welds: [10, 24, 31, 38] }),
+        floor(R, foot),
+        ...skirt("black", R, skirtFrom, FIRST, { rings: [FIRST - 0.02] }),
+        ...merlin([0, 0], 0, 0.95, 3.6),
+        ...engineRing(6, 2.3, 0, 0.95, 3.6, 30),
+        ...foldedLegs("black", R, [30, 90, 150, 210, 270, 330], foot + 0.4, foot + 11, 0.7),
+        ...fins("black", R, [90, 270], [[0, foot + 1], [1.3, foot + 1], [1.3, foot + 3.2], [0, foot + 7]], 0.25),
+        ...[45, 135, 225, 315].map((az) => ({ kind: "plate", material: "fin-dark", frame: { o: [R * Math.sin(deg(az)), skirtFrom + 2, R * Math.cos(deg(az))], u: [Math.sin(deg(az)), 0, Math.cos(deg(az))], v: [0, 1, 0], w: [Math.cos(deg(az)), 0, -Math.sin(deg(az))] }, outline: [[0, 0], [1, 0], [1, 2.6], [0, 2.6]], thickness: 1.9, plain: false })),
+    ];
+}
+function secondStage() {
+    return [
+        tube("white", R, 0, SECOND, { rings: [0.02, SECOND - 0.02], welds: [SECOND * 0.4, SECOND * 0.7] }),
+        floor(R, 0),
+        { kind: "lathe", material: "soot", segs: 30, under: true, only: "mesh", profile: [[0, 0.1], [R * 0.95, 0.1]] },
+        ...merlin([1.5, 0], -0.05, 0.9, 2.6).map((piece) => ({ ...piece, only: "mesh" })),
+        ...merlin([-1.5, 0], -0.05, 0.9, 2.6).map((piece) => ({ ...piece, only: "mesh" })),
+    ];
+}
+export const NEW_GLENN_BUILDS = [
+    {
+        rocket: "new-glenn",
+        variant: "7x2",
+        drawnFrom: "This package's code, from the sourced whole, stages and width; the fairing is what the whole leaves, and the legs, strakes and paint are judged from photographs. No licensed model is used, and no name or mark is drawn.",
+        parts: [
+            { slot: "first-stage", kind: "first-stage", name: "First stage, New Glenn", height: FIRST, diameter: R * 2, top: [FIRST, R * 2], pieces: firstStage },
+            { slot: "second-stage", kind: "second-stage", name: "Second stage, New Glenn", height: SECOND, diameter: R * 2, bottom: [0, R * 2], top: [SECOND, R * 2], pieces: secondStage },
+            { slot: "fairing", kind: "fairing", name: "Fairing, New Glenn", height: FAIRING, diameter: R * 2, bottom: [0, R * 2], pieces: () => fairingShell("white", R, FAIRING, FAIRING * 0.44, 1.35) },
+        ],
+    },
+];

package/dist/model/pieces.d.ts

@@ -13,6 +13,8 @@ export interface Lathe {
     material: MaterialName;
     profile: readonly (readonly [number, number])[];
     at?: readonly [number, number];
+    /** Its axis leans: this far along x and z for each metre up. */
+    lean?: 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];

package/dist/model/pieces.js

@@ -81,7 +81,7 @@ function latheFaces(mesh, piece) {
                 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.positions.push(cx + r * sa + (piece.lean?.[0] ?? 0) * y, y, cz + r * ca + (piece.lean?.[1] ?? 0) * y);
                 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
@@ -115,7 +115,7 @@ export function ringPath(piece, y, lift = 0.012) {
     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)]);
+        path.push([cx + r * Math.sin(a) + (piece.lean?.[0] ?? 0) * y, y, cz + r * Math.cos(a) + (piece.lean?.[1] ?? 0) * y]);
     }
     return path;
 }

package/dist/model/registry.d.ts

@@ -4,5 +4,27 @@ export interface PartEntry {
     record: PartRecord;
     pieces: () => Piece[];
 }
+/**
+ * Every part of every rocket, each with its record: its real size in metres, the joints it mates at, and where its shape came from.
+ *
+ * @example
+ * ```ts
+ * import { PART_ENTRIES } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(PART_ENTRIES.length, PART_ENTRIES[0]?.record.name);
+ * ```
+ */
 export declare const PART_ENTRIES: readonly PartEntry[];
+/**
+ * Finds a part by its id.
+ *
+ * @param id A part's id.
+ * @returns The part's entry, or undefined for an id that is not a part.
+ * @example
+ * ```ts
+ * import { partEntry } from "@johnmorrisdotca/uchusen-rockets";
+ *
+ * console.log(partEntry("raptor-vacuum")?.record.height, partEntry("nonsense"));
+ * ```
+ */
 export declare const partEntry: (id: string) => PartEntry | undefined;