@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/src/material/shader.ts

@@ -0,0 +1,100 @@
+// Engine shader sources for the trim-sheet material: per-asset effects that stay on the one shared
+// material — vertex-colour tint, wind sway, night window glow, wear/grime. Both functions return
+// plain source strings (a three.js TSL module, a Godot 4 .gdshader). They are STARTING POINTS an
+// engine project loads and owns, not runtime dependencies: ts23d never imports three or Godot.
+//
+// Shared conventions both sources implement:
+//   tint      albedo.rgb × COLOR_0.rgb (linear), alpha from albedo.a (cutout leaf masks)
+//   ORM       R occlusion · G roughness · B metalness (one texture, as the GLB binds it)
+//   wind      weight from the `_WIND` vertex attribute (three: `_wind`) or, by default, the
+//             mesh-local height (authored Z-up), smoothstep(0, wind.height, z); sway in local XY
+//   glow      emissive on window panes: window_sash/porthole texels darker than luma 0.3, and the
+//             whole glass strip; a world-space 1.5 m hash lights `ratio` of windows; × `night`
+//   wear      darkens + roughens cavities (1 − AO) and the first `grimeHeight` metres of world height
+
+import type { Surface } from '../core/index.ts';
+import { Ts23dError } from '../core/index.ts';
+import { godotSource } from './shader-godot.ts';
+import { threeSource } from './shader-three.ts';
+import { cellRect, stripRect, type UvRect } from './trim-sheet.ts';
+
+export interface ShaderHints {
+  /** Vertex sway for vegetation. Weight from the `_WIND` attribute or mesh-local height. */
+  readonly wind?: {
+    readonly strength: number;
+    readonly source?: 'attribute' | 'height';
+    /** Metres of height at which sway reaches full weight (height source). Default 4. */
+    readonly height?: number;
+    readonly hz?: number;
+  };
+  /** Emissive mask on window cells at night: `ratio` of windows lit. */
+  readonly windowGlow?: {
+    readonly color: string;
+    readonly ratio: number;
+    readonly intensity?: number;
+  };
+  /** Wear/grime mask strength 0..1 and how high ground grime climbs (metres). */
+  readonly wear?: { readonly amount: number; readonly grimeHeight?: number };
+  /** The surface the material is for: 'cutout' adds alpha test + double-sided. */
+  readonly surface?: Surface;
+}
+
+/** Resolved, validated numbers both emitters print. */
+export interface ShaderParams {
+  readonly windStrength: number;
+  readonly windAttribute: boolean;
+  readonly windHeight: number;
+  readonly windHz: number;
+  readonly glow: readonly [number, number, number];
+  readonly glowRatio: number;
+  readonly glowIntensity: number;
+  readonly wear: number;
+  readonly grimeHeight: number;
+  readonly cutout: boolean;
+  readonly blend: boolean;
+  readonly glowRects: readonly UvRect[];
+  readonly glassRect: UvRect;
+}
+
+function fail(cause: string, fix: string): never {
+  throw new Ts23dError('T3D_RECIPE_INVALID', { cause: `shader hints: ${cause}`, fix });
+}
+
+function srgbHex(value: string): [number, number, number] {
+  if (!/^#[0-9a-fA-F]{6}$/.test(value)) fail(`colour '${value}'`, "use '#rrggbb' sRGB hex");
+  const n = Number.parseInt(value.slice(1), 16);
+  return [((n >> 16) & 255) / 255, ((n >> 8) & 255) / 255, (n & 255) / 255];
+}
+
+export function resolveHints(h: ShaderHints): ShaderParams {
+  const unit = (v: number, what: string): number =>
+    Number.isFinite(v) && v >= 0 && v <= 1 ? v : fail(`${what} is ${v}`, `${what} is 0..1`);
+  const pos = (v: number, what: string): number =>
+    Number.isFinite(v) && v > 0 ? v : fail(`${what} is ${v}`, `${what} is a positive number`);
+  const strength = h.wind ? pos(h.wind.strength, 'wind.strength') : 0;
+  return {
+    windStrength: strength,
+    windAttribute: h.wind?.source === 'attribute',
+    windHeight: pos(h.wind?.height ?? 4, 'wind.height'),
+    windHz: pos(h.wind?.hz ?? 0.4, 'wind.hz'),
+    glow: h.windowGlow ? srgbHex(h.windowGlow.color) : [1, 0.75, 0.4],
+    glowRatio: h.windowGlow ? unit(h.windowGlow.ratio, 'windowGlow.ratio') : 0,
+    glowIntensity: pos(h.windowGlow?.intensity ?? 2, 'windowGlow.intensity'),
+    wear: h.wear ? unit(h.wear.amount, 'wear.amount') : 0,
+    grimeHeight: pos(h.wear?.grimeHeight ?? 0.6, 'wear.grimeHeight'),
+    cutout: h.surface === 'cutout',
+    blend: h.surface === 'glass' || h.surface === 'translucent',
+    glowRects: [cellRect('window_sash'), cellRect('porthole')],
+    glassRect: stripRect('glass'),
+  };
+}
+
+/** A three.js (r18x, WebGPU/TSL) TypeScript module: `createTrimMaterial(maps)` + `upgradeTrimMaterials(root)`. */
+export function threeMaterialSource(hints: ShaderHints = {}): string {
+  return threeSource(resolveHints(hints));
+}
+
+/** A Godot 4 spatial shader (.gdshader) with the same features and uniform names. */
+export function godotShaderSource(hints: ShaderHints = {}): string {
+  return godotSource(resolveHints(hints));
+}

package/src/material/trim-sheet.ts

@@ -0,0 +1,100 @@
+// The shared trim sheet: ONE 1024² atlas (albedo + normal + ORM) every asset maps into, so every
+// asset is one material and one draw call. Strips tile along U; cells are fixed decals.
+// Layout is data here; `paintTrimSheet` (generator.ts) paints it. V grows with world up on
+// box/planar faces. Foliage cells (cutout leaf cards, alpha = leaf mask) sit in their own rows.
+
+export type StripId =
+  | 'plain'
+  | 'brick'
+  | 'stone'
+  | 'slate'
+  | 'iron'
+  | 'wood'
+  | 'glass'
+  | 'concrete';
+export type DecalCellId = 'window_sash' | 'door_panel' | 'clock' | 'smokebox' | 'sign' | 'porthole';
+/** Cutout leaf cards: the anchor (twig base) is the cell's bottom-centre, growth toward +V. */
+export type FoliageCellId =
+  | 'foliage_broadleaf'
+  | 'foliage_maple'
+  | 'foliage_maple_autumn'
+  | 'foliage_birch'
+  | 'foliage_acacia'
+  | 'foliage_palm'
+  | 'foliage_spruce'
+  | 'foliage_spruce_snow'
+  | 'foliage_willow'
+  | 'foliage_reeds'
+  | 'foliage_needles';
+export type CellId = DecalCellId | FoliageCellId;
+
+export interface UvRect {
+  readonly u0: number;
+  readonly v0: number;
+  readonly u1: number;
+  readonly v1: number;
+  /** Metres of world surface one full rect covers, so texel density is equal across assets. */
+  readonly metres: number;
+}
+
+const STRIP_H = 1 / 16;
+const strips: readonly StripId[] = [
+  'plain',
+  'brick',
+  'stone',
+  'slate',
+  'iron',
+  'wood',
+  'glass',
+  'concrete',
+];
+const decals: readonly DecalCellId[] = [
+  'window_sash',
+  'door_panel',
+  'clock',
+  'smokebox',
+  'sign',
+  'porthole',
+];
+const foliage: readonly FoliageCellId[] = [
+  'foliage_broadleaf',
+  'foliage_maple',
+  'foliage_maple_autumn',
+  'foliage_birch',
+  'foliage_acacia',
+  'foliage_palm',
+  'foliage_spruce',
+  'foliage_spruce_snow',
+  'foliage_willow',
+  'foliage_reeds',
+  'foliage_needles',
+];
+const cells: readonly CellId[] = [...decals, ...foliage];
+/** Decals fill row 0 of the cell region (V 0.5); foliage starts on row 1 (V 0.625). */
+const FOLIAGE_SLOT = 8;
+const slotOf = (id: CellId): number => {
+  const d = decals.indexOf(id as DecalCellId);
+  return d >= 0 ? d : FOLIAGE_SLOT + foliage.indexOf(id as FoliageCellId);
+};
+
+export const TRIM_SHEET_SIZE = 1024;
+
+export function stripRect(id: StripId): UvRect {
+  const i = strips.indexOf(id);
+  return { u0: 0, v0: i * STRIP_H, u1: 1, v1: (i + 1) * STRIP_H, metres: 2 };
+}
+
+/** Cells sit in the lower half (V ≥ 0.5), 8 per row: decals on row 0, foliage from row 1. */
+export function cellRect(id: CellId): UvRect {
+  const i = slotOf(id);
+  const size = 1 / 8;
+  const u0 = (i % 8) * size;
+  const v0 = 0.5 + Math.floor(i / 8) * size;
+  return { u0, v0, u1: u0 + size, v1: v0 + size, metres: 1 };
+}
+
+export const STRIPS = strips;
+export const CELLS = cells;
+export const DECAL_CELLS = decals;
+export const FOLIAGE_CELLS = foliage;
+export const isFoliage = (id: CellId): id is FoliageCellId => id.startsWith('foliage_');

package/src/neural/generator.ts

@@ -0,0 +1,37 @@
+// Optional seam for organic shapes the recipe approach handles poorly: people, animals, sculpted
+// rocks. Runs an open-weight image/text-to-3D model on the USER's GPU (TRELLIS, Hunyuan3D, SF3D…)
+// behind a local HTTP endpoint, then wraps the result as an ordinary part. Never a core dependency.
+//
+// Determinism: a generated mesh is cached by (model, prompt/image hash, seed) under
+// .ts23d/neural/ and committed or published like any asset, so CI rebuilds without a GPU.
+
+import { type Mesh, notImplemented, type Vec3 } from '../core/index.ts';
+
+export interface GenerateRequest {
+  readonly prompt?: string;
+  /** PNG/JPEG bytes of a reference or concept image. */
+  readonly image?: Uint8Array;
+  readonly seed: number;
+  /** Fit the result into this box (metres), Z up, base on the ground. */
+  readonly fit: Vec3;
+  readonly targetTriangles: number;
+}
+
+export interface MeshGenerator {
+  /** e.g. 'trellis-2', 'hunyuan3d-2.1', 'sf3d'. Part of the cache key. */
+  readonly model: string;
+  generate(request: GenerateRequest): Promise<Mesh>;
+}
+
+/** Talks to a local server (e.g. a ComfyUI / gradio wrapper) at `endpoint`. Planned: M5. */
+export function localGenerator(_o: { model: string; endpoint: string }): MeshGenerator {
+  return notImplemented(
+    'localGenerator (local GPU model adapter)',
+    'docs/idea/08-neural-adapters.md',
+  );
+}
+
+/** Import an existing GLB (a CC0 base mesh, a sculpt, a generator's output) as a part. Planned: M5. */
+export function importGlb(_bytes: Uint8Array, _o: { fit: Vec3; recolor?: Vec3 }): Mesh {
+  return notImplemented('importGlb', 'docs/idea/08-neural-adapters.md');
+}

package/src/neural/images.ts

@@ -0,0 +1,27 @@
+// Image sources for the material generator and the agent loop: reference/concept images, decals,
+// texture source photos. kubeez.com is the recommended hosted source; any function returning PNG
+// bytes fits. Results are cached by (source, prompt, seed) like generated meshes. Planned: M5.
+
+import { notImplemented } from '../core/index.ts';
+
+export interface ImageRequest {
+  readonly prompt: string;
+  readonly seed: number;
+  readonly width: number;
+  readonly height: number;
+  /** e.g. 'decal', 'tileable', 'reference', 'concept'. */
+  readonly purpose: 'decal' | 'tileable' | 'reference' | 'concept';
+}
+
+export interface ImageSource {
+  readonly name: string;
+  generate(request: ImageRequest): Promise<Uint8Array>;
+}
+
+/** kubeez.com image generation. Reads the key from the caller, never from ambient env. */
+export function kubeezImages(_o: { apiKey: string; model?: string }): ImageSource {
+  return notImplemented(
+    'kubeezImages (kubeez.com image source)',
+    'docs/idea/08-neural-adapters.md',
+  );
+}

package/src/neural/index.ts

@@ -0,0 +1,10 @@
+// Public API of /neural: optional AI adapters — local-GPU mesh generators for organic shapes,
+// mesh import, and image sources (kubeez.com) for references and materials. Never required.
+
+export {
+  type GenerateRequest,
+  importGlb,
+  localGenerator,
+  type MeshGenerator,
+} from './generator.ts';
+export { type ImageRequest, type ImageSource, kubeezImages } from './images.ts';

package/src/passes/bake-ao.ts

@@ -0,0 +1,183 @@
+// Ambient occlusion baked into vertex colour: the cheapest big look upgrade for a vertex-coloured
+// asset — creases, wheel wells and the gap under a turret darken, as a lit render would. Each
+// vertex fires a fixed cosine-weighted hemisphere of rays (Fibonacci spiral, no randomness) at the
+// asset's own triangles (and optionally the ground plane); the hit fraction darkens its colour.
+
+import { type CompiledAsset, type Mesh, merge, type Vec3, worldMeshes } from '../core/index.ts';
+import { RayGrid } from './ray-grid.ts';
+
+export interface AoOptions {
+  /** Rays per vertex. Default 24. */
+  readonly samples?: number;
+  /** Occluders farther than this (metres) don't count. Default 1. */
+  readonly radius?: number;
+  /** 0 = no change, 1 = fully occluded vertices go black. Default 0.6. */
+  readonly strength?: number;
+  /** Treat z = 0 as a ground plane (contact shadow under the asset). Default true. */
+  readonly ground?: boolean;
+}
+
+const GOLDEN = Math.PI * (3 - Math.sqrt(5));
+
+/** Fixed cosine-weighted directions around +Z. */
+function hemisphere(n: number): Vec3[] {
+  return Array.from({ length: n }, (_, i) => {
+    const r = Math.sqrt((i + 0.5) / n);
+    const phi = i * GOLDEN;
+    return [r * Math.cos(phi), r * Math.sin(phi), Math.sqrt(Math.max(0, 1 - r * r))] as Vec3;
+  });
+}
+
+/** Orthonormal frame with `n` as its Z (Frisvad / Duff et al. branchless basis). */
+function frame(n: Vec3): [Vec3, Vec3] {
+  const s = n[2] >= 0 ? 1 : -1;
+  const a = -1 / (s + n[2]);
+  const b = n[0] * n[1] * a;
+  return [
+    [1 + s * n[0] * n[0] * a, s * b, -s * n[0]],
+    [b, s + n[1] * n[1] * a, -n[1]],
+  ];
+}
+
+/**
+ * Vertices sharing a position (0.1 mm) and normal (0.001) share one result: welded seams and
+ * duplicated soup vertices cost one hemisphere, not many. Open addressing on the six integers.
+ */
+class Memo {
+  private readonly keys: Float64Array;
+  private readonly vals: Float64Array;
+  private readonly used: Uint8Array;
+  private readonly mask: number;
+
+  constructor(n: number) {
+    let cap = 16;
+    while (cap < n * 2) cap *= 2;
+    this.mask = cap - 1;
+    this.keys = new Float64Array(cap * 6);
+    this.vals = new Float64Array(cap);
+    this.used = new Uint8Array(cap);
+  }
+
+  /** Slot for the key; `found` tells whether it already holds a value. */
+  slot(k: Float64Array): { at: number; found: boolean } {
+    let h = 2166136261;
+    for (let i = 0; i < 6; i++) h = Math.imul(h ^ ((k[i] ?? 0) | 0), 16777619);
+    let at = (h >>> 0) & this.mask;
+    for (;;) {
+      if (!this.used[at]) return { at, found: false };
+      let same = true;
+      for (let i = 0; i < 6 && same; i++) same = this.keys[at * 6 + i] === k[i];
+      if (same) return { at, found: true };
+      at = (at + 1) & this.mask;
+    }
+  }
+
+  get(at: number): number {
+    return this.vals[at] ?? 0;
+  }
+
+  set(at: number, k: Float64Array, v: number): void {
+    this.used[at] = 1;
+    this.keys.set(k, at * 6);
+    this.vals[at] = v;
+  }
+}
+
+/** Per-vertex visibility (1 = open sky, 0 = buried) of `mesh` against `grid`. */
+function visibility(mesh: Mesh, grid: RayGrid, o: AoOptions): Float32Array {
+  const hemi = hemisphere(o.samples ?? 24);
+  const D = Float64Array.from(hemi.flat());
+  const count = hemi.length;
+  const radius = o.radius ?? 1;
+  const ground = o.ground ?? true;
+  const P = mesh.positions;
+  const N = mesh.normals;
+  const out = new Float32Array(P.length / 3);
+  const memo = new Memo(out.length);
+  const key = new Float64Array(6);
+  // Lift off the surface so a ray never hits the face it starts on.
+  const bias = 2e-3;
+  for (let v = 0; v < out.length; v++) {
+    const px = P[v * 3] ?? 0;
+    const py = P[v * 3 + 1] ?? 0;
+    const pz = P[v * 3 + 2] ?? 0;
+    const rx = N[v * 3] ?? 0;
+    const ry = N[v * 3 + 1] ?? 0;
+    const rz = N[v * 3 + 2] ?? 1;
+    const len = Math.hypot(rx, ry, rz) || 1;
+    const n: Vec3 = [rx / len, ry / len, rz / len];
+    key[0] = Math.round(px * 1e4);
+    key[1] = Math.round(py * 1e4);
+    key[2] = Math.round(pz * 1e4);
+    key[3] = Math.round(n[0] * 1e3);
+    key[4] = Math.round(n[1] * 1e3);
+    key[5] = Math.round(n[2] * 1e3);
+    const s = memo.slot(key);
+    if (s.found) {
+      out[v] = memo.get(s.at);
+      continue;
+    }
+    const [t, b] = frame(n);
+    const ox = px + n[0] * bias;
+    const oy = py + n[1] * bias;
+    const oz = pz + n[2] * bias;
+    let blocked = 0;
+    for (let i = 0; i < count; i++) {
+      const d0 = D[i * 3] ?? 0;
+      const d1 = D[i * 3 + 1] ?? 0;
+      const d2 = D[i * 3 + 2] ?? 0;
+      const wx = t[0] * d0 + b[0] * d1 + n[0] * d2;
+      const wy = t[1] * d0 + b[1] * d1 + n[1] * d2;
+      const wz = t[2] * d0 + b[2] * d1 + n[2] * d2;
+      if (ground && wz < -1e-6 && oz >= 0 && -oz / wz <= radius) blocked++;
+      else if (grid.hit(ox, oy, oz, wx, wy, wz, radius)) blocked++;
+    }
+    const vis = 1 - blocked / count;
+    memo.set(s.at, key, vis);
+    out[v] = vis;
+  }
+  return out;
+}
+
+const darken = (mesh: Mesh, vis: Float32Array, strength: number): Mesh => {
+  const colors = new Float32Array(mesh.colors);
+  for (let v = 0; v < vis.length; v++) {
+    const f = 1 - strength * (1 - (vis[v] ?? 1));
+    for (let k = 0; k < 3; k++) colors[v * 3 + k] = (colors[v * 3 + k] ?? 0) * f;
+  }
+  return { ...mesh, colors };
+};
+
+/** Bake AO of one mesh against itself (or `occluder`, in the same space). */
+// Callers bake several parts against one occluder (a head's skin, jaw and eyes against the
+// whole head): index each occluder once. Meshes are immutable, so the grid stays valid.
+const grids = new WeakMap<Mesh, RayGrid>();
+const gridOf = (m: Mesh): RayGrid => {
+  const hit = grids.get(m);
+  if (hit) return hit;
+  const g = new RayGrid(m);
+  grids.set(m, g);
+  return g;
+};
+
+export function bakeAo(mesh: Mesh, o: AoOptions = {}, occluder: Mesh = mesh): Mesh {
+  return darken(mesh, visibility(mesh, gridOf(occluder), o), o.strength ?? 0.6);
+}
+
+/**
+ * Bake AO across a whole compiled asset: every part is occluded by every other (a wheel darkens
+ * the hull behind it). Colours only change, so parts keep their local meshes and pivots.
+ */
+export function bakeAoAsset(asset: CompiledAsset, o: AoOptions = {}): CompiledAsset {
+  const world = worldMeshes(asset.parts);
+  if (world.size === 0) return asset;
+  const grid = new RayGrid(merge([...world.values()]));
+  const strength = o.strength ?? 0.6;
+  return {
+    ...asset,
+    parts: asset.parts.map((p) => {
+      const w = world.get(p.name);
+      return p.mesh && w ? { ...p, mesh: darken(p.mesh, visibility(w, grid, o), strength) } : p;
+    }),
+  };
+}

package/src/passes/grime.ts

@@ -0,0 +1,37 @@
+// Grime: darken vertex colour near the ground and in named zones (soot, mud, dust). A pass over a
+// finished mesh, so recipes stay about shape; wear is applied once, the same way everywhere.
+
+import type { Mesh, Vec3 } from '../core/index.ts';
+
+export interface GrimeZone {
+  readonly at: Vec3;
+  readonly radius: number;
+  /** 0..1 darkening at the centre. */
+  readonly strength: number;
+}
+
+export interface GrimeOptions {
+  /** Height (m) below which mud/dust builds up toward the ground. */
+  readonly ground?: number;
+  /** Darkening at z = 0. */
+  readonly groundStrength?: number;
+  readonly zones?: readonly GrimeZone[];
+}
+
+export function grime(mesh: Mesh, o: GrimeOptions): Mesh {
+  const colors = new Float32Array(mesh.colors);
+  const g = o.ground ?? 0;
+  const gs = o.groundStrength ?? 0.3;
+  for (let i = 0; i < mesh.positions.length / 3; i++) {
+    const x = mesh.positions[i * 3] ?? 0;
+    const y = mesh.positions[i * 3 + 1] ?? 0;
+    const z = mesh.positions[i * 3 + 2] ?? 0;
+    let f = g > 0 && z < g ? 1 - gs * (1 - Math.max(0, z) / g) : 1;
+    for (const zone of o.zones ?? []) {
+      const d = Math.hypot(x - zone.at[0], y - zone.at[1], z - zone.at[2]) / zone.radius;
+      if (d < 1) f *= 1 - zone.strength * (1 - d);
+    }
+    for (let k = 0; k < 3; k++) colors[i * 3 + k] = (colors[i * 3 + k] ?? 1) * f;
+  }
+  return { ...mesh, colors };
+}

package/src/passes/index.ts

@@ -0,0 +1,8 @@
+// Public API of /passes: whole-mesh post-processing applied after geometry — wear, optimisation.
+
+export { type AoOptions, bakeAo, bakeAoAsset } from './bake-ao.ts';
+export { type GrimeOptions, type GrimeZone, grime } from './grime.ts';
+export { type Livery, type LiveryRule, livery } from './livery.ts';
+export { type OptimizeOptions, type OptimizeReport, optimize } from './optimize.ts';
+export { RayGrid } from './ray-grid.ts';
+export { type WeightedNormalsOptions, weightedNormals } from './weighted-normals.ts';

package/src/passes/livery.ts

@@ -0,0 +1,66 @@
+// Livery: paint a finished mesh by rules instead of by hand. Base colour, then ordered rules —
+// the last matching rule wins — keyed on height bands, an along-length range, a side-elevation
+// polygon (stripes, wings, numbers' backgrounds), and surface orientation (roof, front, back,
+// sides, underside). One call turns a grey loco into "Daylight", a tank into its camo scheme.
+
+import type { Mesh, Vec2, Vec3 } from '../core/index.ts';
+
+export interface LiveryRule {
+  readonly color: Vec3;
+  /** Height band [z0, z1] (metres). */
+  readonly z?: readonly [number, number];
+  /** Along-length band [x0, x1] (metres, +X forward). */
+  readonly x?: readonly [number, number];
+  /** Polygon in the side elevation (x, z): the region a stripe or panel covers. */
+  readonly poly?: readonly Vec2[];
+  /** Only faces whose normal points this way (n·axis > 0.5; roof: n.z > 0.55). */
+  readonly facing?: 'roof' | 'under' | 'front' | 'back' | 'side';
+  /** Multiply into the existing colour instead of replacing it (weathering, shading). */
+  readonly multiply?: boolean;
+}
+
+export interface Livery {
+  readonly base?: Vec3;
+  readonly rules: readonly LiveryRule[];
+}
+
+function inPoly(poly: readonly Vec2[], x: number, z: number): boolean {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const [xi, zi] = poly[i] ?? [0, 0];
+    const [xj, zj] = poly[j] ?? [0, 0];
+    if (zi > z !== zj > z && x < ((xj - xi) * (z - zi)) / (zj - zi) + xi) inside = !inside;
+  }
+  return inside;
+}
+
+function faces(f: NonNullable<LiveryRule['facing']>, n: Vec3): boolean {
+  if (f === 'roof') return n[2] > 0.55;
+  if (f === 'under') return n[2] < -0.55;
+  if (f === 'front') return n[0] > 0.5;
+  if (f === 'back') return n[0] < -0.5;
+  return Math.abs(n[1]) > 0.5;
+}
+
+export function livery(mesh: Mesh, l: Livery): Mesh {
+  const colors = new Float32Array(mesh.colors);
+  for (let i = 0; i < mesh.positions.length / 3; i++) {
+    const x = mesh.positions[i * 3] ?? 0;
+    const z = mesh.positions[i * 3 + 2] ?? 0;
+    const n: Vec3 = [
+      mesh.normals[i * 3] ?? 0,
+      mesh.normals[i * 3 + 1] ?? 0,
+      mesh.normals[i * 3 + 2] ?? 0,
+    ];
+    let c: Vec3 = l.base ?? [colors[i * 3] ?? 1, colors[i * 3 + 1] ?? 1, colors[i * 3 + 2] ?? 1];
+    for (const r of l.rules) {
+      if (r.z && (z < r.z[0] || z > r.z[1])) continue;
+      if (r.x && (x < r.x[0] || x > r.x[1])) continue;
+      if (r.poly && !inPoly(r.poly, x, z)) continue;
+      if (r.facing && !faces(r.facing, n)) continue;
+      c = r.multiply ? [c[0] * r.color[0], c[1] * r.color[1], c[2] * r.color[2]] : r.color;
+    }
+    colors.set(c, i * 3);
+  }
+  return { ...mesh, colors };
+}