@johnmorrisdotca/uchusen-rockets 0.0.0-stage → 0.1.0

package/dist/build/glb.js

@@ -0,0 +1,157 @@
+// The writer: a rocket's parts into one small .glb, in Node or a browser, with no dependency. One node per part, one primitive per material, plus the lines of the line looks as line primitives; positions
+// and normals packed into 16 bits (KHR_mesh_quantization). The same parts always give the same bytes: no clock, no random, a fixed order.
+import { MATERIALS } from "../model/materials.js";
+const SHORT = 5122;
+const USHORT = 5123;
+const UINT = 5125;
+const ARRAY_BUFFER = 34962;
+const ELEMENT_BUFFER = 34963;
+const LINES = 1;
+const round6 = (v) => Math.round(v * 1e6) / 1e6;
+const toLinear = (c) => (c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+const linearOf = (hex) => [1, 3, 5].map((i) => round6(toLinear(Number.parseInt(hex.slice(i, i + 2), 16) / 255)));
+export function toGlb(parts) {
+    const chunks = [];
+    let offset = 0;
+    const bufferViews = [];
+    const accessors = [];
+    const put = (data, target, byteStride) => {
+        const pad = (4 - (offset % 4)) % 4;
+        if (pad) {
+            chunks.push(new Uint8Array(pad));
+            offset += pad;
+        }
+        chunks.push(data);
+        bufferViews.push({ buffer: 0, byteOffset: offset, byteLength: data.byteLength, target, ...(byteStride ? { byteStride } : {}) });
+        offset += data.byteLength;
+        return bufferViews.length - 1;
+    };
+    const accessor = (a) => accessors.push(a) - 1;
+    const materials = [];
+    const materialIndex = new Map();
+    const useMaterial = (name) => {
+        const known = materialIndex.get(name);
+        if (known !== undefined)
+            return known;
+        const spec = name.startsWith("line-") ? { color: "#8fa1b8", metal: 0, rough: 1 } : MATERIALS[name];
+        materials.push({ name, pbrMetallicRoughness: { baseColorFactor: [...linearOf(spec.color), 1], metallicFactor: spec.metal, roughnessFactor: spec.rough } });
+        materialIndex.set(name, materials.length - 1);
+        return materials.length - 1;
+    };
+    const indexAccessor = (list, count) => {
+        const wide = count >= 65536;
+        const data = wide ? Uint32Array.from(list) : Uint16Array.from(list);
+        return accessor({ bufferView: put(new Uint8Array(data.buffer), ELEMENT_BUFFER), componentType: wide ? UINT : USHORT, count: list.length, type: "SCALAR" });
+    };
+    let triangles = 0;
+    const meshes = [];
+    const nodes = [];
+    const roots = [];
+    for (const part of parts) {
+        const { mesh } = part;
+        const faces = [...mesh.faces];
+        // the packing's middle and half-size, over all of the part's points
+        const lo = [Infinity, Infinity, Infinity];
+        const hi = [-Infinity, -Infinity, -Infinity];
+        const sweep = (positions) => {
+            for (let i = 0; i < positions.length; i += 3)
+                for (let c = 0; c < 3; c++) {
+                    if (positions[i + c] < lo[c])
+                        lo[c] = positions[i + c];
+                    if (positions[i + c] > hi[c])
+                        hi[c] = positions[i + c];
+                }
+        };
+        for (const [, b] of faces)
+            sweep(b.positions);
+        sweep(mesh.feature.positions);
+        sweep(mesh.weld.positions);
+        const q = [0, 1, 2].map((c) => (lo[c] + hi[c]) / 2);
+        const half = Math.max(1e-3, ...[0, 1, 2].map((c) => (hi[c] - lo[c]) / 2));
+        const packPositions = (positions) => {
+            const count = positions.length / 3;
+            const out = new Int16Array(count * 4);
+            const min = [32767, 32767, 32767];
+            const max = [-32767, -32767, -32767];
+            for (let i = 0; i < count; i++)
+                for (let c = 0; c < 3; c++) {
+                    const v = Math.round(((positions[i * 3 + c] - q[c]) / half) * 32767);
+                    out[i * 4 + c] = v;
+                    if (v < min[c])
+                        min[c] = v;
+                    if (v > max[c])
+                        max[c] = v;
+                }
+            return accessor({ bufferView: put(new Uint8Array(out.buffer), ARRAY_BUFFER, 8), componentType: SHORT, count, type: "VEC3", normalized: true, min, max });
+        };
+        const primitives = [];
+        for (const [name, b] of faces) {
+            const count = b.positions.length / 3;
+            const normal = new Int16Array(count * 4);
+            for (let i = 0; i < count; i++)
+                for (let c = 0; c < 3; c++)
+                    normal[i * 4 + c] = Math.round(b.normals[i * 3 + c] * 32767);
+            const attributes = {
+                POSITION: packPositions(b.positions),
+                NORMAL: accessor({ bufferView: put(new Uint8Array(normal.buffer), ARRAY_BUFFER, 8), componentType: SHORT, count, type: "VEC3", normalized: true }),
+            };
+            if (b.hasUv) {
+                const uv = new Uint16Array(count * 2);
+                for (let i = 0; i < count * 2; i++)
+                    uv[i] = Math.round(Math.min(1, Math.max(0, b.uvs[i])) * 65535);
+                attributes.TEXCOORD_0 = accessor({ bufferView: put(new Uint8Array(uv.buffer), ARRAY_BUFFER, 4), componentType: USHORT, count, type: "VEC2", normalized: true });
+            }
+            triangles += b.indices.length / 3;
+            primitives.push({ attributes, indices: indexAccessor(b.indices, count), material: useMaterial(name) });
+        }
+        for (const [name, lines] of [
+            ["line-feature", mesh.feature],
+            ["line-weld", mesh.weld],
+        ]) {
+            if (lines.indices.length === 0)
+                continue;
+            primitives.push({ attributes: { POSITION: packPositions(lines.positions) }, indices: indexAccessor(lines.indices, lines.positions.length / 3), material: useMaterial(name), mode: LINES });
+        }
+        meshes.push({ name: part.name, primitives });
+        // a holder that the viewer moves, and the packed mesh under it
+        nodes.push({ name: `${part.name}-mesh`, mesh: meshes.length - 1, translation: q.map(round6), scale: [round6(half), round6(half), round6(half)] });
+        const child = nodes.length - 1;
+        nodes.push({ name: part.name, children: [child], translation: part.at.map(round6) });
+        roots.push(nodes.length - 1);
+    }
+    const json = {
+        asset: { version: "2.0", generator: "uchusen-rockets" },
+        extensionsUsed: ["KHR_mesh_quantization"],
+        extensionsRequired: ["KHR_mesh_quantization"],
+        scene: 0,
+        scenes: [{ name: "rocket", nodes: roots }],
+        nodes,
+        meshes,
+        materials,
+        accessors,
+        bufferViews,
+        buffers: [{ byteLength: offset }],
+    };
+    const text = new TextEncoder().encode(JSON.stringify(json));
+    const jsonPad = (4 - (text.byteLength % 4)) % 4;
+    const binPad = (4 - (offset % 4)) % 4;
+    const total = 12 + 8 + text.byteLength + jsonPad + 8 + offset + binPad;
+    const bytes = new Uint8Array(total);
+    const view = new DataView(bytes.buffer);
+    view.setUint32(0, 0x46546c67, true);
+    view.setUint32(4, 2, true);
+    view.setUint32(8, total, true);
+    view.setUint32(12, text.byteLength + jsonPad, true);
+    view.setUint32(16, 0x4e4f534a, true);
+    bytes.set(text, 20);
+    bytes.fill(0x20, 20 + text.byteLength, 20 + text.byteLength + jsonPad);
+    let at = 20 + text.byteLength + jsonPad;
+    view.setUint32(at, offset + binPad, true);
+    view.setUint32(at + 4, 0x004e4942, true);
+    at += 8;
+    for (const chunk of chunks) {
+        bytes.set(chunk, at);
+        at += chunk.byteLength;
+    }
+    return { bytes, triangles };
+}

package/dist/build/index.d.ts

@@ -0,0 +1,59 @@
+import { type Description, type FitReport } from "../fit.ts";
+import { type Angle, type Vec3, type ViewName } from "../framing.ts";
+import { type LookName } from "../looks.ts";
+import { type PartMesh, type Bounds, type Piece } from "../model/pieces.ts";
+import type { PartRecord } from "../parts.ts";
+import { type Glb, toGlb } from "./glb.ts";
+/** Raised when a description does not fit: its report says why. */
+export declare class FitError extends Error {
+    readonly report: FitReport;
+    constructor(report: FitReport);
+}
+export interface BuiltPart {
+    slot: string;
+    record: PartRecord;
+    pieces: readonly Piece[];
+    mesh: PartMesh;
+    bounds: Bounds;
+}
+export interface SvgOptions {
+    look?: LookName;
+    view?: ViewName | Angle;
+    show?: string;
+}
+export interface Built {
+    report: FitReport;
+    parts: readonly BuiltPart[];
+    /** What can be shown: together, apart and each part. */
+    shows: readonly string[];
+    /** The bounds of a choice of what to show, in metres. */
+    boundsOf(show?: string): Bounds;
+    /** Where each part stands for a choice of what to show. */
+    placesOf(show?: string): {
+        slot: string;
+        at: Vec3;
+        shown: boolean;
+    }[];
+    /** The .glb file's bytes: every part stacked, each its own node to move. */
+    glb(): Glb;
+    /** The drawing, in a look, from an angle. */
+    svg(options?: SvgOptions): string;
+}
+/** What a drawing draws of a part: in a stack, what nests inside the part below is out of sight. */
+export declare function drawnPieces(part: {
+    record: PartRecord;
+    pieces: readonly Piece[];
+}, together: boolean): readonly Piece[];
+/** A rocket from a description. Throws FitError when it does not go together. */
+export declare function build(description: Description): Built;
+/** One part on its own, by its id. */
+export declare function buildPart(id: string): {
+    record: PartRecord;
+    bounds: Bounds;
+    glb: () => Glb;
+    svg: (options?: SvgOptions) => string;
+};
+export { toGlb };
+export type { Glb };
+export { COMPARES, lineupSvg } from "./lineup.ts";
+export type { CompareId, LineupItem, LineupOptions } from "./lineup.ts";

package/dist/build/index.js

@@ -0,0 +1,118 @@
+// The builder: one description into one mesh and one drawing. Works in Node and in a browser, with no dependency: the geometry here is this package's own.
+import { check } from "../fit.js";
+import { cleanView, DEFAULT_VIEW, PICTURE_H, PICTURE_W, VIEWS } from "../framing.js";
+import { cleanShow, placesFor, showsOf } from "../layout.js";
+import { DEFAULT_LOOK } from "../looks.js";
+import { boundsOf, meshOf } from "../model/pieces.js";
+import { partEntry } from "../model/registry.js";
+import { defsOf, drawPart, perspective } from "../draw/svg.js";
+import { toGlb } from "./glb.js";
+/** Raised when a description does not fit: its report says why. */
+export class FitError extends Error {
+    report;
+    constructor(report) {
+        super(report.issues.filter((issue) => issue.level === "error").map((issue) => issue.message).join(" "));
+        this.name = "FitError";
+        this.report = report;
+    }
+}
+const memo = new Map();
+function made(id) {
+    const known = memo.get(id);
+    if (known)
+        return known;
+    const entry = partEntry(id);
+    if (!entry)
+        throw new Error(`There is no part "${id}".`);
+    const pieces = entry.pieces();
+    const mesh = meshOf(pieces);
+    const result = { pieces, mesh, bounds: boundsOf(mesh) };
+    memo.set(id, result);
+    return result;
+}
+const xmlText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function wrap(inner, look, width = PICTURE_W, height = PICTURE_H, label) {
+    const halo = look !== "painted" ? `<ellipse cx="${width / 2}" cy="${height / 2}" rx="${width / 2}" ry="${height / 2}" fill="url(#halo)"/>` : "";
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" width="${width}" height="${height}" role="img"${label ? ` aria-label="${xmlText(label)}"` : ""}>${defsOf(look)}${halo}${inner}</svg>`;
+}
+/** The widest a part reaches from its own axis. */
+const widthOf = (id) => {
+    const { min, max } = made(id).bounds;
+    return Math.max(Math.abs(min[0]), Math.abs(max[0]), Math.abs(min[2]), Math.abs(max[2]));
+};
+function assembled(report) {
+    const parts = report.parts.map(({ slot, part }) => {
+        const { pieces, mesh, bounds } = made(part.id);
+        return { slot, record: part, pieces, mesh, bounds };
+    });
+    const slots = parts.map((part) => part.slot);
+    const placesOf = (show) => placesFor(report.parts, cleanShow(show, slots), (part) => widthOf(part.id));
+    const boundsOfShow = (show) => {
+        const min = [Infinity, Infinity, Infinity];
+        const max = [-Infinity, -Infinity, -Infinity];
+        for (const place of placesOf(show)) {
+            if (!place.shown)
+                continue;
+            const { bounds } = parts.find((part) => part.slot === place.slot);
+            for (let c = 0; c < 3; c++) {
+                min[c] = Math.min(min[c], bounds.min[c] + place.at[c]);
+                max[c] = Math.max(max[c], bounds.max[c] + place.at[c]);
+            }
+        }
+        return { min, max };
+    };
+    return {
+        report,
+        parts,
+        shows: showsOf(slots),
+        boundsOf: boundsOfShow,
+        placesOf,
+        glb: () => toGlb(parts.map((part) => ({ name: part.slot, mesh: part.mesh, at: placesOf("together").find((place) => place.slot === part.slot)?.at ?? [0, 0, 0] }))),
+        svg: ({ look = DEFAULT_LOOK, view = DEFAULT_VIEW, show } = {}) => {
+            const angle = typeof view === "string" ? VIEWS[cleanView(view)] : view;
+            const places = placesOf(show).filter((place) => place.shown);
+            const cam = perspective(boundsOfShow(show), angle);
+            const ordered = places
+                .map((place) => {
+                const part = parts.find((p) => p.slot === place.slot);
+                const middle = [place.at[0], place.at[1] + part.record.height / 2, place.at[2]];
+                return { place, part, depth: cam.depth(middle) };
+            })
+                .sort((a, b) => b.depth - a.depth);
+            const together = !show || show === "together";
+            return wrap(ordered.map(({ place, part }) => drawPart(drawnPieces(part, together), place.at, cam, look)).join(""), look, PICTURE_W, PICTURE_H, report.label);
+        },
+    };
+}
+/** What a drawing draws of a part: in a stack, what nests inside the part below is out of sight. */
+export function drawnPieces(part, together) {
+    const joint = part.record.joints.bottom?.y ?? 0;
+    if (!together || joint <= 0)
+        return part.pieces;
+    return part.pieces.filter((piece) => !(piece.kind === "lathe" && piece.under && Math.max(...piece.profile.map(([, y]) => y)) <= joint + 0.01));
+}
+/** A rocket from a description. Throws FitError when it does not go together. */
+export function build(description) {
+    const report = check(description);
+    if (!report.ok)
+        throw new FitError(report);
+    return assembled(report);
+}
+/** One part on its own, by its id. */
+export function buildPart(id) {
+    const entry = partEntry(id);
+    if (!entry)
+        throw new Error(`There is no part "${id}".`);
+    const { pieces, mesh, bounds } = made(id);
+    return {
+        record: entry.record,
+        bounds,
+        glb: () => toGlb([{ name: entry.record.id, mesh, at: [0, 0, 0] }]),
+        svg: ({ look = DEFAULT_LOOK, view = DEFAULT_VIEW } = {}) => {
+            const angle = typeof view === "string" ? VIEWS[cleanView(view)] : view;
+            return wrap(drawPart(pieces, [0, 0, 0], perspective(bounds, angle), look, 1), look, PICTURE_W, PICTURE_H, entry.record.name);
+        },
+    };
+}
+export { toGlb };
+export { COMPARES, lineupSvg } from "./lineup.js";

package/dist/build/lineup.d.ts

@@ -0,0 +1,40 @@
+import { type ViewName } from "../framing.ts";
+import { type LookName } from "../looks.ts";
+/** Comparison shapes: plain round sizes, for scale, not facts about anything. */
+export declare const COMPARES: {
+    readonly person: {
+        readonly name: "A person, 1.8 m";
+        readonly height: 1.8;
+        readonly width: 0.5;
+    };
+    readonly building: {
+        readonly name: "A ten-storey building, 30 m";
+        readonly height: 30;
+        readonly width: 18;
+    };
+};
+export type CompareId = keyof typeof COMPARES;
+export interface LineupItem {
+    /** "starship:v3" or a comparison's name. */
+    key: string;
+    label: string;
+    height: number;
+}
+export interface LineupOptions {
+    /** "starship:v1,starship:v3,person,building". */
+    items: readonly string[];
+    /** Pixels a metre. */
+    unit: number;
+    look?: LookName;
+    view?: ViewName;
+    show?: string;
+    ruler?: boolean;
+    labels?: boolean;
+}
+/** The whole picture as SVG text. Unknown items are left out. */
+export declare function lineupSvg(options: LineupOptions): {
+    svg: string;
+    items: LineupItem[];
+    width: number;
+    height: number;
+};

package/dist/build/lineup.js

@@ -0,0 +1,97 @@
+// Rockets and what to compare them with, side by side on one baseline at one scale, as one drawing with a ruler. Orthographic, so a metre is the same on every one. Pure.
+import { build, drawnPieces } from "./index.js";
+import { check } from "../fit.js";
+import { axesOf, cleanView, directionOf, VIEWS } from "../framing.js";
+import { DEFAULT_LOOK, LOOKS } from "../looks.js";
+import { defsOf, drawPart, orthographic } from "../draw/svg.js";
+import { variantOf } from "../rockets.js";
+/** Comparison shapes: plain round sizes, for scale, not facts about anything. */
+export const COMPARES = {
+    person: { name: "A person, 1.8 m", height: 1.8, width: 0.5 },
+    building: { name: "A ten-storey building, 30 m", height: 30, width: 18 },
+};
+const xmlText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const n = (v) => (Math.round(v * 10) / 10).toString();
+function comparison(id, x, base, unit, line, fill) {
+    const { height, width } = COMPARES[id];
+    const h = height * unit;
+    const w = width * unit;
+    if (id === "person") {
+        const head = Math.max(0.6, h * 0.11);
+        return `<circle cx="${n(x + w / 2)}" cy="${n(base - h + head)}" r="${n(head)}" fill="${fill}" stroke="${line}" stroke-width=".6"/><path d="M${n(x + w * 0.12)} ${n(base)}L${n(x + w * 0.2)} ${n(base - h * 0.76)}H${n(x + w * 0.8)}L${n(x + w * 0.88)} ${n(base)}Z" fill="${fill}" stroke="${line}" stroke-width=".6"/>`;
+    }
+    let floors = "";
+    for (let i = 1; i < 10; i++)
+        floors += `M${n(x)} ${n(base - (h * i) / 10)}h${n(w)}`;
+    return `<rect x="${n(x)}" y="${n(base - h)}" width="${n(w)}" height="${n(h)}" fill="${fill}" stroke="${line}" stroke-width=".9"/><path d="${floors}" stroke="${line}" stroke-width=".35" opacity=".6"/>`;
+}
+/** The whole picture as SVG text. Unknown items are left out. */
+export function lineupSvg(options) {
+    const { items, unit, look = DEFAULT_LOOK, view = "front", ruler = true, labels = true } = options;
+    const angle = VIEWS[cleanView(view)];
+    const known = [];
+    for (const raw of items) {
+        const key = raw.trim();
+        if (Object.hasOwn(COMPARES, key)) {
+            const c = COMPARES[key];
+            known.push({ key, compare: key, height: c.height, width: c.width, label: c.name });
+            continue;
+        }
+        const [rocket, variant] = key.split(":");
+        const named = variantOf(rocket, variant);
+        if (!named)
+            continue;
+        const report = check({ rocket, variant: named.id });
+        if (!report.ok)
+            continue;
+        const built = build({ rocket, variant: named.id });
+        const show = options.show && built.shows.includes(options.show) ? options.show : built.shows[0];
+        const b = built.boundsOf(show);
+        known.push({ key, built, height: b.max[1], width: Math.max(Math.abs(b.min[0]), Math.abs(b.max[0]), Math.abs(b.min[2]), Math.abs(b.max[2])) * 2, label: named.name });
+    }
+    const gap = 28;
+    const top = 26;
+    const labelRoom = labels ? 44 : 0;
+    const rulerRoom = ruler ? 46 : 8;
+    const tallest = Math.max(10, ...known.map((item) => item.height));
+    const height = top + tallest * unit + labelRoom + 10;
+    const base = top + tallest * unit;
+    const minCell = 96;
+    let x = rulerRoom;
+    const body = [];
+    const { line } = LOOKS[look];
+    for (const item of known) {
+        const cell = Math.max(minCell, item.width * unit + gap);
+        const cx = x + cell / 2;
+        if (item.compare)
+            body.push(comparison(item.compare, cx - (COMPARES[item.compare].width * unit) / 2, base, unit, line, "url(#metal)"));
+        else if (item.built) {
+            const show = options.show && item.built.shows.includes(options.show) ? options.show : item.built.shows[0];
+            const cam = orthographic(angle, unit, cx, base);
+            const places = item.built.placesOf(show).filter((place) => place.shown);
+            const { right, forward } = axesOf(directionOf(angle));
+            void right;
+            for (const place of places.sort((a, b) => b.at[0] * forward[0] + b.at[2] * forward[2] - a.at[0] * forward[0] - a.at[2] * forward[2])) {
+                const part = item.built.parts.find((p) => p.slot === place.slot);
+                if (part)
+                    body.push(drawPart(drawnPieces(part, show === "together"), place.at, cam, look, 0.7));
+            }
+        }
+        if (labels) {
+            const words = item.label.length > 19 ? [item.label.slice(0, item.label.lastIndexOf(" ", 19)), item.label.slice(item.label.lastIndexOf(" ", 19) + 1)] : [item.label];
+            body.push(`<text x="${n(cx)}" y="${n(base + 16)}" text-anchor="middle" font-size="11" fill="currentColor">${words.map((word, i) => `<tspan x="${n(cx)}" dy="${i ? 13 : 0}">${xmlText(word)}</tspan>`).join("")}</text>`);
+        }
+        x += cell;
+    }
+    const width = x + 8;
+    let rule = "";
+    if (ruler) {
+        const step = tallest * unit < 240 ? 10 : 20;
+        rule += `<path d="M${rulerRoom - 8} ${n(base)}V${n(base - tallest * unit)}" stroke="currentColor" stroke-width="1" opacity=".7"/>`;
+        for (let m = 0; m <= tallest + 0.001; m += step)
+            rule += `<path d="M${rulerRoom - 8} ${n(base - m * unit)}h-5" stroke="currentColor" stroke-width="1" opacity=".7"/><text x="${rulerRoom - 16}" y="${n(base - m * unit + 3.5)}" text-anchor="end" font-size="10" fill="currentColor" opacity=".85">${m}</text>`;
+        rule += `<text x="${rulerRoom - 16}" y="${n(base - tallest * unit - 10)}" text-anchor="end" font-size="10" fill="currentColor" opacity=".85">m</text><path d="M${rulerRoom - 8} ${n(base)}H${n(width)}" stroke="currentColor" stroke-width=".6" opacity=".4"/>`;
+    }
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(width)} ${n(height)}" width="${n(width)}" height="${n(height)}" role="img" aria-label="${xmlText(`To scale: ${known.map((item) => item.label).join(", ")}`)}">${defsOf(look)}${rule}${body.join("")}</svg>`;
+    return { svg, width, height, items: known.map(({ key, label, height: h }) => ({ key, label, height: h })) };
+}

package/dist/crossfade.d.ts

@@ -0,0 +1,6 @@
+/** The drawing stays at least this long after it first comes on screen. */
+export declare const DRAWING_HOLD_MS = 1200;
+export declare const CROSSFADE_MS = 1500;
+export declare const REDUCED_FADE_MS = 400;
+/** How long to wait, once the 3D view is ready at `readyAt`, before it takes over from a drawing first seen at `shownAt` (0 under reduced motion). */
+export declare function revealDelay(shownAt: number, readyAt: number, reducedMotion: boolean): number;

package/dist/crossfade.js

@@ -0,0 +1,11 @@
+// The change from a rocket's drawing to its 3D view: the drawing stays a moment even when the 3D view is ready sooner, then a slow crossfade; under reduced motion, a plain short fade. Pure.
+/** The drawing stays at least this long after it first comes on screen. */
+export const DRAWING_HOLD_MS = 1200;
+export const CROSSFADE_MS = 1500;
+export const REDUCED_FADE_MS = 400;
+/** How long to wait, once the 3D view is ready at `readyAt`, before it takes over from a drawing first seen at `shownAt` (0 under reduced motion). */
+export function revealDelay(shownAt, readyAt, reducedMotion) {
+    if (reducedMotion)
+        return 0;
+    return Math.max(0, Math.min(DRAWING_HOLD_MS, shownAt + DRAWING_HOLD_MS - readyAt));
+}

package/dist/data/credits.d.ts

@@ -0,0 +1,87 @@
+export interface ModelCredit {
+    title: string;
+    creator: string;
+    creatorUrl: string;
+    sourceUrl: string;
+    licence: "CC BY 4.0";
+    licenceUrl: string;
+    /** What this package changed. */
+    changes: string;
+}
+export declare const MODEL_CREDITS: {
+    readonly "clarence365-block3": {
+        readonly title: "SpaceX Starship Block 3";
+        readonly creator: "Clarence365";
+        readonly creatorUrl: "https://sketchfab.com/clarence365";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-starship-block-3-6f6c6f88a3eb4b4d822fdca66733fbb2";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "Reduced from 913,217 triangles; logos, wordmark and serial number removed; rescaled to sourced sizes; separated into booster and ship; unseen payload bay interior removed; materials merged and renamed.";
+    };
+    readonly "clarence365-s24b7": {
+        readonly title: "Spacex Starship Ship 24 & Booster 7 V4";
+        readonly creator: "clarence365";
+        readonly creatorUrl: "https://sketchfab.com/clarence365";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-starship-ship-24-booster-7-v4-97875d14b63e4b9ca9ed425ef4253306";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "Reduced from 870,993 triangles; logo, serial number and engine decals removed; rescaled to sourced sizes; separated into booster and ship; unseen payload bay interior removed; materials merged and renamed.";
+    };
+    readonly "martiandays-2019": {
+        readonly title: "SpaceX Starship";
+        readonly creator: "MartianDays";
+        readonly creatorUrl: "https://sketchfab.com/MartianDays";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-starship-a8a0b69f776841a1a465cd9fb3762fd2";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "Rescaled to the sourced height; turned to this package's axes; material renamed. Its triangles and images are otherwise unchanged.";
+    };
+    readonly "stanley-falcon-9": {
+        readonly title: "Falcon 9 - SpaceX";
+        readonly creator: "Stanley Creative";
+        readonly creatorUrl: "https://sketchfab.com/Stanley_Creative";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/falcon-9-spacex-394f7cf52d124bbd9db69f24d1ff2f08";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "Reduced from 157,889 triangles; the wordmark, logos, flags and mission marks removed with the two textures that carried them; rescaled to sourced sizes; separated into first stage, second stage and fairing; materials merged and renamed.";
+    };
+    readonly "kubaha-dragon-2": {
+        readonly title: "SpaceX - Dragon 2";
+        readonly creator: "KUBAHA";
+        readonly creatorUrl: "https://sketchfab.com/KUBAHA";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-dragon-2-1b125e30a2cb442288580290536fbe5d";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "Reduced from 42,974 triangles; rescaled to sourced sizes; separated into capsule and trunk; materials merged and renamed.";
+    };
+    readonly "progressth-dragon-1": {
+        readonly title: "SpaceX Cargo Dragon";
+        readonly creator: "ProgressTH";
+        readonly creatorUrl: "https://sketchfab.com/ProgressTH";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-cargo-dragon-0ca8951e47b343dc8a41e23b3e9c55e5";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "Merged from 414 meshes; the logo decal and the hidden pressure vessel removed; rescaled to sourced sizes; stood upright; separated into capsule and trunk; materials merged and renamed.";
+    };
+    readonly "antonio-falcon-heavy": {
+        readonly title: "SpaceX Falcon Heavy(Low Poly)";
+        readonly creator: "Antonio_Adams";
+        readonly creatorUrl: "https://sketchfab.com/AAdams3112";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-falcon-heavylow-poly-0dc068a462e34258b3872085a7f592c8";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "The wordmark and logos painted out of its colour, roughness and normal maps, which were also resized; rescaled to sourced sizes; separated into its centre core and two side boosters by its own connected pieces.";
+    };
+    readonly "echo3-grasshopper": {
+        readonly title: "SpaceX Grasshopper";
+        readonly creator: "Echo_3";
+        readonly creatorUrl: "https://sketchfab.com/Echo_3";
+        readonly sourceUrl: "https://sketchfab.com/3d-models/spacex-grasshopper-35c07a68cdb246c59bb425610b934bf8";
+        readonly licence: "CC BY 4.0";
+        readonly licenceUrl: "https://creativecommons.org/licenses/by/4.0/";
+        readonly changes: "The wordmark and logo removed with the texture that carried them; rescaled to the sourced height; reduced from 55,455 triangles; materials merged and renamed.";
+    };
+};
+export type CreditId = keyof typeof MODEL_CREDITS;
+/** One credit as a line of text. */
+export declare function creditLine(id: CreditId): string;