@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/src/kinds/hull-lines.ts

@@ -0,0 +1,160 @@
+// A hull's lines plan as functions, no mesh: deck-edge plan (half-breadth), sheer (deck-edge
+// height), keel/stem/counter profile and the section shape at any station. Waterline at z = 0,
+// bow toward +X, x = 0 amidships. Sections are superellipse quarters (n = 2 round bilge, 4 hard
+// bilge), going V toward the ends; the stem is where the keel line rises to meet the sheer.
+
+import { Ts23dError, type Vec3 } from '../core/index.ts';
+
+export interface HullColors {
+  /** Above the boot-top. */
+  readonly topsides: Vec3;
+  /** Below the waterline (antifouling). */
+  readonly bottom: Vec3;
+  /** The boot-top band at the waterline. Default near-black. */
+  readonly boot?: Vec3;
+  readonly deck: Vec3;
+  /** Inside of the bulwarks and the cap rail. Default = topsides. */
+  readonly bulwark?: Vec3;
+}
+
+export interface HullOptions {
+  /** Length overall at the deck, metres. */
+  readonly length: number;
+  /** Maximum beam at the deck edge. */
+  readonly beam: number;
+  /** Keel below the waterline. */
+  readonly draft: number;
+  /** Deck edge above the waterline amidships (lowest point of the sheer). */
+  readonly freeboard: number;
+  /** Sheer rise of the deck edge at [bow, stern] above amidships. Default [0.035, 0.012]·L. */
+  readonly sheer?: readonly [number, number];
+  /** 'round' (cruiser / tug) or 'transom' (flat stern). Default 'round'. */
+  readonly stern?: 'round' | 'transom';
+  /** Transom half-width as a share of the half-beam. Default 0.75. */
+  readonly transomWidth?: number;
+  /** Bilge: section superellipse exponent, 1.5 (soft V) … 5 (barge). Default 3. */
+  readonly fullness?: number;
+  /** Plan entrance exponent at the bow: 1.4 sharp … 3 bluff. Default 2. */
+  readonly entrance?: number;
+  /** Deck-edge breadth over waterline breadth − 1. Default 0.06. */
+  readonly flare?: number;
+  /** Bottom deadrise, degrees. Default 5. */
+  readonly deadriseDeg?: number;
+  /** Bulwark height above the deck, metres; 0 = none. Default 0. */
+  readonly bulwark?: number;
+  /** Deck camber at the centreline, metres. Default beam / 50. */
+  readonly camber?: number;
+  /** Height of the boot-top band above the waterline. Default 0.3. */
+  readonly bootTop?: number;
+  readonly colors: HullColors;
+  /** A rubbing strake / fender along each side just below the sheer (LOD0/1). */
+  readonly fender?: { readonly color: Vec3; readonly radius?: number };
+  /** Waterline amidships. Default [0, 0, 0]. */
+  readonly at?: Vec3;
+}
+
+export interface HullLines {
+  readonly L: number;
+  /** Deck-edge half-breadth at x (outer hull). */
+  readonly halfBreadth: (x: number) => number;
+  /** Deck-edge height at x (sheer line), relative to the waterline. */
+  readonly deck: (x: number) => number;
+  /** Keel / stem / counter height at x. */
+  readonly keel: (x: number) => number;
+  /** Section point at x for θ ∈ [0, π/2] (0 = keel, π/2 = deck edge), starboard (y ≥ 0). */
+  readonly section: (x: number, theta: number) => [number, number];
+}
+
+const bad = (cause: string, fix: string): Ts23dError =>
+  new Ts23dError('T3D_RECIPE_INVALID', { cause, fix });
+
+export function validateHull(o: HullOptions): void {
+  const dims = [o.length, o.beam, o.draft, o.freeboard];
+  if (!dims.every((v) => v > 0 && Number.isFinite(v)))
+    throw bad(
+      `hull length/beam/draft/freeboard = ${dims.join(' / ')}`,
+      'give all four in metres, > 0 (a harbour tug: 30 / 9 / 4 / 1.2)',
+    );
+  if (o.beam > o.length * 0.8)
+    throw bad(
+      `hull beam ${o.beam} is over 0.8 × length ${o.length}`,
+      'check the numbers: length/beam is 2.5–4 for tugs, 6–9 for ships',
+    );
+  const n = o.fullness ?? 3;
+  if (!(n >= 1.2 && n <= 8)) throw bad(`hull fullness is ${n}`, 'use 1.5 (soft V) … 5 (barge)');
+  const tw = o.transomWidth ?? 0.75;
+  if (!(tw > 0 && tw <= 1))
+    throw bad(`hull transomWidth is ${tw}`, 'use a share 0.3–1 of the half-beam');
+}
+
+const smooth = (t: number): number => (t <= 0 ? 0 : t >= 1 ? 1 : t * t * (3 - 2 * t));
+
+export function hullLines(o: HullOptions): HullLines {
+  validateHull(o);
+  const L = o.length;
+  const half = L / 2;
+  const [sb, ss] = o.sheer ?? [0.035 * L, 0.012 * L];
+  const round = (o.stern ?? 'round') === 'round';
+  const tw = o.transomWidth ?? 0.75;
+  const pe = o.entrance ?? 2;
+  const n = o.fullness ?? 3;
+  const flare = o.flare ?? 0.06;
+  const dead = Math.tan(((o.deadriseDeg ?? 5) * Math.PI) / 180);
+  // Parallel middle body and where the keel starts to rise, as shares of L.
+  const xf = 0.1 * L;
+  const xa = -0.15 * L;
+  const kf = 0.22 * L;
+  const ka = -0.25 * L;
+  const deck = (x: number): number => {
+    const u = x / half;
+    return o.freeboard + (u > 0 ? sb : ss) * u * u;
+  };
+  const plan = (x: number): number => {
+    if (x > xf) return 1 - ((x - xf) / (half - xf)) ** pe;
+    if (x < xa) {
+      const v = Math.min(1, (xa - x) / (xa + half));
+      return round ? Math.sqrt(Math.max(0, 1 - v * v)) : 1 - (1 - tw) * v * v;
+    }
+    return 1;
+  };
+  const halfBreadth = (x: number): number => (o.beam / 2) * Math.max(0, plan(x));
+  const counter = round ? 0.35 * o.freeboard : 0.15 * o.freeboard;
+  const keel = (x: number): number => {
+    if (x > kf) {
+      const u = Math.min(1, (x - kf) / (half - kf));
+      return -o.draft + (deck(half) + o.draft) * u ** 2;
+    }
+    if (x < ka) {
+      const v = Math.min(1, (ka - x) / (ka + half));
+      return -o.draft + (counter + o.draft) * v ** 1.6;
+    }
+    return -o.draft;
+  };
+  const section = (x: number, theta: number): [number, number] => {
+    const f = plan(x);
+    // Fine ends go V-sectioned; the middle body keeps the full bilge.
+    const ns = 1.2 + (n - 1.2) * smooth(f / 0.8);
+    const s = Math.sin(theta) ** (2 / ns);
+    const c = Math.cos(theta) ** (2 / ns);
+    const zk = keel(x);
+    const zd = deck(x);
+    const zf = 1 - c;
+    const y = halfBreadth(x) * (1 - flare + flare * zf * zf) * s;
+    return [y, zk + (zd - zk) * zf + dead * y * c];
+  };
+  return { L, halfBreadth, deck, keel, section };
+}
+
+/** θ where the section crosses height z (bisection; the section rises monotonically). */
+export function thetaAt(lines: HullLines, x: number, z: number): number {
+  let lo = 0;
+  let hi = Math.PI / 2;
+  if (lines.section(x, lo)[1] >= z) return lo;
+  if (lines.section(x, hi)[1] <= z) return hi;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (lines.section(x, mid)[1] < z) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}

package/src/kinds/hull-skin.ts

@@ -0,0 +1,83 @@
+// Skinning for hull-like surfaces: a station × column grid of points becomes quads with smooth
+// normals (central differences; collapsed rows such as a stem head borrow their neighbour's), and
+// any column range can be emitted as its own colour band, mirrored to port for a symmetric hull.
+
+import type { MeshBuilder, Vec3 } from '../core/index.ts';
+import { stripRect } from '../material/index.ts';
+
+export type Grid = Vec3[][];
+const sub3 = (a: Vec3, b: Vec3): Vec3 => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+const cross3 = (a: Vec3, b: Vec3): Vec3 => [
+  a[1] * b[2] - a[2] * b[1],
+  a[2] * b[0] - a[0] * b[2],
+  a[0] * b[1] - a[1] * b[0],
+];
+
+/** Smooth normals over a station × column grid (outward = tj × ti for the starboard side). */
+export function normalsOf(g: Grid): Grid {
+  const R = g.length;
+  const out: Grid = g.map((row, i) =>
+    row.map((p, j) => {
+      const r = (k: number): Vec3[] => g[Math.max(0, Math.min(R - 1, k))] ?? row;
+      const ti = sub3(r(i + 1)[j] ?? p, r(i - 1)[j] ?? p);
+      const tj = sub3(row[Math.min(row.length - 1, j + 1)] ?? p, row[Math.max(0, j - 1)] ?? p);
+      const n = cross3(tj, ti);
+      const l = Math.hypot(...n);
+      return l < 1e-9 ? ([0, 0, 0] as Vec3) : ([n[0] / l, n[1] / l, n[2] / l] as Vec3);
+    }),
+  );
+  // Collapsed rows (stem head, round stern post) borrow the nearest row's normals.
+  for (let i = 0; i < R; i++) {
+    const row = out[i] ?? [];
+    row.forEach((n, j) => {
+      if (n[0] || n[1] || n[2]) return;
+      for (let d = 1; d < R; d++) {
+        const m = out[i - d]?.[j] ?? out[i + d]?.[j];
+        if (m && (m[0] || m[1] || m[2])) {
+          row[j] = m;
+          return;
+        }
+      }
+    });
+  }
+  return out;
+}
+
+/** Emit columns [j0, j1] of a starboard grid and its port mirror. */
+export function emitBand(
+  b: MeshBuilder,
+  g: Grid,
+  nrm: Grid,
+  j0: number,
+  j1: number,
+  color: Vec3,
+  mirror: boolean,
+): void {
+  const rect = stripRect('plain');
+  for (const side of mirror ? [1, -1] : [1]) {
+    const ids = g.map((row, i) =>
+      row.slice(j0, j1 + 1).map((p, k) => {
+        const n = nrm[i]?.[j0 + k] ?? [0, 0, 1];
+        return b.vertex({
+          p: [p[0], p[1] * side, p[2]],
+          n: [n[0], n[1] * side, n[2]],
+          uv: [
+            rect.u0 + p[0] / rect.metres,
+            rect.v0 + (k / Math.max(1, j1 - j0)) * (rect.v1 - rect.v0),
+          ],
+          color,
+        });
+      }),
+    );
+    for (let i = 0; i + 1 < ids.length; i++) {
+      for (let k = 0; k < j1 - j0; k++) {
+        const a = ids[i]?.[k] ?? 0;
+        const c = ids[i]?.[k + 1] ?? 0;
+        const e = ids[i + 1]?.[k + 1] ?? 0;
+        const d = ids[i + 1]?.[k] ?? 0;
+        if (side > 0) b.quad(a, c, e, d);
+        else b.quad(a, d, e, c);
+      }
+    }
+  }
+}

package/src/kinds/hull.ts

@@ -0,0 +1,209 @@
+// Vessel hulls from the lines plan (hull-lines.ts): a smooth-shaded shell skinned over stations
+// (denser toward bow and stern), split at the waterline and boot-top so the paint bands are crisp,
+// optional bulwarks with a cap rail, a cambered plank deck laid in true-scale bands fore and aft,
+// and a flat transom. Waterline at `at` z, bow +X. LOD = stations × section points, nothing else.
+
+import {
+  type BuildContext,
+  type Lod,
+  type Mesh,
+  MeshBuilder,
+  merge,
+  translate,
+  type Vec3,
+} from '../core/index.ts';
+import { stripRect } from '../material/index.ts';
+import { sweep, triangulate } from '../primitives/index.ts';
+import { dedupe, stripScale } from './faces.ts';
+import { type HullLines, type HullOptions, hullLines, thetaAt } from './hull-lines.ts';
+import { emitBand, type Grid, normalsOf } from './hull-skin.ts';
+
+export type { HullColors, HullLines, HullOptions } from './hull-lines.ts';
+
+/** Width of one deck band (one V of the wood strip); LOD2 squeezes the whole beam into one. */
+const deckBand = (o: HullOptions, lod: Lod): number => (lod === 2 ? o.beam : stripScale('wood'));
+
+/** Plank deck between the bulwarks: bands `wood` scale wide, planks running fore and aft. */
+function deckMesh(o: HullOptions, ln: HullLines, xs: readonly number[], inset: number, lod: Lod) {
+  const b = new MeshBuilder();
+  const rect = stripRect('wood');
+  const w = deckBand(o, lod);
+  const camber = o.camber ?? o.beam / 50;
+  const yd = (x: number): number => Math.max(0, ln.halfBreadth(x) - inset);
+  for (let y0 = -Math.ceil(o.beam / 2 / w) * w; y0 < o.beam / 2; y0 += w) {
+    const at = (x: number, y: number): Vec3 => {
+      const h = yd(x);
+      const c = Math.max(-h, Math.min(h, y));
+      return [x, c, ln.deck(x) + (h > 0 ? camber * (1 - (c / h) ** 2) : 0)];
+    };
+    for (let i = 0; i + 1 < xs.length; i++) {
+      const x0 = xs[i] ?? 0;
+      const x1 = xs[i + 1] ?? 0;
+      const q = [at(x0, y0), at(x0, y0 + w), at(x1, y0 + w), at(x1, y0)];
+      if (
+        Math.abs((q[1]?.[1] ?? 0) - (q[0]?.[1] ?? 0)) +
+          Math.abs((q[2]?.[1] ?? 0) - (q[3]?.[1] ?? 0)) <
+        1e-6
+      )
+        continue;
+      const ids = q.map((p) =>
+        b.vertex({
+          p,
+          n: [0, 0, 1],
+          uv: [rect.u0 + p[0] / rect.metres, rect.v0 + ((p[1] - y0) / w) * (rect.v1 - rect.v0)],
+          color: o.colors.deck,
+        }),
+      );
+      b.quad(ids[0] ?? 0, ids[3] ?? 0, ids[2] ?? 0, ids[1] ?? 0);
+    }
+  }
+  return b.build();
+}
+
+export interface HullMesh {
+  /** Shell (+ bulwarks + transom). */
+  readonly shell: Mesh;
+  readonly deck: Mesh;
+  readonly lines: HullLines;
+}
+
+export function hullMesh(o: HullOptions, lod: Lod = 0): HullMesh {
+  const ln = hullLines(o);
+  const half = o.length / 2;
+  const stations = [36, 18, 8][lod] ?? 8;
+  const na = [6, 3, 2][lod] ?? 2;
+  const nc = [4, 2, 1][lod] ?? 1;
+  // Cosine spacing: stations crowd the bow and stern where the shape turns.
+  const xs = Array.from(
+    { length: stations + 1 },
+    (_, i) => -half + (o.length * (1 - Math.cos((Math.PI * i) / stations))) / 2,
+  );
+  const boot = o.bootTop ?? 0.3;
+  const hb = o.bulwark ?? 0;
+  const tb = 0.12;
+  const grid: Grid = xs.map((x) => {
+    const tw = thetaAt(ln, x, 0);
+    const tbt = thetaAt(ln, x, boot);
+    const row: Vec3[] = [];
+    const seg = (t0: number, t1: number, k: number, first: boolean) => {
+      for (let i = first ? 0 : 1; i <= k; i++) {
+        const [y, z] = ln.section(x, t0 + ((t1 - t0) * i) / k);
+        row.push([x, y, z]);
+      }
+    };
+    seg(0, tw, na, true);
+    seg(tw, tbt, 1, false);
+    seg(tbt, Math.PI / 2, nc, false);
+    return row;
+  });
+  const nrm = normalsOf(grid);
+  for (const row of nrm) {
+    const n = row[0];
+    if (n) {
+      const l = Math.hypot(n[0], n[2]) || 1;
+      row[0] = [n[0] / l, 0, n[2] / l];
+    }
+  }
+  const b = new MeshBuilder();
+  const c = o.colors;
+  emitBand(b, grid, nrm, 0, na, c.bottom, true);
+  emitBand(b, grid, nrm, na, na + 1, c.boot ?? [0.06, 0.06, 0.06], true);
+  emitBand(b, grid, nrm, na + 1, na + 1 + nc, c.topsides, true);
+  const parts = [b.build()];
+  if (hb > 0) parts.push(bulwarks(o, ln, xs, hb, tb));
+  if (o.fender && lod < 2) parts.push(...fenders(o.fender, ln, xs, lod));
+  if ((o.stern ?? 'round') === 'transom') {
+    const x = xs[0] ?? -half;
+    const star = (grid[0] ?? []).map((p) => p);
+    if (hb > 0) star.push([x, ln.halfBreadth(x), ln.deck(x) + hb]);
+    const port = [...star].reverse().map((p): Vec3 => [p[0], -p[1], p[2]]);
+    // Without bulwarks the transom's top follows the deck camber through the deck's band seams.
+    const yd = ln.halfBreadth(x);
+    const arc: Vec3[] = [];
+    const w = deckBand(o, lod);
+    for (let y = Math.ceil(o.beam / 2 / w) * w; y > -o.beam / 2; y -= w) {
+      if (hb === 0 && Math.abs(y) < yd - 1e-9)
+        arc.push([x, y, ln.deck(x) + (o.camber ?? o.beam / 50) * (1 - (y / yd) ** 2)]);
+    }
+    parts.push(transom(dedupe([...port.slice(0, -1), ...star, ...arc]), c.topsides));
+  }
+  const at = o.at ?? [0, 0, 0];
+  return {
+    shell: translate(merge(parts), at),
+    deck: translate(deckMesh(o, ln, xs, hb > 0 ? tb : 0, lod), at),
+    lines: ln,
+  };
+}
+
+/** Bulwark: outer plate up from the deck edge, cap rail, inner face down to the deck. */
+function bulwarks(
+  o: HullOptions,
+  ln: HullLines,
+  xs: readonly number[],
+  hb: number,
+  tb: number,
+): Mesh {
+  const g: Grid = xs.map((x) => {
+    const y = ln.halfBreadth(x);
+    const z = ln.deck(x);
+    const yi = Math.max(0, y - tb);
+    return [
+      [x, y, z],
+      [x, y, z + hb],
+      [x, yi, z + hb],
+      [x, yi, z],
+    ];
+  });
+  const b = new MeshBuilder();
+  const top = o.colors.bulwark ?? o.colors.topsides;
+  // Each face its own band so the corners stay crisp.
+  for (const [j0, color] of [
+    [0, o.colors.topsides],
+    [1, top],
+    [2, top],
+  ] as const) {
+    const sliced = g.map((row) => row.slice(j0, j0 + 2));
+    emitBand(b, sliced, normalsOf(sliced), 0, 1, color, true);
+  }
+  return b.build();
+}
+
+/** Rubbing strake / tyre fender along each side just below the sheer. */
+function fenders(
+  f: NonNullable<HullOptions['fender']>,
+  ln: HullLines,
+  xs: readonly number[],
+  lod: Lod,
+) {
+  const r = f.radius ?? 0.15;
+  return [1, -1].map((side) =>
+    sweep({
+      section: { radius: r, segments: lod === 0 ? 8 : 5 },
+      path: xs.map((x): Vec3 => [x, side * (ln.halfBreadth(x) + r * 0.4), ln.deck(x) - r * 1.2]),
+      color: f.color,
+      caps: true,
+    }),
+  );
+}
+
+/** Flat stern plate facing −X (ear-clipped: the bulwark notch makes it non-convex). */
+function transom(points: readonly Vec3[], color: Vec3): Mesh {
+  const b = new MeshBuilder();
+  const rect = stripRect('plain');
+  const ids = points.map((p) =>
+    b.vertex({ p, n: [-1, 0, 0], uv: [rect.u0 + p[1] / rect.metres, rect.v0], color }),
+  );
+  // CCW in (y, z) faces +X, so each triangle is reversed to face aft.
+  for (const [i, j, k] of triangulate(points.map((p) => [p[1], p[2]])))
+    b.tri(ids[i] ?? 0, ids[k] ?? 0, ids[j] ?? 0);
+  return b.build();
+}
+
+/** Add `name` (shell) and `name_deck` parts; returns the lines for placing deckhouses and fittings. */
+export function hull(ctx: BuildContext, o: HullOptions & { readonly name?: string }): HullLines {
+  const name = o.name ?? 'hull';
+  const m = hullMesh(o, ctx.lod);
+  ctx.part(name, m.shell);
+  ctx.part(`${name}_deck`, m.deck);
+  return m.lines;
+}

package/src/kinds/index.ts

@@ -0,0 +1,63 @@
+// Public API of /kinds: domain builders (buildings, vehicles, vessels, vegetation) recipes compose.
+
+export { type FacadeOptions, facade, type SetbackTier, type Side, setbacks } from './building.ts';
+export {
+  HEAD_RES,
+  type HeadInfo,
+  type HeadOptions,
+  type HeadOverrides,
+  head,
+  headEdits,
+  headParams,
+} from './head.ts';
+export {
+  type BeardStyle,
+  type BustStyle,
+  checkHead,
+  type EarShape,
+  type HairStyle,
+  type HeadColors,
+  type HeadParams,
+} from './head-params.ts';
+// Presets by race name (`head(ctx, { race: 'orc' })`); HEADS.orc etc. for tweaking. The bare
+// preset names (`orc`, `human`) stay internal: too generic for the top-level barrel.
+export { HEADS, type HeadPreset } from './head-presets.ts';
+export {
+  type HullColors,
+  type HullLines,
+  type HullMesh,
+  type HullOptions,
+  hull,
+  hullMesh,
+} from './hull.ts';
+export { hullLines } from './hull-lines.ts';
+export { type MassOptions, mass } from './mass.ts';
+export { type OpeningOptions, type OpeningSide, opening } from './openings.ts';
+export { creature } from './planned.ts';
+export { type RoofInfo, type RoofMeshOptions, roof, roofInfo, roofMesh } from './roof.ts';
+export type { RoofChimney } from './roof-chimney.ts';
+export {
+  type RoofOptions,
+  type RoofSide,
+  type RoofType,
+  ridgeHeight,
+  roofHeightAt,
+} from './roof-shape.ts';
+export {
+  type TreeFamilyParams,
+  type TreeInfo,
+  type TreeOptions,
+  tree,
+  treeParams,
+  treeReal,
+  trees,
+} from './vegetation.ts';
+export type {
+  BranchLevel,
+  CrownShape,
+  LeafParams,
+  LeafShape,
+  TreeParams,
+} from './vegetation-params.ts';
+export { birch, oak, palm, pine, SPECIES, type SpeciesName, willow } from './vegetation-presets.ts';
+export { axle, propeller, trackRun, whyteAxles } from './vehicle.ts';

package/src/kinds/mass.ts

@@ -0,0 +1,110 @@
+// A building mass (walls block) whose masonry is laid at TRUE scale: every side is cut into
+// course bands of the strip's `scaleMetres`, all starting from the ground line, so brick courses
+// match across sides and across stacked masses. `box` stretches one strip band over the whole face
+// — fine for trim, wrong for a 6 m brick wall. LOD2 keeps one quad per side (V squeezed).
+
+import { type Lod, type Mesh, MeshBuilder, Ts23dError, type Vec3 } from '../core/index.ts';
+import type { StripId } from '../material/index.ts';
+import { emitFace } from './faces.ts';
+
+export interface MassOptions {
+  /** Width (X), depth (Y), height (Z). */
+  readonly size: Vec3;
+  /** Centre of the base. */
+  readonly at?: Vec3;
+  readonly color: Vec3;
+  readonly strip?: StripId;
+  /** Courses start at this world z (default 0, the ground) so stacked masses line up. */
+  readonly courseOrigin?: number;
+  /** Skip faces nobody sees (bottom on the ground, top under a roof, a party wall). */
+  readonly omit?: readonly ('top' | 'bottom' | 'front' | 'back' | 'left' | 'right')[];
+}
+
+export function mass(o: MassOptions, lod: Lod = 0): Mesh {
+  const [w, d, h] = o.size;
+  if (!(w > 0 && d > 0 && h > 0))
+    throw new Ts23dError('T3D_RECIPE_INVALID', {
+      cause: `mass size is [${o.size.join(', ')}]`,
+      fix: 'give width (X), depth (Y) and height (Z) in metres, all > 0',
+    });
+  const [cx, cy, z0] = o.at ?? [0, 0, 0];
+  const [x0, x1, y0, y1, z1] = [cx - w / 2, cx + w / 2, cy - d / 2, cy + d / 2, z0 + h];
+  const b = new MeshBuilder();
+  const strip = o.strip ?? 'brick';
+  const origin: Vec3 = [0, 0, o.courseOrigin ?? 0];
+  const sides: [NonNullable<MassOptions['omit']>[number], Vec3, Vec3[]][] = [
+    [
+      'front',
+      [1, 0, 0],
+      [
+        [x1, y0, z0],
+        [x1, y1, z0],
+        [x1, y1, z1],
+        [x1, y0, z1],
+      ],
+    ],
+    [
+      'back',
+      [-1, 0, 0],
+      [
+        [x0, y1, z0],
+        [x0, y0, z0],
+        [x0, y0, z1],
+        [x0, y1, z1],
+      ],
+    ],
+    [
+      'left',
+      [0, 1, 0],
+      [
+        [x1, y1, z0],
+        [x0, y1, z0],
+        [x0, y1, z1],
+        [x1, y1, z1],
+      ],
+    ],
+    [
+      'right',
+      [0, -1, 0],
+      [
+        [x0, y0, z0],
+        [x1, y0, z0],
+        [x1, y0, z1],
+        [x0, y0, z1],
+      ],
+    ],
+  ];
+  for (const [name, normal, points] of sides) {
+    if (o.omit?.includes(name)) continue;
+    emitFace(b, {
+      points,
+      normal,
+      up: [0, 0, 1],
+      vOrigin: origin,
+      color: o.color,
+      strip,
+      banded: lod < 2,
+    });
+  }
+  for (const [name, z, s] of [
+    ['top', z1, 1],
+    ['bottom', z0, -1],
+  ] as const) {
+    if (o.omit?.includes(name)) continue;
+    emitFace(b, {
+      points: [
+        [x0, y0, z],
+        [x1, y0, z],
+        [x1, y1, z],
+        [x0, y1, z],
+      ],
+      normal: [0, 0, s],
+      up: [0, 1, 0],
+      vOrigin: [cx, y0, z],
+      color: o.color,
+      strip: 'plain',
+      banded: false,
+    });
+  }
+  return b.build();
+}