@johnmorrisdotca/uchusen-rockets 0.9.0 → 0.10.0

package/dist/model/materials.d.ts

@@ -16,6 +16,12 @@ export interface MaterialSpec {
     rough: number;
     /** The fill it takes in a drawing. */
     fill: FillName;
+    /** How brightly it glows when the engines are lit (the viewer's "Engines: Lit" switch): the emissive strength. Left out: it never glows. */
+    glow?: number;
+    /** The colour of that glow; left out: its own colour. */
+    glowColor?: string;
+    /** How opaque it is in a painted 3D view, 0 to 1: glass you can see through. Left out: solid. */
+    opacity?: number;
 }
 /**
  * Every material the meshes use, by name. One naming scheme serves every source.
@@ -172,6 +178,276 @@ export declare const MATERIALS: {
         readonly rough: 0.5;
         readonly fill: "metal";
     };
+    readonly "hull-white": {
+        readonly color: "#dad8d0";
+        readonly metal: 0.25;
+        readonly rough: 0.5;
+        readonly fill: "white";
+    };
+    readonly "hull-white-worn": {
+        readonly color: "#b9b7ae";
+        readonly metal: 0.3;
+        readonly rough: 0.62;
+        readonly fill: "white";
+    };
+    readonly "hull-orange": {
+        readonly color: "#d17a3c";
+        readonly metal: 0.35;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+    readonly "hull-orange-worn": {
+        readonly color: "#a86432";
+        readonly metal: 0.4;
+        readonly rough: 0.62;
+        readonly fill: "metal";
+    };
+    readonly "hull-dawn": {
+        readonly color: "#eca637";
+        readonly metal: 0.55;
+        readonly rough: 0.36;
+        readonly fill: "metal";
+    };
+    readonly "hull-dawn-worn": {
+        readonly color: "#b87a2c";
+        readonly metal: 0.5;
+        readonly rough: 0.55;
+        readonly fill: "metal";
+    };
+    readonly "hull-yellow": {
+        readonly color: "#d6aa2b";
+        readonly metal: 0.3;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+    readonly "hull-grey": {
+        readonly color: "#8b9097";
+        readonly metal: 0.65;
+        readonly rough: 0.45;
+        readonly fill: "metal";
+    };
+    readonly "hull-grey-dark": {
+        readonly color: "#4b5057";
+        readonly metal: 0.7;
+        readonly rough: 0.5;
+        readonly fill: "dark";
+    };
+    readonly "hull-blue": {
+        readonly color: "#55778c";
+        readonly metal: 0.4;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+    readonly "panel-dark": {
+        readonly color: "#2a2d32";
+        readonly metal: 0.55;
+        readonly rough: 0.55;
+        readonly fill: "dark";
+    };
+    readonly coolant: {
+        readonly color: "#4f8085";
+        readonly metal: 0.55;
+        readonly rough: 0.4;
+        readonly fill: "metal";
+    };
+    readonly blanket: {
+        readonly color: "#e3e0d8";
+        readonly metal: 0.05;
+        readonly rough: 0.9;
+        readonly fill: "white";
+    };
+    readonly copper: {
+        readonly color: "#b8733a";
+        readonly metal: 1;
+        readonly rough: 0.34;
+        readonly fill: "metal";
+    };
+    readonly coil: {
+        readonly color: "#d3a34a";
+        readonly metal: 1;
+        readonly rough: 0.26;
+        readonly fill: "metal";
+    };
+    readonly radiator: {
+        readonly color: "#e4e2da";
+        readonly metal: 0.15;
+        readonly rough: 0.4;
+        readonly fill: "white";
+    };
+    readonly "radiator-hot": {
+        readonly color: "#9b4b3a";
+        readonly metal: 0.3;
+        readonly rough: 0.5;
+        readonly fill: "metal";
+    };
+    readonly hazard: {
+        readonly color: "#dcb126";
+        readonly metal: 0.1;
+        readonly rough: 0.55;
+        readonly fill: "metal";
+    };
+    readonly frost: {
+        readonly color: "#b9d2de";
+        readonly metal: 0.1;
+        readonly rough: 0.55;
+        readonly fill: "white";
+    };
+    readonly "lamp-amber": {
+        readonly color: "#ffb43a";
+        readonly metal: 0;
+        readonly rough: 0.3;
+        readonly fill: "metal";
+        readonly glow: 1.2;
+    };
+    readonly "lamp-blue": {
+        readonly color: "#9ad8ff";
+        readonly metal: 0;
+        readonly rough: 0.2;
+        readonly fill: "white";
+        readonly glow: 1;
+    };
+    readonly "lamp-red": {
+        readonly color: "#d8372f";
+        readonly metal: 0;
+        readonly rough: 0.35;
+        readonly fill: "metal";
+        readonly glow: 1.5;
+    };
+    readonly deck: {
+        readonly color: "#7b7f84";
+        readonly metal: 0.3;
+        readonly rough: 0.7;
+        readonly fill: "metal";
+    };
+    readonly plant: {
+        readonly color: "#3f7d3a";
+        readonly metal: 0;
+        readonly rough: 0.8;
+        readonly fill: "dark";
+    };
+    readonly fuel: {
+        readonly color: "#3a68a0";
+        readonly metal: 0.1;
+        readonly rough: 0.35;
+        readonly fill: "metal";
+    };
+    readonly core: {
+        readonly color: "#e9f6ff";
+        readonly metal: 0;
+        readonly rough: 0.2;
+        readonly fill: "white";
+    };
+    readonly "blanket-worn": {
+        readonly color: "#cfccc2";
+        readonly metal: 0.05;
+        readonly rough: 0.92;
+        readonly fill: "white";
+    };
+    readonly foil: {
+        readonly color: "#cfd3d8";
+        readonly metal: 1;
+        readonly rough: 0.3;
+        readonly fill: "metal";
+    };
+    readonly kapton: {
+        readonly color: "#b9893c";
+        readonly metal: 0.9;
+        readonly rough: 0.32;
+        readonly fill: "metal";
+    };
+    readonly "pipe-steel": {
+        readonly color: "#b7bcc2";
+        readonly metal: 0.85;
+        readonly rough: 0.36;
+        readonly fill: "metal";
+    };
+    readonly window: {
+        readonly color: "#16202c";
+        readonly metal: 0.1;
+        readonly rough: 0.1;
+        readonly fill: "dark";
+        readonly glow: 1.5;
+        readonly glowColor: "#ffe3a0";
+    };
+    readonly "coil-lit": {
+        readonly color: "#d3a34a";
+        readonly metal: 1;
+        readonly rough: 0.26;
+        readonly fill: "metal";
+        readonly glow: 2.4;
+        readonly glowColor: "#ff9a4d";
+    };
+    readonly "nav-red": {
+        readonly color: "#9a1f1f";
+        readonly metal: 0;
+        readonly rough: 0.3;
+        readonly fill: "metal";
+        readonly glow: 3;
+        readonly glowColor: "#ff2a2a";
+    };
+    readonly "nav-green": {
+        readonly color: "#1f8a46";
+        readonly metal: 0;
+        readonly rough: 0.3;
+        readonly fill: "metal";
+        readonly glow: 3;
+        readonly glowColor: "#2aff6a";
+    };
+    readonly strobe: {
+        readonly color: "#e8e8e8";
+        readonly metal: 0;
+        readonly rough: 0.25;
+        readonly fill: "white";
+        readonly glow: 4;
+        readonly glowColor: "#ffffff";
+    };
+    readonly flood: {
+        readonly color: "#e6dfc8";
+        readonly metal: 0;
+        readonly rough: 0.25;
+        readonly fill: "white";
+        readonly glow: 3;
+        readonly glowColor: "#fff4d6";
+    };
+    readonly "glass-clear": {
+        readonly color: "#c3dbe8";
+        readonly metal: 0.15;
+        readonly rough: 0.04;
+        readonly fill: "dark";
+        readonly opacity: 0.26;
+    };
+    readonly "grow-lamp": {
+        readonly color: "#7a4a8a";
+        readonly metal: 0;
+        readonly rough: 0.3;
+        readonly fill: "metal";
+        readonly glow: 2.6;
+        readonly glowColor: "#e08cff";
+    };
+    readonly leaf: {
+        readonly color: "#3f8f45";
+        readonly metal: 0;
+        readonly rough: 0.7;
+        readonly fill: "dark";
+    };
+    readonly soil: {
+        readonly color: "#4a3a2c";
+        readonly metal: 0;
+        readonly rough: 0.95;
+        readonly fill: "dark";
+    };
+    readonly fabric: {
+        readonly color: "#6f7f93";
+        readonly metal: 0;
+        readonly rough: 0.85;
+        readonly fill: "metal";
+    };
+    readonly wood: {
+        readonly color: "#a77b4e";
+        readonly metal: 0;
+        readonly rough: 0.7;
+        readonly fill: "metal";
+    };
 };
 /**
  * The name of one material in `MATERIALS`.

package/dist/model/materials.js

@@ -1,3 +1,4 @@
+import { FLEET_PALETTE as P } from "./fleet/palette.js";
 /**
  * Every material the meshes use, by name. One naming scheme serves every source.
  *
@@ -33,4 +34,46 @@ export const MATERIALS = {
     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" },
+    "hull-white": { color: P.protected, metal: 0.25, rough: 0.5, fill: "white" },
+    "hull-white-worn": { color: "#b9b7ae", metal: 0.3, rough: 0.62, fill: "white" },
+    "hull-orange": { color: P.shield, metal: 0.35, rough: 0.5, fill: "metal" },
+    "hull-orange-worn": { color: "#a86432", metal: 0.4, rough: 0.62, fill: "metal" },
+    "hull-dawn": { color: "#eca637", metal: 0.55, rough: 0.36, fill: "metal" },
+    "hull-dawn-worn": { color: "#b87a2c", metal: 0.5, rough: 0.55, fill: "metal" },
+    "hull-yellow": { color: P.service, metal: 0.3, rough: 0.5, fill: "metal" },
+    "hull-grey": { color: P.structure, metal: 0.65, rough: 0.45, fill: "metal" },
+    "hull-grey-dark": { color: "#4b5057", metal: 0.7, rough: 0.5, fill: "dark" },
+    "hull-blue": { color: "#55778c", metal: 0.4, rough: 0.5, fill: "metal" },
+    "panel-dark": { color: P.heatSink, metal: 0.55, rough: 0.55, fill: "dark" },
+    coolant: { color: P.coolant, metal: 0.55, rough: 0.4, fill: "metal" },
+    blanket: { color: "#e3e0d8", metal: 0.05, rough: 0.9, fill: "white" },
+    copper: { color: "#b8733a", metal: 1, rough: 0.34, fill: "metal" },
+    coil: { color: P.coil, metal: 1, rough: 0.26, fill: "metal" },
+    radiator: { color: "#e4e2da", metal: 0.15, rough: 0.4, fill: "white" },
+    "radiator-hot": { color: "#9b4b3a", metal: 0.3, rough: 0.5, fill: "metal" },
+    hazard: { color: "#dcb126", metal: 0.1, rough: 0.55, fill: "metal" },
+    frost: { color: "#b9d2de", metal: 0.1, rough: 0.55, fill: "white" },
+    "lamp-amber": { color: "#ffb43a", metal: 0, rough: 0.3, fill: "metal", glow: 1.2 },
+    "lamp-blue": { color: P.light, metal: 0, rough: 0.2, fill: "white", glow: 1 },
+    "lamp-red": { color: "#d8372f", metal: 0, rough: 0.35, fill: "metal", glow: 1.5 },
+    deck: { color: "#7b7f84", metal: 0.3, rough: 0.7, fill: "metal" },
+    plant: { color: P.farm, metal: 0, rough: 0.8, fill: "dark" },
+    fuel: { color: P.propellant, metal: 0.1, rough: 0.35, fill: "metal" },
+    core: { color: "#e9f6ff", metal: 0, rough: 0.2, fill: "white" },
+    "blanket-worn": { color: "#cfccc2", metal: 0.05, rough: 0.92, fill: "white" },
+    foil: { color: P.foil, metal: 1, rough: 0.3, fill: "metal" },
+    kapton: { color: P.kapton, metal: 0.9, rough: 0.32, fill: "metal" },
+    "pipe-steel": { color: P.pipe, metal: 0.85, rough: 0.36, fill: "metal" },
+    window: { color: "#16202c", metal: 0.1, rough: 0.1, fill: "dark", glow: 1.5, glowColor: P.windowLit },
+    "coil-lit": { color: P.coil, metal: 1, rough: 0.26, fill: "metal", glow: 2.4, glowColor: P.coilGlow },
+    "nav-red": { color: "#9a1f1f", metal: 0, rough: 0.3, fill: "metal", glow: 3, glowColor: P.navRed },
+    "nav-green": { color: "#1f8a46", metal: 0, rough: 0.3, fill: "metal", glow: 3, glowColor: P.navGreen },
+    strobe: { color: "#e8e8e8", metal: 0, rough: 0.25, fill: "white", glow: 4, glowColor: P.strobe },
+    flood: { color: "#e6dfc8", metal: 0, rough: 0.25, fill: "white", glow: 3, glowColor: P.flood },
+    "glass-clear": { color: "#c3dbe8", metal: 0.15, rough: 0.04, fill: "dark", opacity: 0.26 },
+    "grow-lamp": { color: "#7a4a8a", metal: 0, rough: 0.3, fill: "metal", glow: 2.6, glowColor: P.growLamp },
+    leaf: { color: "#3f8f45", metal: 0, rough: 0.7, fill: "dark" },
+    soil: { color: "#4a3a2c", metal: 0, rough: 0.95, fill: "dark" },
+    fabric: { color: "#6f7f93", metal: 0, rough: 0.85, fill: "metal" },
+    wood: { color: "#a77b4e", metal: 0, rough: 0.7, fill: "metal" },
 };

package/dist/model/pieces.d.ts

@@ -41,6 +41,9 @@ export interface Lathe {
     body?: boolean;
     /** Its outline is drawn in a drawing. */
     outline?: boolean;
+    /** Its surface is fluted, `flutes` ridges round it each `flute` metres deep (the tubes of a regeneratively cooled nozzle, the ribs of a sleeve). Needs four segments for each flute. */
+    flutes?: number;
+    flute?: number;
     move?: Move;
 }
 /** 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. */
@@ -57,6 +60,21 @@ export interface Plate {
     only?: "mesh" | "drawing";
     /** No feature lines of its own. */
     plain?: boolean;
+    /** Only its +w face, with no back and no edge walls: a sheet, such as foil or the skin of a blanket. */
+    sheet?: boolean;
+    /** Its +w face stuffed into pillows: a rectangular outline in `nu` by `nv` cells, each standing `bulge` metres proud at its middle, with a crease where two meet. */
+    quilt?: {
+        nu: number;
+        nv: number;
+        bulge: number;
+    };
+    /** A rectangular outline with a raised frame `margin` wide round a field sunk `depth` below it (a quilt, when it has one, fills the field). */
+    inset?: {
+        margin: number;
+        depth: number;
+    };
+    /** Loose flat triangles in the frame's [u, v, w] coordinates, wound counter-clockwise seen from the front, each lit on its own: crinkled foil. The outline only bounds them. */
+    facets?: readonly (readonly [Vec3, Vec3, Vec3])[];
     move?: Move;
 }
 /** Lines only, in the part's own space. */
@@ -120,5 +138,10 @@ export interface Bounds {
     min: Vec3;
     max: Vec3;
 }
+/**
+ * The box a part's pieces fill, worked from the pieces and not from a mesh, so a part with a very large number of pieces can be measured without building its triangles. A lathe counts as its full circle (its mesh is a polygon inside
+ * that circle, so this is never smaller than the mesh's box and at most a percent or two larger).
+ */
+export declare function boundsOfPieces(pieces: readonly Piece[]): Bounds;
 /** The box a part's triangles fill. */
 export declare function boundsOf(mesh: PartMesh): Bounds;

package/dist/model/pieces.js

@@ -81,8 +81,22 @@ 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 + (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);
+                if (piece.flutes && piece.flute) {
+                    // ridges round the surface: the radius swings by `flute` and the normal leans along the circle where it climbs
+                    const wave = Math.cos(piece.flutes * a);
+                    const lean = (-piece.flute * piece.flutes * Math.sin(piece.flutes * a)) / Math.max(r, 0.05);
+                    const rr = r + piece.flute * 0.5 * wave;
+                    const tangent = [ca, -sa];
+                    const nx = normal[0] * sa + tangent[0] * lean;
+                    const nz = normal[0] * ca + tangent[1] * lean;
+                    const l = Math.hypot(nx, normal[1], nz) || 1;
+                    out.positions.push(cx + rr * sa + (piece.lean?.[0] ?? 0) * y, y, cz + rr * ca + (piece.lean?.[1] ?? 0) * y);
+                    out.normals.push(nx / l, normal[1] / l, nz / l);
+                }
+                else {
+                    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
                 out.uvs.push(a / (2 * Math.PI) + (a0 < 0 ? 0.5 : 0), y / 100);
@@ -119,10 +133,138 @@ export function ringPath(piece, y, lift = 0.012) {
     }
     return path;
 }
+const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross3 = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const diff3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const unit3 = (a) => {
+    const l = Math.hypot(a[0], a[1], a[2]) || 1;
+    return [a[0] / l, a[1] / l, a[2] / l];
+};
+/** One triangle with a normal at each corner, wound so its front faces the way the first normal does. */
+function addTriangle(out, points, normals) {
+    const base = out.positions.length / 3;
+    for (let i = 0; i < 3; i++) {
+        out.positions.push(...points[i]);
+        out.normals.push(...normals[i]);
+        out.uvs.push(0, 0);
+    }
+    const face = cross3(diff3(points[1], points[0]), diff3(points[2], points[0]));
+    if (dot3(face, normals[0]) >= 0)
+        out.indices.push(base, base + 1, base + 2);
+    else
+        out.indices.push(base, base + 2, base + 1);
+}
+/** A flat four-cornered face with one normal. */
+function addQuad(out, a, b, c, d, normal) {
+    addTriangle(out, [a, b, c], [normal, normal, normal]);
+    addTriangle(out, [a, c, d], [normal, normal, normal]);
+}
+/** The +w face of a rectangular plate: a raised frame round a sunk field, a quilt of pillows, or both. */
+function relief(mesh, piece, half) {
+    const { frame, outline } = piece;
+    const field = buffersOf(mesh, piece.top ?? piece.material);
+    const out = buffersOf(mesh, piece.material);
+    const us = outline.map(([a]) => a);
+    const vs = outline.map(([, b]) => b);
+    const [u0, u1, v0, v1] = [Math.min(...us), Math.max(...us), Math.min(...vs), Math.max(...vs)];
+    const at = (a, b, c) => pointOf(frame, a, b, c);
+    const up = frame.w;
+    const inset = piece.inset;
+    const m = inset ? Math.min(inset.margin, (u1 - u0) / 2 - 0.001, (v1 - v0) / 2 - 0.001) : 0;
+    let floor = half;
+    if (inset) {
+        floor = half - inset.depth;
+        const [i0, i1, j0, j1] = [u0 + m, u1 - m, v0 + m, v1 - m];
+        addQuad(out, at(u0, v0, half), at(u1, v0, half), at(u1, j0, half), at(u0, j0, half), up);
+        addQuad(out, at(u0, j1, half), at(u1, j1, half), at(u1, v1, half), at(u0, v1, half), up);
+        addQuad(out, at(u0, j0, half), at(i0, j0, half), at(i0, j1, half), at(u0, j1, half), up);
+        addQuad(out, at(i1, j0, half), at(u1, j0, half), at(u1, j1, half), at(i1, j1, half), up);
+        const wall = (p, q, inward) => addQuad(field, p, q, [q[0] - up[0] * inset.depth, q[1] - up[1] * inset.depth, q[2] - up[2] * inset.depth], [p[0] - up[0] * inset.depth, p[1] - up[1] * inset.depth, p[2] - up[2] * inset.depth], inward);
+        wall(at(i0, j0, half), at(i1, j0, half), frame.v);
+        wall(at(i1, j1, half), at(i0, j1, half), [-frame.v[0], -frame.v[1], -frame.v[2]]);
+        wall(at(i0, j1, half), at(i0, j0, half), frame.u);
+        wall(at(i1, j0, half), at(i1, j1, half), [-frame.u[0], -frame.u[1], -frame.u[2]]);
+    }
+    const [f0, f1, g0, g1] = [u0 + m, u1 - m, v0 + m, v1 - m];
+    const quilt = piece.quilt;
+    if (!quilt) {
+        addQuad(field, at(f0, g0, floor), at(f1, g0, floor), at(f1, g1, floor), at(f0, g1, floor), up);
+        return;
+    }
+    const cu = (f1 - f0) / quilt.nu;
+    const cv = (g1 - g0) / quilt.nv;
+    const lean = 1.7;
+    for (let i = 0; i < quilt.nu; i++)
+        for (let j = 0; j < quilt.nv; j++) {
+            const grid = [];
+            for (let a = 0; a < 3; a++) {
+                grid.push([]);
+                for (let b = 0; b < 3; b++) {
+                    const fu = a / 2;
+                    const fv = b / 2;
+                    const h = quilt.bulge * Math.sin(Math.PI * fu) * Math.sin(Math.PI * fv);
+                    const du = ((quilt.bulge * Math.PI) / cu) * Math.cos(Math.PI * fu) * Math.sin(Math.PI * fv) * lean;
+                    const dv = ((quilt.bulge * Math.PI) / cv) * Math.sin(Math.PI * fu) * Math.cos(Math.PI * fv) * lean;
+                    const n = unit3([frame.w[0] - frame.u[0] * du - frame.v[0] * dv, frame.w[1] - frame.u[1] * du - frame.v[1] * dv, frame.w[2] - frame.u[2] * du - frame.v[2] * dv]);
+                    grid[a].push({ p: at(f0 + (i + fu) * cu, g0 + (j + fv) * cv, floor + h), n });
+                }
+            }
+            const base = field.positions.length / 3;
+            for (const column of grid)
+                for (const { p, n } of column) {
+                    field.positions.push(...p);
+                    field.normals.push(...n);
+                    field.uvs.push(0, 0);
+                }
+            // the nine points are numbered column by column: the middle is 4, and the ring round it goes 0 3 6 7 8 5 2 1
+            const ring = [0, 3, 6, 7, 8, 5, 2, 1];
+            for (let k = 0; k < 8; k++) {
+                const [a, b, c] = [base + 4, base + ring[k], base + ring[(k + 1) % 8]];
+                const pa = grid[1][1].p;
+                const face = cross3(diff3(grid[Math.floor(ring[k] / 3)][ring[k] % 3].p, pa), diff3(grid[Math.floor(ring[(k + 1) % 8] / 3)][ring[(k + 1) % 8] % 3].p, pa));
+                if (dot3(face, up) >= 0)
+                    field.indices.push(a, b, c);
+                else
+                    field.indices.push(a, c, b);
+            }
+        }
+}
+/** The lines of a quilted or framed face, so the line looks read it as the painted look does: the inner rim of a frame, the creases between pillows. */
+function reliefLines(mesh, piece, half) {
+    const { frame, outline } = piece;
+    const us = outline.map(([a]) => a);
+    const vs = outline.map(([, b]) => b);
+    const [u0, u1, v0, v1] = [Math.min(...us), Math.max(...us), Math.min(...vs), Math.max(...vs)];
+    const m = piece.inset ? Math.min(piece.inset.margin, (u1 - u0) / 2 - 0.001, (v1 - v0) / 2 - 0.001) : 0;
+    const [f0, f1, g0, g1] = [u0 + m, u1 - m, v0 + m, v1 - m];
+    const lift = 0.006;
+    if (piece.inset) {
+        addPath(mesh.feature, [[f0, g0], [f1, g0], [f1, g1], [f0, g1], [f0, g0]].map(([a, b]) => pointOf(frame, a, b, half + lift)));
+        const floor = half - piece.inset.depth + lift;
+        addPath(mesh.weld, [[f0, g0], [f1, g0], [f1, g1], [f0, g1], [f0, g0]].map(([a, b]) => pointOf(frame, a, b, floor)));
+    }
+    const quilt = piece.quilt;
+    if (quilt) {
+        const level = (piece.inset ? half - piece.inset.depth : half) + lift;
+        for (let i = 1; i < quilt.nu; i++)
+            addPath(mesh.weld, [pointOf(frame, f0 + ((f1 - f0) * i) / quilt.nu, g0, level), pointOf(frame, f0 + ((f1 - f0) * i) / quilt.nu, g1, level)]);
+        for (let j = 1; j < quilt.nv; j++)
+            addPath(mesh.weld, [pointOf(frame, f0, g0 + ((g1 - g0) * j) / quilt.nv, level), pointOf(frame, f1, g0 + ((g1 - g0) * j) / quilt.nv, level)]);
+    }
+}
 function plateFaces(mesh, piece) {
     const { frame, outline, thickness } = piece;
     const half = thickness / 2;
     const n = outline.length;
+    if (piece.facets) {
+        const out = buffersOf(mesh, piece.material);
+        for (const [a, b, c] of piece.facets) {
+            const p = [pointOf(frame, ...a), pointOf(frame, ...b), pointOf(frame, ...c)];
+            const normal = unit3(cross3(diff3(p[1], p[0]), diff3(p[2], p[0])));
+            addTriangle(out, [p[0], p[1], p[2]], [normal, normal, normal]);
+        }
+        return;
+    }
     const addFan = (material, c, normal, reverse) => {
         const out = buffersOf(mesh, material);
         const base = out.positions.length / 3;
@@ -151,7 +293,12 @@ function plateFaces(mesh, piece) {
     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);
+    if (piece.quilt || piece.inset)
+        relief(mesh, piece, half);
+    else
+        addFan(piece.top ?? piece.material, half, frame.w, ccw !== right);
+    if (piece.sheet)
+        return;
     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++) {
@@ -234,6 +381,8 @@ function meshOfFixed(pieces) {
                 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)]);
+                if (piece.quilt || piece.inset)
+                    reliefLines(mesh, piece, half);
             }
         }
         else {
@@ -243,6 +392,52 @@ function meshOfFixed(pieces) {
     }
     return mesh;
 }
+/**
+ * The box a part's pieces fill, worked from the pieces and not from a mesh, so a part with a very large number of pieces can be measured without building its triangles. A lathe counts as its full circle (its mesh is a polygon inside
+ * that circle, so this is never smaller than the mesh's box and at most a percent or two larger).
+ */
+export function boundsOfPieces(pieces) {
+    const min = [Infinity, Infinity, Infinity];
+    const max = [-Infinity, -Infinity, -Infinity];
+    const add = (x, y, z) => {
+        if (x < min[0])
+            min[0] = x;
+        if (x > max[0])
+            max[0] = x;
+        if (y < min[1])
+            min[1] = y;
+        if (y > max[1])
+            max[1] = y;
+        if (z < min[2])
+            min[2] = z;
+        if (z > max[2])
+            max[2] = z;
+    };
+    for (const piece of pieces) {
+        if (piece.only === "drawing")
+            continue;
+        if (piece.kind === "plate") {
+            const half = piece.thickness / 2;
+            for (const [a, b] of piece.outline)
+                for (const c of [-half, half])
+                    add(...pointOf(piece.frame, a, b, c));
+        }
+        else if (piece.kind === "lathe") {
+            const [cx, cz] = piece.at ?? [0, 0];
+            for (const [r, y] of piece.profile) {
+                const lx = (piece.lean?.[0] ?? 0) * y;
+                const lz = (piece.lean?.[1] ?? 0) * y;
+                add(cx + lx - r, y, cz + lz - r);
+                add(cx + lx + r, y, cz + lz + r);
+            }
+        }
+        else
+            for (const path of piece.paths)
+                for (const p of path)
+                    add(p[0], p[1], p[2]);
+    }
+    return { min, max };
+}
 /** The box a part's triangles fill. */
 export function boundsOf(mesh) {
     const min = [Infinity, Infinity, Infinity];