@developerz.ai/ts23d 0.0.0-stage → 0.1.0

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();
+}

package/src/kinds/openings.ts

@@ -0,0 +1,141 @@
+// Windows and doors as one mesh each: a reveal (surround in the wall's colour, so the glass reads
+// set back by `depth`), stone sill and lintel, sash frame with glazing bars, or a panelled door
+// leaf. The wall mass behind stays whole (no boolean cut): half the triangles, no T-junctions.
+// Authored with the face at x = 0 looking +X, then turned to the requested side.
+//   LOD0: everything · LOD1: no glazing bars / door panels · LOD2: glass or leaf only.
+
+import { type Lod, type Mesh, merge, place, Ts23dError, type Vec3 } from '../core/index.ts';
+import type { StripId } from '../material/index.ts';
+import { box } from '../primitives/index.ts';
+import { mass } from './mass.ts';
+
+export type OpeningSide = 'front' | 'back' | 'left' | 'right';
+
+export interface OpeningOptions {
+  readonly kind: 'window' | 'door';
+  /** Clear opening, metres (UK sash ≈ 0.9 × 1.6; door ≈ 0.9 × 2.1). */
+  readonly width: number;
+  readonly height: number;
+  /** Bottom centre of the opening ON the wall face. */
+  readonly at: Vec3;
+  /** Which way the wall faces (front = +X, left = +Y). */
+  readonly facing: OpeningSide;
+  readonly glass: Vec3;
+  /** Sash frame / door leaf colour. */
+  readonly frame: Vec3;
+  /** Reveal (surround) colour: the wall's, so the opening reads recessed. */
+  readonly wall: Vec3;
+  readonly wallStrip?: StripId;
+  /** Sill + lintel colour (dressed stone). */
+  readonly trim?: Vec3;
+  /** Reveal depth, metres. Default 0.12 (half a brick). */
+  readonly depth?: number;
+  /** Reveal band width either side. Default 0.1. */
+  readonly surround?: number;
+  /** Glazing panes [across, up]: 2-over-2 sash = [2, 2]. Default window [2, 2]. */
+  readonly panes?: readonly [number, number];
+  readonly sill?: boolean;
+  readonly lintel?: boolean;
+}
+
+const YAW: Record<OpeningSide, number> = {
+  front: 0,
+  left: Math.PI / 2,
+  back: Math.PI,
+  right: -Math.PI / 2,
+};
+
+/** Base-centred box flush on the wall face (x = 0), back face omitted (it is against the wall). */
+const onWall = (size: Vec3, y: number, z: number, color: Vec3, strip?: StripId): Mesh =>
+  box({ size, at: [size[0] / 2, y, z], color, omit: ['back'], ...(strip ? { strip } : {}) });
+
+export function opening(o: OpeningOptions, lod: Lod = 0): Mesh {
+  const { width: w, height: h } = o;
+  if (!(w > 0.2 && h > 0.2 && Number.isFinite(w) && Number.isFinite(h)))
+    throw new Ts23dError('T3D_RECIPE_INVALID', {
+      cause: `${o.kind} opening is ${w} × ${h} m`,
+      fix: 'give a clear width and height > 0.2 m (sash ≈ 0.9 × 1.6, door ≈ 0.9 × 2.1)',
+    });
+  const r = o.depth ?? 0.12;
+  const s = o.surround ?? 0.1;
+  const trim = o.trim ?? [0.78, 0.75, 0.68];
+  const door = o.kind === 'door';
+  const parts: Mesh[] = [];
+  // The infill: glass flush on the wall, or the door leaf a little proud of it.
+  parts.push(
+    door
+      ? onWall([0.05, w, h], 0, 0, o.frame, 'wood')
+      : onWall([0.02, w, h], 0, 0, o.glass, 'glass'),
+  );
+  if (lod < 2) {
+    const lintel = o.lintel ?? true;
+    // Reveal masonry in true-scale courses aligned with the wall's (courses start at world z 0).
+    const reveal = (size: Vec3, y: number, z: number): Mesh =>
+      mass(
+        {
+          size,
+          at: [size[0] / 2, y, z],
+          color: o.wall,
+          strip: o.wallStrip ?? 'plain',
+          courseOrigin: -o.at[2],
+          omit: ['back'],
+        },
+        lod,
+      );
+    for (const side of [-1, 1]) parts.push(reveal([r, s, h], side * (w / 2 + s / 2), 0));
+    if (lintel) parts.push(onWall([r + 0.03, w + 2 * s + 0.2, 0.22], 0, h, trim, 'stone'));
+    else parts.push(reveal([r, w + 2 * s, s], 0, h));
+    if (!door && (o.sill ?? true))
+      parts.push(onWall([r + 0.07, w + 2 * s + 0.12, 0.07], 0, -0.07, trim, 'stone'));
+    if (!door) parts.push(...sash(o, w, h, lod));
+    else if (lod === 0) parts.push(...panels(o, w, h));
+  }
+  return place(merge(parts), { yaw: YAW[o.facing], at: o.at });
+}
+
+/** Sash frame round the glass; glazing bars at LOD0. */
+function sash(o: OpeningOptions, w: number, h: number, lod: Lod): Mesh[] {
+  const f = 0.06;
+  const d = 0.05;
+  const out = [
+    onWall([d, f, h], -(w / 2 - f / 2), 0, o.frame),
+    onWall([d, f, h], w / 2 - f / 2, 0, o.frame),
+    onWall([d, w - 2 * f, f], 0, 0, o.frame),
+    onWall([d, w - 2 * f, f], 0, h - f, o.frame),
+  ];
+  if (lod > 0) return out;
+  const [across, up] = o.panes ?? [2, 2];
+  const bar = 0.03;
+  for (let i = 1; i < across; i++)
+    out.push(
+      onWall([d * 0.8, bar, h - 2 * f], -w / 2 + f + ((w - 2 * f) * i) / across, f, o.frame),
+    );
+  for (let j = 1; j < up; j++)
+    out.push(onWall([d * 0.8, w - 2 * f, bar], 0, f + ((h - 2 * f) * j) / up - bar / 2, o.frame));
+  return out;
+}
+
+/** Four raised fielded panels on a door leaf (LOD0). */
+function panels(o: OpeningOptions, w: number, h: number): Mesh[] {
+  const out: Mesh[] = [];
+  const pw = (w - 0.36) / 2;
+  const tone: Vec3 = [o.frame[0] * 0.85, o.frame[1] * 0.85, o.frame[2] * 0.85];
+  for (const y of [-1, 1])
+    for (const [z0, ph] of [
+      [0.15, h * 0.38],
+      [0.15 + h * 0.38 + 0.15, h - 0.45 - h * 0.38],
+    ] as const)
+      out.push(
+        box({
+          size: [0.02, pw, ph],
+          at: [0.06, y * (pw / 2 + 0.06), z0],
+          color: tone,
+          omit: ['back'],
+        }),
+      );
+  // Knob on the lock side.
+  out.push(
+    box({ size: [0.06, 0.06, 0.06], at: [0.08, w / 2 - 0.12, h * 0.48], color: [0.7, 0.6, 0.3] }),
+  );
+  return out;
+}

package/src/kinds/planned.ts

@@ -0,0 +1,12 @@
+// Kinds with a fixed entry point and no body yet. Each is a library of builders recipes call;
+// the roadmap slice that builds it is named in the error.
+
+import { type BuildContext, notImplemented } from '../core/index.ts';
+
+/** Stylised creature from a skeleton + SDF flesh (Spore-like). Realistic ones go via /neural. M4. */
+export function creature(
+  _ctx: BuildContext,
+  _o: { skeleton: 'biped' | 'quadruped' | 'bird'; height: number },
+): void {
+  notImplemented('creature (SDF-skinned skeleton)', 'docs/idea/07-what-fits.md');
+}

package/src/kinds/roof-chimney.ts

@@ -0,0 +1,100 @@
+// A chimney stack for `roofMesh`: brick shaft from the wall plate (hidden in the attic, so it
+// always meets the roof) to a set height above where it leaves the slope, with an oversailing
+// cap course (LOD0/1) and clay pots (LOD0). Building-regs rule of thumb: ≥ 0.9 m above the
+// highest point where it passes through the roof.
+
+import { type Lod, type Mesh, MeshBuilder, merge, type Vec3 } from '../core/index.ts';
+import type { StripId } from '../material/index.ts';
+import { box, lathe } from '../primitives/index.ts';
+import { emitFace } from './faces.ts';
+
+export interface RoofChimney {
+  /** Centre offset from the roof's `at`, world X/Y metres. */
+  readonly at: readonly [number, number];
+  /** Stack width (X) and depth (Y). Default [0.9, 0.6]. */
+  readonly size?: readonly [number, number];
+  /** Height above the highest roof point it touches. Default 0.9. */
+  readonly height?: number;
+  readonly color: Vec3;
+  readonly strip?: StripId;
+  /** Clay pots on top (LOD0). Default: one per 0.4 m of width. */
+  readonly pots?: number;
+  readonly potColor?: Vec3;
+}
+
+export function chimney(
+  c: RoofChimney,
+  heightAt: (x: number, y: number) => number,
+  at: Vec3,
+  lod: Lod,
+): Mesh {
+  const [w, d] = c.size ?? [0.9, 0.6];
+  const cx = at[0] + c.at[0];
+  const cy = at[1] + c.at[1];
+  const corners: [number, number][] = [
+    [cx - w / 2, cy - d / 2],
+    [cx + w / 2, cy - d / 2],
+    [cx + w / 2, cy + d / 2],
+    [cx - w / 2, cy + d / 2],
+  ];
+  const exit = Math.max(...corners.map(([x, y]) => heightAt(x, y)));
+  const top = exit + (c.height ?? 0.9);
+  const z0 = at[2];
+  const strip = c.strip ?? 'brick';
+  const b = new MeshBuilder();
+  corners.forEach(([x0, y0], i) => {
+    const [x1, y1] = corners[(i + 1) % 4] ?? [x0, y0];
+    emitFace(b, {
+      points: [
+        [x0, y0, z0],
+        [x1, y1, z0],
+        [x1, y1, top],
+        [x0, y0, top],
+      ],
+      normal: [y1 - y0, -(x1 - x0), 0],
+      up: [0, 0, 1],
+      vOrigin: [0, 0, z0],
+      color: c.color,
+      strip,
+      banded: lod < 2,
+    });
+  });
+  emitFace(b, {
+    points: corners.map(([x, y]) => [x, y, top] as Vec3),
+    normal: [0, 0, 1],
+    up: [0, 1, 0],
+    vOrigin: [cx, cy, top],
+    color: c.color,
+    strip: 'plain',
+    banded: false,
+  });
+  const parts = [b.build()];
+  if (lod < 2) {
+    const k = 0.06;
+    const cap: Vec3 = [c.color[0] * 0.85, c.color[1] * 0.85, c.color[2] * 0.85];
+    parts.push(box({ size: [w + 2 * k, d + 2 * k, 0.1], at: [cx, cy, top - 0.22], color: cap }));
+    parts.push(box({ size: [w + k, d + k, 0.07], at: [cx, cy, top - 0.07], color: cap }));
+  }
+  if (lod === 0) {
+    const n = c.pots ?? Math.max(1, Math.round(w / 0.4));
+    const pot = c.potColor ?? [0.62, 0.32, 0.2];
+    for (let i = 0; i < n; i++) {
+      const x = cx - w / 2 + (w * (i + 0.5)) / n;
+      parts.push(
+        lathe({
+          profile: [
+            [0.13, 0],
+            [0.1, 0.36],
+            [0.125, 0.4],
+            [0.125, 0.46],
+          ],
+          segments: 8,
+          caps: true,
+          at: [x, cy, top - 0.02],
+          color: pot,
+        }),
+      );
+    }
+  }
+  return merge(parts);
+}