@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/src/material/library.ts

@@ -0,0 +1,196 @@
+// The house material library: sixteen physically distinct strips with measured or sourced PBR
+// numbers (docs/architecture/materials.md has the table and the reasoning). Metals use the
+// physicallybased.info reflectance (sRGB here), dielectrics stay inside the 30–240 sRGB albedo
+// range, roughness follows engine/asset references. Colour lives in the texture, so tint these
+// with a near-white vertex colour (`NATURAL`) — except where noted (paint films take the hue).
+
+import type { MaterialDef } from './material-def.ts';
+import type { MaterialStripId } from './trim-sheet.ts';
+
+const PB = 'https://physicallybased.info';
+const ROBLOX = 'https://create.roblox.com/docs/art/modeling/material-reference';
+const PBR_GUIDE = 'https://www.adobe.com/learn/substance-3d-designer/web/the-pbr-guide-part-2';
+
+type Library = Readonly<Record<MaterialStripId, MaterialDef & { readonly id: MaterialStripId }>>;
+
+export const MATERIAL_LIBRARY: Library = {
+  oak: {
+    id: 'oak',
+    kind: 'planks',
+    scaleMetres: 0.6,
+    roughness: 0.68,
+    albedo: '#a27b52',
+    albedo2: '#6a482b',
+    params: { width: 0.14, rings: 0.55, rays: 0.6, knots: 0.6 },
+    description: 'Oak boards: warm brown, dark latewood rings, pale ray flecks.',
+    sources: [PBR_GUIDE, ROBLOX],
+  },
+  pine: {
+    id: 'pine',
+    kind: 'planks',
+    scaleMetres: 0.6,
+    roughness: 0.72,
+    albedo: '#d2b183',
+    albedo2: '#9b6a3c',
+    params: { width: 0.16, rings: 0.75, knots: 2.5 },
+    description: 'Pine boards: pale yellow, strong orange latewood, frequent knots.',
+    sources: [PBR_GUIDE, ROBLOX],
+  },
+  wood_weathered: {
+    id: 'wood_weathered',
+    kind: 'planks',
+    scaleMetres: 0.6,
+    roughness: 0.86,
+    albedo: '#9b968c',
+    albedo2: '#4f463c',
+    params: { width: 0.2, rings: 0.35, checks: 1, knots: 1.5, grime: 0.15 },
+    description: 'Barn-grey weathered boards: silvered, eroded grain, open checks.',
+    sources: [ROBLOX],
+  },
+  wood_painted: {
+    id: 'wood_painted',
+    kind: 'planks',
+    scaleMetres: 0.6,
+    roughness: 0.84,
+    albedo: '#ededed',
+    albedo2: '#a08c74',
+    params: { width: 0.14, paint: 1, paintRough: 0.62, chips: 0.38, knots: 0.8, grime: 0.3 },
+    description: 'Painted boards (vertex colour = paint) worn through to grey wood at the edges.',
+    sources: [ROBLOX],
+  },
+  iron_rust: {
+    id: 'iron_rust',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.55,
+    metalness: 0.9,
+    albedo: '#8e8a85',
+    albedo2: '#764323',
+    params: { oxide: 0.62, cast: 0.25, streaks: 0.5 },
+    description: 'Weathered wrought/rolled iron, rust blooming in patches and runs.',
+    sources: [PB, ROBLOX],
+  },
+  iron_cast: {
+    id: 'iron_cast',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.68,
+    metalness: 0.75,
+    albedo: '#6c6966',
+    albedo2: '#55372a',
+    params: { cast: 1, oxide: 0.35 },
+    description: 'Sand-cast iron (wheels, frames): dark pitted skin, dull oxide.',
+    sources: [PB],
+  },
+  steel_painted: {
+    id: 'steel_painted',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.4,
+    metalness: 1,
+    albedo: '#eeeeee',
+    albedo2: '#5a3b2a',
+    params: { paint: 1, paintRough: 0.42, chips: 0.2, streaks: 0.2, grime: 0.2 },
+    description: 'Painted steel (vertex colour = paint): chips show rusty steel beneath.',
+    sources: [ROBLOX],
+  },
+  steel_galvanised: {
+    id: 'steel_galvanised',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.42,
+    metalness: 1,
+    albedo: '#d5dadc',
+    albedo2: '#9a9c98',
+    params: { spangle: 1, oxide: 0.12 },
+    description: 'Hot-dip galvanised steel: zinc spangle, white-rust bloom.',
+    sources: [PB],
+  },
+  brass: {
+    id: 'brass',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.28,
+    metalness: 1,
+    albedo: '#f5e5ae',
+    albedo2: '#6b5a3a',
+    params: { brush: 0.3, oxide: 0.1 },
+    description: 'Brass fittings: warm gold reflectance, dark tarnish in patches.',
+    sources: [PB, ROBLOX],
+  },
+  copper: {
+    id: 'copper',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.32,
+    metalness: 1,
+    albedo: '#f2b89c',
+    albedo2: '#6fa58f',
+    params: { oxide: 0.15 },
+    description: 'Copper: salmon reflectance with verdigris patches.',
+    sources: [PB],
+  },
+  aluminium: {
+    id: 'aluminium',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.34,
+    metalness: 1,
+    albedo: '#e6e8e9',
+    params: { brush: 1 },
+    description: 'Brushed aluminium: bright, cool, streaked along U.',
+    sources: [PB],
+  },
+  chrome: {
+    id: 'chrome',
+    kind: 'metal',
+    scaleMetres: 0.5,
+    roughness: 0.07,
+    metalness: 1,
+    albedo: '#d3d9dc',
+    description: 'Chrome plate: near-mirror.',
+    sources: [PB],
+  },
+  rubber: {
+    id: 'rubber',
+    kind: 'noise',
+    scaleMetres: 0.5,
+    roughness: 0.78,
+    albedo: '#2c2c2c',
+    params: { tone: 0.95, mottle: 0.06, relief: 0.0002, size: 0.05, grime: 0.2 },
+    description: 'Vulcanised rubber (tyres, hoses, seals).',
+    sources: [PB, ROBLOX],
+  },
+  canvas: {
+    id: 'canvas',
+    kind: 'weave',
+    scaleMetres: 1,
+    roughness: 0.88,
+    albedo: '#cbbea2',
+    albedo2: '#8a7c62',
+    params: { pitch: 0.004, folds: 0.6, stains: 0.35 },
+    description: 'Cotton duck canvas: natural, weave relief, folds and water stains.',
+    sources: [ROBLOX],
+  },
+  leather: {
+    id: 'leather',
+    kind: 'leather',
+    scaleMetres: 0.5,
+    roughness: 0.58,
+    albedo: '#7c5438',
+    albedo2: '#3e281a',
+    params: { creases: 0.5, wear: 0.4 },
+    description: 'Worn brown leather: pebble grain, dark creases, burnished wear.',
+    sources: [ROBLOX],
+  },
+  plastic: {
+    id: 'plastic',
+    kind: 'noise',
+    scaleMetres: 0.5,
+    roughness: 0.35,
+    albedo: '#ececec',
+    params: { tone: 0.97, mottle: 0.01, relief: 0.00004, size: 0.2 },
+    description: 'Moulded plastic (vertex colour = the plastic colour): satin, even.',
+    sources: [ROBLOX],
+  },
+};

package/src/material/material-def.ts

@@ -0,0 +1,84 @@
+// The material definition contract: what a project (or the house library) says about a strip —
+// PBR numbers, intrinsic colour, a base painter kind and an optional painter layer — and its
+// translation to the sheet's StripRecipe. Validation throws T3D_MATERIAL_INVALID with the fix.
+
+import { Ts23dError, type Vec3 } from '../core/index.ts';
+import type { MaterialPainter, StripKind, StripRecipe } from './paint/types.ts';
+import { hex } from './palette.ts';
+import { type TextureSource, validateTexture } from './texture-source.ts';
+
+export interface MaterialDef {
+  /** snake_case, unique; becomes the strip id recipes pass as `strip`. */
+  readonly id: string;
+  /** Base painter the strip starts from. Default 'noise' (a quiet surface). */
+  readonly kind?: StripKind;
+  /** World metres the strip's V span represents (typical face height). Default 1. */
+  readonly scaleMetres?: number;
+  /** Perceptual roughness 0..1 (glTF): 0 mirror, 1 chalk. */
+  readonly roughness: number;
+  /** 0 dielectric, 1 metal. Default 0. Avoid in-between values except for dirt/oxide blends. */
+  readonly metalness?: number;
+  /** Intrinsic base colour: sRGB '#rrggbb' or linear RGB. Default white (vertex colour = hue). */
+  readonly albedo?: string | Vec3;
+  /** Second colour the painter blends to (latewood, rust, verdigris, bare wood under paint). */
+  readonly albedo2?: string | Vec3;
+  /** Painter knobs for `kind` (see each painter's header in src/material/paint/). */
+  readonly params?: Readonly<Record<string, number>>;
+  /** Your own layer, painted after `kind`: write height/tone/rough/metal/mix per texel. */
+  readonly paint?: MaterialPainter;
+  /** Paint from a CC0 texture set (opt-in, needs `bun run textures`) instead of `kind`. */
+  readonly texture?: TextureSource;
+  readonly description?: string;
+  /** Where the numbers come from (URLs). */
+  readonly sources?: readonly string[];
+}
+
+const ID = /^[a-z][a-z0-9_]{1,31}$/;
+const unit = (v: number): boolean => Number.isFinite(v) && v >= 0 && v <= 1;
+
+function fail(id: string, cause: string, fix: string): never {
+  throw new Ts23dError('T3D_MATERIAL_INVALID', { cause: `material '${id}': ${cause}`, fix });
+}
+
+function colour(id: string, key: string, v: string | Vec3 | undefined): Vec3 | undefined {
+  if (v === undefined) return undefined;
+  if (typeof v === 'string') {
+    if (!/^#?[0-9a-fA-F]{6}$/.test(v))
+      fail(id, `${key} '${v}' is not a hex colour`, "use '#rrggbb'");
+    return hex(v);
+  }
+  if (!(v.length === 3 && v.every(unit)))
+    fail(id, `${key} [${v}] is not linear RGB 0..1`, "use '#rrggbb' or three numbers in 0..1");
+  return v;
+}
+
+/** Validate a definition and turn it into the strip recipe the sheet painter runs. */
+export function toStripRecipe(d: MaterialDef): StripRecipe {
+  const id = String(d.id);
+  if (!ID.test(id))
+    fail(id, 'id is not snake_case (2–32 chars, starts with a letter)', "e.g. 'teak_deck'");
+  if (!unit(d.roughness)) fail(id, `roughness ${d.roughness}`, 'roughness is 0..1');
+  if (d.metalness !== undefined && !unit(d.metalness))
+    fail(id, `metalness ${d.metalness}`, 'metalness is 0..1 (0 dielectric, 1 metal)');
+  const scale = d.scaleMetres ?? 1;
+  if (!(Number.isFinite(scale) && scale > 0))
+    fail(id, `scaleMetres ${scale}`, 'scaleMetres is the face height in metres, > 0');
+  if (d.paint !== undefined && typeof d.paint !== 'function')
+    fail(id, 'paint is not a function', 'paint is (surface, kit) => void');
+  for (const [k, v] of Object.entries(d.params ?? {}))
+    if (!Number.isFinite(v)) fail(id, `params.${k} is ${v}`, 'params are finite numbers');
+  if (d.texture) validateTexture(id, d.texture);
+  const albedo = colour(id, 'albedo', d.albedo);
+  const albedo2 = colour(id, 'albedo2', d.albedo2);
+  return {
+    kind: d.kind ?? 'noise',
+    scaleMetres: scale,
+    roughness: d.roughness,
+    ...(d.metalness !== undefined ? { metalness: d.metalness } : {}),
+    ...(d.params ? { params: d.params } : {}),
+    ...(albedo ? { albedo } : {}),
+    ...(albedo2 ? { albedo2 } : {}),
+    ...(d.paint ? { paint: d.paint } : {}),
+    ...(d.texture ? { texture: d.texture } : {}),
+  };
+}

package/src/material/paint/bond.ts

@@ -0,0 +1,60 @@
+// Brick and stone bond (kind 'bond'): staggered courses, recessed mortar with chipped edges,
+// per-unit tone and tilt, face pitting. Stone is the same bond with `irregular` > 0 and bigger,
+// rougher units.
+// params: course 0.075 · length 0.225 · mortar 0.01 · depth 0.006 · bevel 0.004 · irregular 0
+//         stagger 0.5 · relief 0.0008 (face roughness amplitude, m) · variation 0.3 (tone spread)
+
+import { type Canvas, noiseAt, param, smooth } from './canvas.ts';
+import { Courses } from './courses.ts';
+import { hash2 } from './noise.ts';
+import type { StripRecipe } from './types.ts';
+
+export function paintBond(c: Canvas, r: StripRecipe, seed: number): void {
+  const p = r.params;
+  const mortar = param(p, 'mortar', 0.01);
+  const depth = param(p, 'depth', 0.006);
+  const bevel = param(p, 'bevel', 0.004);
+  const relief = param(p, 'relief', 0.0008);
+  const variation = param(p, 'variation', 0.3);
+  const course = param(p, 'course', 0.075);
+  const length = param(p, 'length', 0.225);
+  const courses = new Courses(c, {
+    course,
+    length,
+    irregular: param(p, 'irregular', 0),
+    stagger: param(p, 'stagger', 0.5),
+    seed,
+  });
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const half = mortar / 2;
+  for (let y = 0; y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const k = courses.at(ym);
+    const dy = Math.min(ym - courses.y0, courses.y1 - ym);
+    for (let x = 0; x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const unit = courses.id[x] ?? 0;
+      const chip = noiseAt(c, xm, ym, 0.02, 0.02, seed + 7, 3) * mortar * 0.6;
+      const d = Math.min(courses.dx[x] ?? 0, dy) + chip;
+      const fine = noiseAt(c, xm, ym, 0.006, 0.006, seed + 11, 2);
+      if (d < half) {
+        c.height[i] = -depth + fine * 0.0006;
+        c.tone[i] = 0.95 + 0.04 * fine;
+        c.rough[i] = Math.min(1, r.roughness + 0.08);
+        continue;
+      }
+      const h = hash2(k, unit, seed);
+      const h2 = hash2(unit, k, seed + 3);
+      const big = noiseAt(c, xm, ym, length * 0.6, course * 0.8, seed + 5, 3);
+      const edge = smooth(0, bevel, d - half);
+      const tilt = ((h2 - 0.5) * (courses.ux[x] ?? 0) * 0.02 + (h - 0.5) * 0.001) * edge;
+      const pit = fine > 0.55 ? (fine - 0.55) * 0.004 : 0;
+      c.height[i] = -depth * (1 - edge) + relief * big + tilt - pit;
+      c.tone[i] =
+        (0.62 - variation * 0.5 + variation * h) * (1 + 0.15 * big + 0.05 * fine) - pit * 40;
+      c.rough[i] = r.roughness + 0.06 * fine;
+    }
+  }
+}

package/src/material/paint/canvas.ts

@@ -0,0 +1,101 @@
+// The painting surface for one sheet region (a strip or a cell): float layers in real metres.
+// Painters write height (metres of relief, + is out of the surface), linear grey tone,
+// roughness, metalness and a two-colour `mix`; `compose` turns them into albedo + normal + ORM.
+
+import type { Vec3 } from '../../core/index.ts';
+import { fbm } from './noise.ts';
+
+export interface Canvas {
+  readonly w: number;
+  readonly h: number;
+  /** World metres the canvas spans along U (x) and V (y). Row y grows with world up (+V). */
+  readonly metresU: number;
+  readonly metresV: number;
+  /** Strips wrap along U (tile seamlessly); cells clamp. */
+  readonly wrapU: boolean;
+  readonly height: Float32Array;
+  readonly tone: Float32Array;
+  readonly rough: Float32Array;
+  readonly metal: Float32Array;
+  /** Extra occlusion multiplied into the cavity AO (foliage darkens toward the twig). */
+  readonly occl: Float32Array;
+  /** 0 = `colours[0]`, 1 = `colours[1]` (latewood, rust, bare wood under chipped paint…). */
+  readonly mix: Float32Array;
+  /** Linear albedo pair for material strips; null = greyscale (vertex colour carries hue). */
+  colours: readonly [Vec3, Vec3] | null;
+  /** sRGB RGBA override (stamped images, coloured foliage); null when painted greyscale. */
+  rgba: Uint8Array | null;
+  /** Tangent-space normal override (image strips); null = derived from `height`. */
+  normalRgba: Uint8Array | null;
+}
+
+export function createCanvas(
+  w: number,
+  h: number,
+  metresU: number,
+  metresV: number,
+  wrapU: boolean,
+): Canvas {
+  const n = w * h;
+  return {
+    w,
+    h,
+    metresU,
+    metresV,
+    wrapU,
+    height: new Float32Array(n),
+    tone: new Float32Array(n).fill(1),
+    rough: new Float32Array(n).fill(0.8),
+    metal: new Float32Array(n),
+    occl: new Float32Array(n).fill(1),
+    mix: new Float32Array(n),
+    colours: null,
+    rgba: null,
+    normalRgba: null,
+  };
+}
+
+/** Metres per pixel along x and y. */
+export const pxU = (c: Canvas): number => c.metresU / c.w;
+export const pxV = (c: Canvas): number => c.metresV / c.h;
+
+/** Noise period (lattice cells across the canvas width) for a feature size in metres. */
+export function periodFor(c: Canvas, featureMetres: number): number {
+  return c.wrapU ? Math.max(1, Math.round(c.metresU / featureMetres)) : 1 << 20;
+}
+
+/**
+ * fBm sampled at metres (xm, ym) with feature size `sizeU` along U and `sizeV` along V,
+ * snapped so it tiles along U. Returns [-1, 1].
+ */
+export function noiseAt(
+  c: Canvas,
+  xm: number,
+  ym: number,
+  sizeU: number,
+  sizeV: number,
+  seed: number,
+  octaves = 4,
+): number {
+  // Strips are coarse along V: never ask for a feature finer than ~1.5 texels on either axis,
+  // or it aliases into streaks. Scale both axes together so the feature keeps its aspect.
+  const finest = 1.5 * Math.max(c.metresU / c.w, c.metresV / c.h);
+  const k = Math.max(1, finest / Math.min(sizeU, sizeV));
+  const period = periodFor(c, sizeU * k);
+  const cell = c.wrapU ? c.metresU / period : sizeU * k;
+  return fbm(xm / cell, ym / (sizeV * k), period, seed, octaves);
+}
+
+/** Read a parameter with a default, rejecting nothing (validation happens in the generator). */
+export const param = (
+  params: Readonly<Record<string, number>> | undefined,
+  key: string,
+  fallback: number,
+): number => params?.[key] ?? fallback;
+
+export const clamp01 = (v: number): number => Math.min(1, Math.max(0, v));
+
+export const smooth = (e0: number, e1: number, v: number): number => {
+  const t = clamp01((v - e0) / (e1 - e0));
+  return t * t * (3 - 2 * t);
+};

package/src/material/paint/cell.ts

@@ -0,0 +1,39 @@
+// Paint one cell: a stamped image, a foliage card (its own painter; the recipe's roughness scales
+// the leaves), or a decal motif over a backdrop of the recipe's kind.
+
+import { type CellId, isFoliage } from '../trim-sheet.ts';
+import type { Canvas } from './canvas.ts';
+import { paintDoorPanel, paintSign, paintWindowSash } from './cells.ts';
+import { paintClock, paintPorthole, paintSmokebox } from './cells-round.ts';
+import { FOLIAGE_PAINTERS } from './foliage.ts';
+import { stampImage } from './stamp.ts';
+import { paintStrip } from './strip.ts';
+import type { CellImage, StripRecipe } from './types.ts';
+
+type Motif = (c: Canvas, r: StripRecipe, seed: number) => void;
+const MOTIFS: Readonly<Record<string, Motif>> = {
+  window_sash: paintWindowSash,
+  door_panel: paintDoorPanel,
+  clock: paintClock,
+  smokebox: paintSmokebox,
+  sign: paintSign,
+  porthole: paintPorthole,
+};
+
+/** Roughness the foliage painter assumes; a recipe's own roughness rescales it. */
+const LEAF_ROUGHNESS = 0.6;
+
+export function paintCell(c: Canvas, id: CellId, entry: StripRecipe | CellImage, seed: number) {
+  if ('image' in entry) {
+    stampImage(c, entry.image);
+    return;
+  }
+  if (isFoliage(id)) {
+    FOLIAGE_PAINTERS[id](c, seed);
+    const k = entry.roughness / LEAF_ROUGHNESS;
+    for (let i = 0; i < c.rough.length; i++) c.rough[i] = Math.min(1, (c.rough[i] ?? 0.6) * k);
+    return;
+  }
+  paintStrip(c, entry, seed);
+  MOTIFS[id]?.(c, entry, seed + 1);
+}

package/src/material/paint/cells-round.ts

@@ -0,0 +1,119 @@
+// Round decal cells (1 m each), centred, over the cell recipe's backdrop: station clock (bezel,
+// minute and hour ticks, hands at 10:10), locomotive smokebox door (flanged, bolted rim, hinge
+// straps, centre dart with handle), porthole (bolted brass ring, dark glass). Row y grows with
+// world up, so 12 o'clock is +y.
+
+import { type Canvas, noiseAt, smooth } from './canvas.ts';
+import { PANE_TONE } from './cells.ts';
+import { boltRing, dome, segment } from './shapes.ts';
+import type { StripRecipe } from './types.ts';
+
+const TAU = Math.PI * 2;
+
+/** Hand from the centre at clock position `hours` (0..12), length `len`. */
+function hand(px: number, py: number, hours: number, len: number): number {
+  const a = (hours / 12) * TAU;
+  return segment(px, py, 0, 0, Math.sin(a) * len, Math.cos(a) * len);
+}
+
+export function paintClock(c: Canvas, r: StripRecipe, _seed: number): void {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0; y < c.h; y++) {
+    const py = (y + 0.5) * pv - 0.5;
+    for (let x = 0; x < c.w; x++) {
+      const px = (x + 0.5) * pu - 0.5;
+      const i = y * c.w + x;
+      const d = Math.hypot(px, py);
+      if (d > 0.48) continue;
+      const i0 = i;
+      if (d > 0.42) {
+        c.height[i0] = 0.012 * dome(Math.abs(d - 0.45), 0.03);
+        c.tone[i0] = 0.55;
+        c.metal[i0] = 1;
+        c.rough[i0] = 0.35;
+        continue;
+      }
+      const a = Math.atan2(px, py);
+      const minute = Math.abs((((a / TAU) * 60 + 60.5) % 1) - 0.5) * (TAU / 60) * d;
+      const hour = Math.abs((((a / TAU) * 12 + 12.5) % 1) - 0.5) * (TAU / 12) * d;
+      const tickM = d > 0.38 && d < 0.41 && minute < 0.003 ? 1 : 0;
+      const tickH = d > 0.32 && d < 0.41 && hour < 0.008 ? 1 : 0;
+      const hands = Math.min(
+        hand(px, py, 10 + 10 / 60, 0.22) - 0.012,
+        hand(px, py, 2, 0.34) - 0.007,
+      );
+      const ink = Math.max(tickM, tickH, hands < 0 ? 1 : 0, d < 0.02 ? 1 : 0);
+      c.height[i0] = -0.004 + 0.002 * ink;
+      c.tone[i0] = ink ? 0.08 : 0.96;
+      c.rough[i0] = ink ? 0.5 : r.roughness;
+      c.metal[i0] = 0;
+    }
+  }
+}
+
+export function paintSmokebox(c: Canvas, r: StripRecipe, seed: number): void {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const metal = r.metalness ?? 0;
+  for (let y = 0; y < c.h; y++) {
+    const py = (y + 0.5) * pv - 0.5;
+    for (let x = 0; x < c.w; x++) {
+      const px = (x + 0.5) * pu - 0.5;
+      const i = y * c.w + x;
+      const d = Math.hypot(px, py);
+      if (d > 0.47) continue;
+      const pit = noiseAt(c, px + 0.5, py + 0.5, 0.03, 0.03, seed, 3);
+      // Slightly dished door, a raised flange, a bolt ring just inside it.
+      let h = 0.01 * (1 - (d / 0.47) ** 2) + 0.0004 * pit;
+      const flange = dome(Math.abs(d - 0.45), 0.02);
+      h += 0.006 * flange;
+      const bolt = dome(boltRing(px, py, 0.415, 28), 0.011);
+      h += 0.006 * bolt;
+      // Two hinge straps from the left rim to the dart's line, ending in a rounded tip.
+      const strap = Math.min(
+        segment(px, py, -0.47, 0.17, 0.12, 0.17),
+        segment(px, py, -0.47, -0.17, 0.12, -0.17),
+      );
+      const strapH = smooth(0.024, 0.018, strap);
+      h = Math.max(h, 0.014 * strapH + h * (1 - strapH));
+      const boss = dome(d, 0.05);
+      const handle = smooth(0.012, 0.008, segment(px, py, -0.13, 0, 0.13, 0));
+      h += 0.02 * boss + 0.012 * handle;
+      c.height[i] = h;
+      c.tone[i] =
+        (0.5 + 0.05 * pit) * (1 + 0.5 * Math.max(bolt, handle, strapH * 0.6, flange, boss));
+      c.rough[i] = r.roughness - 0.15 * Math.max(bolt, handle, boss);
+      c.metal[i] = metal + (1 - metal) * Math.max(handle, boss) * 0.8;
+    }
+  }
+}
+
+export function paintPorthole(c: Canvas, r: StripRecipe, seed: number): void {
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0; y < c.h; y++) {
+    const py = (y + 0.5) * pv - 0.5;
+    for (let x = 0; x < c.w; x++) {
+      const px = (x + 0.5) * pu - 0.5;
+      const i = y * c.w + x;
+      const d = Math.hypot(px, py);
+      if (d > 0.44) continue;
+      if (d < 0.29) {
+        const sky = noiseAt(c, px + 0.5, py + 0.5, 0.5, 0.5, seed, 2);
+        c.height[i] = -0.012;
+        c.tone[i] = PANE_TONE + 0.04 * (py + 0.3) + 0.02 * sky;
+        c.rough[i] = 0.05;
+        c.metal[i] = 0;
+        continue;
+      }
+      const ring = dome(Math.abs(d - 0.365), 0.075);
+      const bolt = dome(boltRing(px, py, 0.405, 10, Math.PI / 10), 0.018);
+      const lip = dome(Math.abs(d - 0.3), 0.012);
+      c.height[i] = 0.016 * ring + 0.008 * bolt + 0.004 * lip;
+      c.tone[i] = 0.75 + 0.15 * ring;
+      c.rough[i] = Math.max(0.2, r.roughness - 0.2 * ring);
+      c.metal[i] = 1;
+    }
+  }
+}