@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/src/material/generator.ts

@@ -0,0 +1,56 @@
+// Procedural material generator: paints the shared trim sheet (albedo, normal, ORM) from code —
+// brick bonds, plank grain, riveted plates, slate, concrete, glass, decal cells and cutout foliage
+// cards — at a fixed seed, so the texture is as deterministic as the meshes. Supplied PNGs (reference
+// photos, kubeez.com generations) can stamp cells; they are inputs, never the only path.
+//
+// Conventions: V (image row) grows with world up, as box/planar map faces; strips tile seamlessly
+// along U and span `stripRect().metres` there and `scaleMetres` along V; albedo is near-greyscale
+// sRGB (vertex colour tints it) except foliage and stamped cells, which carry colour + alpha.
+
+import { createRng } from '../core/index.ts';
+import { createCanvas } from './paint/canvas.ts';
+import { paintCell } from './paint/cell.ts';
+import { blankSheet, composeRegion } from './paint/compose.ts';
+import { DEFAULT_SHEET } from './paint/default-sheet.ts';
+import { paintStrip } from './paint/strip.ts';
+import type { PaintedSheet, SheetRecipe } from './paint/types.ts';
+import { validateSheet, validateStrip } from './paint/validate.ts';
+import { CELLS, cellRect, STRIPS, stripRect } from './trim-sheet.ts';
+
+export { DEFAULT_SHEET } from './paint/default-sheet.ts';
+export type {
+  CellImage,
+  PaintedSheet,
+  SheetRecipe,
+  StripKind,
+  StripRecipe,
+} from './paint/types.ts';
+
+const FALLBACK = { kind: 'noise', scaleMetres: 1, roughness: 0.6 } as const;
+
+export function paintTrimSheet(recipe: SheetRecipe = DEFAULT_SHEET): PaintedSheet {
+  validateSheet(recipe);
+  const size = recipe.size ?? 1024;
+  const sheet = blankSheet(size);
+  const rng = createRng(recipe.seed);
+  const seedOf = (name: string): number => rng.fork(name).int(0, 0x7fffffff);
+  const pad = Math.max(2, size / 256);
+  for (const id of STRIPS) {
+    const r = recipe.strips[id] ?? DEFAULT_SHEET.strips[id] ?? FALLBACK;
+    validateStrip(`strips.${id}`, r);
+    const rect = stripRect(id);
+    const h = Math.round((rect.v1 - rect.v0) * size);
+    const c = createCanvas(size, h, rect.metres, r.scaleMetres, true);
+    paintStrip(c, r, seedOf(id));
+    composeRegion(sheet, c, 0, Math.round(rect.v0 * size), pad);
+  }
+  for (const id of CELLS) {
+    const e = recipe.cells?.[id] ?? DEFAULT_SHEET.cells?.[id] ?? FALLBACK;
+    const rect = cellRect(id);
+    const w = Math.round((rect.u1 - rect.u0) * size);
+    const c = createCanvas(w, w, rect.metres, rect.metres, false);
+    paintCell(c, id, e, seedOf(id));
+    composeRegion(sheet, c, Math.round(rect.u0 * size), Math.round(rect.v0 * size), pad);
+  }
+  return sheet;
+}

package/src/material/index.ts

@@ -0,0 +1,29 @@
+// Public API of @ts23d/material: the shared trim-sheet layout, the procedural sheet painter,
+// palettes and engine shader sources.
+
+export {
+  type CellImage,
+  DEFAULT_SHEET,
+  type PaintedSheet,
+  paintTrimSheet,
+  type SheetRecipe,
+  type StripKind,
+  type StripRecipe,
+} from './generator.ts';
+export { definePalette, hex, type Palette, palettes } from './palette.ts';
+export { godotShaderSource, type ShaderHints, threeMaterialSource } from './shader.ts';
+export {
+  CELLS,
+  type CellId,
+  cellRect,
+  DECAL_CELLS,
+  type DecalCellId,
+  FOLIAGE_CELLS,
+  type FoliageCellId,
+  isFoliage,
+  STRIPS,
+  type StripId,
+  stripRect,
+  TRIM_SHEET_SIZE,
+  type UvRect,
+} from './trim-sheet.ts';

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,91 @@
+// 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 and metalness; `finish` turns them into normal + ORM; `compose` copies into the sheet.
+
+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;
+  /** sRGB RGBA override (stamped images, coloured foliage); null when painted greyscale. */
+  rgba: 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),
+    rgba: 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;
+    }
+  }
+}

package/src/material/paint/cells.ts

@@ -0,0 +1,111 @@
+// Rectangular decal cells (1 m each), painted over a backdrop of the cell recipe's own kind:
+// window sash (glazing bars, dark panes the shaders' window glow keys on), four-panel door with
+// raised-and-fielded panels, sign blank with a moulded border and corner screws. Row y grows with
+// world up, so "bottom rail" is low y.
+// params (window_sash): cols 2 · rows 2 (panes per sash) · frame 0.07 · bar 0.022
+// params (door_panel): stile 0.12
+
+import { type Canvas, noiseAt, param, smooth } from './canvas.ts';
+import { dome, rect } from './shapes.ts';
+import type { StripRecipe } from './types.ts';
+
+/** Pane tone: dark enough that `luma < 0.3` marks glass for window glow. */
+export const PANE_TONE = 0.12;
+
+export function paintWindowSash(c: Canvas, r: StripRecipe, seed: number): void {
+  const cols = param(r.params, 'cols', 2);
+  const rows = param(r.params, 'rows', 2);
+  const frame = param(r.params, 'frame', 0.07);
+  const bar = param(r.params, 'bar', 0.022);
+  const meet = 0.5;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  for (let y = 0; y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const lower = ym < meet;
+    const y0 = lower ? frame : meet + bar;
+    const y1 = lower ? meet - bar : 1 - frame;
+    for (let x = 0; x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const i = y * c.w + x;
+      // Distance into a pane: inside the sash opening, away from every glazing bar.
+      const fx = ((xm - frame) / (1 - 2 * frame)) * cols;
+      const fy = ((ym - y0) / (y1 - y0)) * rows;
+      const inX = Math.min(fx - Math.floor(fx), Math.ceil(fx) - fx) * ((1 - 2 * frame) / cols);
+      const inY = Math.min(fy - Math.floor(fy), Math.ceil(fy) - fy) * ((y1 - y0) / rows);
+      const open = -rect(xm, ym, frame, y0, 1 - frame, y1);
+      const pane = Math.min(open, inX - bar / 2, inY - bar / 2);
+      const wood = noiseAt(c, xm, ym, 0.3, 0.02, seed, 3);
+      if (pane > 0) {
+        const sky = noiseAt(c, xm, ym, 0.6, 0.6, seed + 1, 2);
+        c.height[i] = -0.012;
+        c.tone[i] = PANE_TONE + 0.05 * (ym - y0) + 0.03 * sky;
+        c.rough[i] = 0.05;
+        c.metal[i] = 0;
+      } else {
+        const bevel = smooth(0, 0.01, -pane);
+        c.height[i] = -0.012 * (1 - bevel) + 0.0003 * wood;
+        c.tone[i] = 0.9 + 0.03 * wood;
+        c.rough[i] = r.roughness;
+      }
+    }
+  }
+}
+
+export function paintDoorPanel(c: Canvas, r: StripRecipe, seed: number): void {
+  const stile = param(r.params, 'stile', 0.12);
+  const muntin = stile * 0.7;
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  // Four panels: two tall above the lock rail, two short below. [x0, y0, x1, y1].
+  const midX = 0.5;
+  const panels = [
+    [stile, 0.2, midX - muntin / 2, 0.42],
+    [midX + muntin / 2, 0.2, 1 - stile, 0.42],
+    [stile, 0.58, midX - muntin / 2, 1 - stile],
+    [midX + muntin / 2, 0.58, 1 - stile, 1 - stile],
+  ] as const;
+  for (let y = 0; y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0; x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const i = y * c.w + x;
+      let d = 1;
+      for (const [x0, y0, x1, y1] of panels) d = Math.min(d, rect(xm, ym, x0, y0, x1, y1));
+      const grain = noiseAt(c, xm, ym, 0.02, 0.4, seed, 3);
+      // Recess, then a bevel rising to the raised field 0.04 m in from the panel edge.
+      const recess = d < 0 ? 1 : 1 - smooth(0, 0.006, d);
+      const field = smooth(0.005, 0.04, -d);
+      c.height[i] = -0.012 * recess + 0.008 * field + 0.0003 * grain;
+      c.tone[i] = (0.8 + 0.08 * grain) * (d < 0 && d > -0.008 ? 0.65 : d < 0 ? 0.92 : 1);
+      c.rough[i] = r.roughness + 0.05 * grain;
+    }
+  }
+}
+
+export function paintSign(c: Canvas, r: StripRecipe, _seed: number): void {
+  const border = param(r.params, 'border', 0.05);
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const screws = [0.07, 0.93];
+  for (let y = 0; y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    for (let x = 0; x < c.w; x++) {
+      const xm = (x + 0.5) * pu;
+      const i = y * c.w + x;
+      const inner = -rect(xm, ym, border, border, 1 - border, 1 - border);
+      const edge = Math.min(xm, ym, 1 - xm, 1 - ym);
+      const moulding = inner < 0 ? dome(Math.abs(-inner - border / 2), border / 2) : 0;
+      let screw = 0;
+      for (const sx of screws)
+        for (const sy of screws) screw = Math.max(screw, dome(Math.hypot(xm - sx, ym - sy), 0.012));
+      c.height[i] = 0.006 * moulding + 0.002 * screw - 0.002 * (1 - smooth(0, 0.004, edge));
+      c.tone[i] = inner > 0 ? 0.95 : 0.85 + 0.1 * moulding;
+      if (screw > 0) {
+        c.tone[i] = 0.6;
+        c.metal[i] = 1;
+        c.rough[i] = 0.35;
+      }
+    }
+  }
+}

package/src/material/paint/compose.ts

@@ -0,0 +1,53 @@
+// Finish a region canvas (AO, normal, ORM, albedo) and blit it into the sheet. Edge texels are
+// replicated `pad` deep (rows for strips, rows + columns for cells) so the first mip levels never
+// sample a neighbouring region.
+
+import type { Canvas } from './canvas.ts';
+import { sobelNormals } from './normal.ts';
+import { cavityOcclusion, packAlbedo, packOrm } from './orm.ts';
+import type { PaintedSheet } from './types.ts';
+
+/** An empty sheet: white albedo (vertex colour reads true), flat normal, AO 1, rough 0.8. */
+export function blankSheet(size: number): PaintedSheet {
+  const n = size * size * 4;
+  const albedo = new Uint8Array(n).fill(255);
+  const normal = new Uint8Array(n);
+  const orm = new Uint8Array(n);
+  const flat = new Uint8Array([128, 128, 255, 255]);
+  const base = new Uint8Array([255, 204, 0, 255]);
+  for (let i = 0; i < n; i += 4) {
+    normal.set(flat, i);
+    orm.set(base, i);
+  }
+  return { size, albedo, normal, orm };
+}
+
+export function composeRegion(
+  sheet: PaintedSheet,
+  c: Canvas,
+  x0: number,
+  y0: number,
+  pad: number,
+): void {
+  const ao = cavityOcclusion(c);
+  const maps = [
+    [sheet.albedo, packAlbedo(c, ao)],
+    [sheet.normal, sobelNormals(c)],
+    [sheet.orm, packOrm(c, ao)],
+  ] as const;
+  const padX = c.wrapU ? 0 : pad;
+  for (let y = 0; y < c.h; y++) {
+    const sy = Math.min(c.h - 1 - pad, Math.max(pad, y));
+    const dst = ((y0 + y) * sheet.size + x0) * 4;
+    const src = sy * c.w;
+    const l = (src + padX) * 4;
+    const r = (src + c.w - 1 - padX) * 4;
+    for (const [to, from] of maps) {
+      to.set(from.subarray(l, r + 4), dst + padX * 4);
+      for (let x = 0; x < padX; x++) {
+        to.set(from.subarray(l, l + 4), dst + x * 4);
+        to.set(from.subarray(r, r + 4), dst + (c.w - 1 - x) * 4);
+      }
+    }
+  }
+}

package/src/material/paint/concrete.ts

@@ -0,0 +1,62 @@
+// Cast concrete (kind 'concrete'): mottled cement tone, air-void pores, pour-lift lines and
+// formwork tie holes on a grid.
+// params: pores 0.35 (fraction of 8 mm cells holding a void) · ties 0.6 (tie grid, m; 0 = none)
+//         lift 0.6 (pour lift spacing, m; 0 = none) · mottle 0.1
+
+import { type Canvas, noiseAt, param, periodFor, smooth } from './canvas.ts';
+import { hash2 } from './noise.ts';
+import type { StripRecipe } from './types.ts';
+
+const PORE_CELL = 0.008;
+
+export function paintConcrete(c: Canvas, r: StripRecipe, seed: number): void {
+  const p = r.params;
+  const pores = param(p, 'pores', 0.35);
+  const ties = param(p, 'ties', 0.6);
+  const lift = param(p, 'lift', 0.6);
+  const mottle = param(p, 'mottle', 0.1);
+  const pu = c.metresU / c.w;
+  const pv = c.metresV / c.h;
+  const cellM = Math.max(PORE_CELL, 2.5 * Math.max(pu, pv));
+  const pPer = periodFor(c, cellM);
+  const pCell = c.wrapU ? c.metresU / pPer : cellM;
+  const tPer = ties > 0 ? periodFor(c, ties) : 1;
+  const tCell = c.wrapU ? c.metresU / tPer : ties;
+  for (let y = 0; y < c.h; y++) {
+    const ym = (y + 0.5) * pv;
+    const liftD = lift > 0 ? Math.abs(ym - Math.round(ym / lift) * lift) : 1;
+    const liftGroove = 1 - smooth(0, 0.003, liftD);
+    const liftBand = lift > 0 ? hash2(Math.floor(ym / lift), 0, seed + 4) - 0.5 : 0;
+    for (let x = 0; x < c.w; x++) {
+      const i = y * c.w + x;
+      const xm = (x + 0.5) * pu;
+      const big = noiseAt(c, xm, ym, 0.25, 0.25, seed, 4);
+      const fine = noiseAt(c, xm, ym, 0.004, 0.004, seed + 2, 2);
+      const ix = Math.floor(xm / pCell) % pPer;
+      const iy = Math.floor(ym / pCell);
+      let pit = 0;
+      if (hash2(ix, iy, seed + 5) < pores) {
+        const cx = (ix + 0.2 + 0.6 * hash2(ix, iy, seed + 6)) * pCell;
+        const cy = (iy + 0.2 + 0.6 * hash2(ix, iy, seed + 7)) * pCell;
+        const rad = pCell * (0.12 + 0.25 * hash2(ix, iy, seed + 8));
+        const d = Math.hypot(xm - cx, ym - cy);
+        pit = d < rad ? 1 - d / rad : 0;
+      }
+      let tie = 0;
+      if (ties > 0) {
+        const tx = xm - (Math.floor(xm / tCell) + 0.5) * tCell;
+        const ty = ym - (Math.floor(ym / ties) + 0.5) * ties;
+        const d = Math.hypot(tx, ty);
+        tie = d < 0.012 ? 1 : 0;
+      }
+      c.height[i] =
+        0.0005 * big + 0.00015 * fine - 0.0015 * pit - 0.006 * tie - 0.0012 * liftGroove;
+      c.tone[i] =
+        (0.78 + mottle * big + 0.05 * liftBand) *
+        (1 + 0.04 * fine) *
+        (1 - 0.4 * pit) *
+        (1 - 0.5 * tie);
+      c.rough[i] = r.roughness + 0.05 * fine + 0.05 * big;
+    }
+  }
+}