@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/src/material/paint/courses.ts

@@ -0,0 +1,85 @@
+// Running-bond layout shared by bricks, stone, planks, slates and plates: horizontal courses
+// (rows along V) split into tiles by vertical joints, staggered per course and periodic along U.
+// Per-course column tables are filled once per course, so the per-pixel loop only reads arrays.
+
+import { createRng } from '../../core/index.ts';
+import type { Canvas } from './canvas.ts';
+
+export interface CourseSpec {
+  /** Course height, metres (along V). */
+  readonly course: number;
+  /** Mean tile length, metres (along U). */
+  readonly length: number;
+  /** 0 = regular; 0.5 = sizes vary ±25 %. */
+  readonly irregular: number;
+  /** Fraction of a tile each odd course shifts; random offsets when irregular. */
+  readonly stagger: number;
+  readonly seed: number;
+}
+
+export class Courses {
+  /** Tile index within the current course, per column. */
+  readonly id: Int32Array;
+  /** Distance to the nearest vertical joint, metres, per column. */
+  readonly dx: Float32Array;
+  /** Distance from the tile's left joint, metres, per column. */
+  readonly ux: Float32Array;
+  /** The current course: index and its bottom / top in metres. */
+  index = -1;
+  y0 = 0;
+  y1 = 0;
+  private readonly bounds: number[] = [0];
+  private readonly c: Canvas;
+  private readonly spec: CourseSpec;
+
+  constructor(c: Canvas, spec: CourseSpec) {
+    this.c = c;
+    this.spec = spec;
+    this.id = new Int32Array(c.w);
+    this.dx = new Float32Array(c.w);
+    this.ux = new Float32Array(c.w);
+    const rng = createRng(spec.seed).fork('rows');
+    let y = 0;
+    while (y < c.metresV) {
+      y += spec.course * (1 + spec.irregular * (rng.next() - 0.5));
+      this.bounds.push(y);
+    }
+  }
+
+  /** Point the tables at the course containing metres `ym`; returns the course index. */
+  at(ym: number): number {
+    if (this.index >= 0 && ym >= this.y0 && ym < this.y1) return this.index;
+    let k = 0;
+    while (k < this.bounds.length - 2 && ym >= (this.bounds[k + 1] ?? 0)) k++;
+    this.index = k;
+    this.y0 = this.bounds[k] ?? 0;
+    this.y1 = this.bounds[k + 1] ?? this.c.metresV;
+    this.fill(k);
+    return k;
+  }
+
+  private fill(k: number): void {
+    const { w, metresU } = this.c;
+    const s = this.spec;
+    const rng = createRng(s.seed).fork(`course${k}`);
+    const n = Math.max(1, Math.round(metresU / s.length));
+    const lens: number[] = [];
+    for (let i = 0; i < n; i++) lens.push(1 + s.irregular * (rng.next() - 0.5));
+    const total = lens.reduce((a, b) => a + b, 0);
+    const joints = [0];
+    for (const l of lens) joints.push((joints[joints.length - 1] ?? 0) + (l / total) * metresU);
+    const shift = s.irregular > 0 ? rng.next() * metresU : (k % 2) * s.stagger * (metresU / n);
+    const px = metresU / w;
+    for (let x = 0; x < w; x++) {
+      let u = ((x + 0.5) * px - shift) % metresU;
+      if (u < 0) u += metresU;
+      let t = 0;
+      while (t < n - 1 && u >= (joints[t + 1] ?? metresU)) t++;
+      const a = joints[t] ?? 0;
+      const b = joints[t + 1] ?? metresU;
+      this.id[x] = t;
+      this.ux[x] = u - a;
+      this.dx[x] = Math.min(u - a, b - u);
+    }
+  }
+}

package/src/material/paint/decode-png.ts

@@ -0,0 +1,100 @@
+// Minimal PNG decoder for stamping supplied images into cells: 8-bit grey, grey+alpha, RGB, RGBA
+// and palette (with tRNS), non-interlaced. Zero dependencies beyond node:zlib. Anything else
+// throws T3D_RECIPE_INVALID with the conversion to make.
+
+import { inflateSync } from 'node:zlib';
+import { Ts23dError } from '../../core/index.ts';
+
+export interface Rgba {
+  readonly width: number;
+  readonly height: number;
+  readonly data: Uint8Array;
+}
+
+const SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+const CHANNELS: Readonly<Record<number, number>> = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+
+function bad(cause: string): never {
+  throw new Ts23dError('T3D_RECIPE_INVALID', {
+    cause: `cell image: ${cause}`,
+    fix: 'pass PNG bytes, 8 bits per channel, non-interlaced (e.g. re-save as RGBA8 PNG)',
+  });
+}
+
+function paeth(a: number, b: number, c: number): number {
+  const p = a + b - c;
+  const pa = Math.abs(p - a);
+  const pb = Math.abs(p - b);
+  const pc = Math.abs(p - c);
+  return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+}
+
+export function decodePng(bytes: Uint8Array): Rgba {
+  if (bytes.length < 33 || SIG.some((s, i) => bytes[i] !== s)) bad('not a PNG (bad signature)');
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let width = 0;
+  let height = 0;
+  let type = -1;
+  let palette: Uint8Array = new Uint8Array();
+  let trns: Uint8Array = new Uint8Array();
+  const idat: Uint8Array[] = [];
+  for (let o = 8; o + 8 <= bytes.length; ) {
+    const len = dv.getUint32(o);
+    const name = String.fromCharCode(...bytes.subarray(o + 4, o + 8));
+    const body = bytes.subarray(o + 8, o + 8 + len);
+    if (name === 'IHDR') {
+      width = dv.getUint32(o + 8);
+      height = dv.getUint32(o + 12);
+      type = body[9] ?? -1;
+      if (body[8] !== 8) bad(`bit depth ${body[8]} (only 8 is supported)`);
+      if (body[12] !== 0) bad('interlaced');
+    } else if (name === 'PLTE') palette = body;
+    else if (name === 'tRNS') trns = body;
+    else if (name === 'IDAT') idat.push(body);
+    else if (name === 'IEND') break;
+    o += 12 + len;
+  }
+  const ch = CHANNELS[type];
+  if (!ch || width === 0 || height === 0) bad(`colour type ${type} or empty image`);
+  const raw = new Uint8Array(inflateSync(Buffer.concat(idat)));
+  const stride = width * ch;
+  if (raw.length < height * (stride + 1)) bad('truncated image data');
+  const px = new Uint8Array(height * stride);
+  for (let y = 0; y < height; y++) {
+    const f = raw[y * (stride + 1)] ?? 0;
+    const src = y * (stride + 1) + 1;
+    const row = y * stride;
+    for (let x = 0; x < stride; x++) {
+      const a = x >= ch ? (px[row + x - ch] ?? 0) : 0;
+      const b = y > 0 ? (px[row - stride + x] ?? 0) : 0;
+      const c = x >= ch && y > 0 ? (px[row - stride + x - ch] ?? 0) : 0;
+      const v = raw[src + x] ?? 0;
+      const pred =
+        f === 1 ? a : f === 2 ? b : f === 3 ? (a + b) >> 1 : f === 4 ? paeth(a, b, c) : 0;
+      px[row + x] = (v + pred) & 255;
+    }
+  }
+  const data = new Uint8Array(width * height * 4);
+  for (let i = 0; i < width * height; i++) {
+    const s = i * ch;
+    const g = px[s] ?? 0;
+    const o = i * 4;
+    if (type === 3) {
+      data[o] = palette[g * 3] ?? 0;
+      data[o + 1] = palette[g * 3 + 1] ?? 0;
+      data[o + 2] = palette[g * 3 + 2] ?? 0;
+      data[o + 3] = trns[g] ?? 255;
+    } else if (ch >= 3) {
+      data[o] = g;
+      data[o + 1] = px[s + 1] ?? 0;
+      data[o + 2] = px[s + 2] ?? 0;
+      data[o + 3] = ch === 4 ? (px[s + 3] ?? 255) : 255;
+    } else {
+      data[o] = g;
+      data[o + 1] = g;
+      data[o + 2] = g;
+      data[o + 3] = ch === 2 ? (px[s + 1] ?? 255) : 255;
+    }
+  }
+  return { width, height, data };
+}

package/src/material/paint/default-sheet.ts

@@ -0,0 +1,61 @@
+// The house sheet: every strip and cell, tuned so albedo stays near-greyscale and bright (vertex
+// colour carries hue) and each strip reads at its typical face height (`scaleMetres`).
+
+import type { SheetRecipe, StripRecipe } from './types.ts';
+
+const leaf: StripRecipe = { kind: 'flat', scaleMetres: 1, roughness: 0.6 };
+
+export const DEFAULT_SHEET: SheetRecipe = {
+  seed: 1,
+  size: 1024,
+  strips: {
+    plain: { kind: 'noise', scaleMetres: 1, roughness: 0.6 },
+    brick: { kind: 'bond', scaleMetres: 0.45, roughness: 0.85, params: { grime: 0.2 } },
+    stone: {
+      kind: 'bond',
+      scaleMetres: 0.9,
+      roughness: 0.9,
+      params: {
+        course: 0.22,
+        length: 0.4,
+        mortar: 0.016,
+        depth: 0.012,
+        bevel: 0.025,
+        irregular: 0.5,
+        relief: 0.004,
+        variation: 0.3,
+        grime: 0.2,
+      },
+    },
+    slate: { kind: 'slate', scaleMetres: 0.66, roughness: 0.7 },
+    iron: { kind: 'plates', scaleMetres: 0.5, roughness: 0.55, metalness: 0 },
+    wood: { kind: 'planks', scaleMetres: 0.6, roughness: 0.75 },
+    glass: { kind: 'glass', scaleMetres: 1, roughness: 0.05 },
+    concrete: { kind: 'concrete', scaleMetres: 1, roughness: 0.9, params: { grime: 0.3 } },
+  },
+  cells: {
+    window_sash: { kind: 'noise', scaleMetres: 1, roughness: 0.5 },
+    door_panel: { kind: 'noise', scaleMetres: 1, roughness: 0.6 },
+    clock: { kind: 'noise', scaleMetres: 1, roughness: 0.3 },
+    smokebox: {
+      kind: 'plates',
+      scaleMetres: 1,
+      roughness: 0.6,
+      metalness: 0.2,
+      params: { rust: 0.3 },
+    },
+    sign: { kind: 'noise', scaleMetres: 1, roughness: 0.5 },
+    porthole: { kind: 'plates', scaleMetres: 1, roughness: 0.5 },
+    foliage_broadleaf: leaf,
+    foliage_maple: leaf,
+    foliage_maple_autumn: leaf,
+    foliage_birch: leaf,
+    foliage_acacia: leaf,
+    foliage_palm: leaf,
+    foliage_spruce: leaf,
+    foliage_spruce_snow: leaf,
+    foliage_willow: leaf,
+    foliage_reeds: leaf,
+    foliage_needles: leaf,
+  },
+};

package/src/material/paint/foliage-broad.ts

@@ -0,0 +1,126 @@
+// Broadleaf foliage cells: a twig grows from the bottom-centre anchor toward +V, side twigs
+// alternate off it, leaves sit at the nodes. A darker back layer of leaves fills the crown first
+// for depth. Variants: beech/oak cluster (ovate, fine teeth), palmate maple, autumn maple
+// (red/orange/yellow per leaf), birch (small serrated leaves on thin drooping twigs).
+
+import { createRng, type Rng } from '../../core/index.ts';
+import type { Canvas } from './canvas.ts';
+import { AUTUMN, at, curve, dim, drawStem, LEAF, vary } from './foliage-common.ts';
+import { Foliage, type LeafShape, type Rgb } from './foliage-raster.ts';
+
+interface ClusterSpec {
+  readonly shape: LeafShape;
+  readonly len: number;
+  readonly wid: number;
+  readonly serrate: number;
+  readonly twigs: number;
+  readonly perTwig: number;
+  readonly back: number;
+  /** Side-twig droop: 0 = straight out, 1 = bends back down. */
+  readonly droop: number;
+  readonly colour: (rng: Rng) => Rgb;
+}
+
+function cluster(c: Canvas, seed: number, s: ClusterSpec): void {
+  const rng = createRng(seed);
+  const f = new Foliage(c);
+  const leafAt = (x: number, y: number, a: number, k: number, lift: number): void => {
+    const len = s.len * rng.range(0.8, 1.15) * k;
+    f.leaf(s.shape, x, y, a, len, s.wid * (len / s.len), s.colour(rng), s.serrate, lift);
+  };
+  // Back layer: darker, unattached leaves filling the crown silhouette.
+  for (let i = 0; i < s.back; i++) {
+    const x = 0.5 + rng.range(-0.33, 0.33);
+    const y = rng.range(0.3, 0.85);
+    const col = dim(s.colour(rng), 0.5);
+    const len = s.len * rng.range(0.8, 1.1);
+    f.leaf(s.shape, x, y, rng.range(-1.4, 1.4), len, s.wid * (len / s.len), col, s.serrate);
+  }
+  const main = curve(
+    0.5,
+    0.02,
+    0.5 + rng.range(-0.1, 0.1),
+    0.45,
+    0.5 + rng.range(-0.08, 0.08),
+    0.8,
+  );
+  drawStem(f, main, 0.016, 0.004, LEAF.twig);
+  for (let k = 0; k < s.twigs; k++) {
+    const t = 0.22 + (k / Math.max(1, s.twigs - 1)) * 0.6;
+    const side = k % 2 === 0 ? 1 : -1;
+    const i = at(main, t);
+    const bx = main.x[i] ?? 0.5;
+    const by = main.y[i] ?? 0.5;
+    const a = (main.a[i] ?? 0) + side * rng.range(0.7, 1.1);
+    const len = 0.3 * (1 - t * 0.45);
+    const ex = bx + Math.sin(a) * len;
+    const ey = by + Math.cos(a) * len - s.droop * len * 0.4;
+    const twig = curve(bx, by, (bx + ex) / 2, (by + ey) / 2 + len * 0.15, ex, ey, 8);
+    drawStem(f, twig, 0.007, 0.002, LEAF.twig);
+    for (let q = 1; q <= s.perTwig; q++) {
+      const j = at(twig, q / s.perTwig);
+      const alt = q % 2 === 0 ? 1 : -1;
+      const ta = (twig.a[j] ?? 0) + (q === s.perTwig ? 0 : alt * rng.range(0.5, 0.9));
+      leafAt(twig.x[j] ?? 0, twig.y[j] ?? 0, ta, 1 - 0.15 * (1 - q / s.perTwig), 0.002);
+    }
+  }
+  const tip = main.x.length - 1;
+  leafAt(main.x[tip] ?? 0.5, main.y[tip] ?? 0.8, main.a[tip] ?? 0, 1.1, 0.003);
+  f.finish(0.5, 0.35);
+}
+
+export function paintBroadleaf(c: Canvas, seed: number): void {
+  cluster(c, seed, {
+    shape: 'ovate',
+    len: 0.15,
+    wid: 0.085,
+    serrate: 0.03,
+    twigs: 6,
+    perTwig: 3,
+    back: 16,
+    droop: 0.1,
+    colour: (rng) => vary(rng, LEAF.beech, 0.18),
+  });
+}
+
+export function paintMaple(c: Canvas, seed: number): void {
+  cluster(c, seed, {
+    shape: 'palmate',
+    len: 0.24,
+    wid: 0.24,
+    serrate: 0.04,
+    twigs: 4,
+    perTwig: 2,
+    back: 7,
+    droop: 0,
+    colour: (rng) => vary(rng, LEAF.maple, 0.15),
+  });
+}
+
+export function paintMapleAutumn(c: Canvas, seed: number): void {
+  cluster(c, seed, {
+    shape: 'palmate',
+    len: 0.24,
+    wid: 0.24,
+    serrate: 0.04,
+    twigs: 4,
+    perTwig: 2,
+    back: 7,
+    droop: 0,
+    colour: (rng) => vary(rng, rng.pick(AUTUMN), 0.12),
+  });
+}
+
+export function paintBirch(c: Canvas, seed: number): void {
+  cluster(c, seed, {
+    shape: 'ovate',
+    len: 0.085,
+    wid: 0.06,
+    serrate: 0.12,
+    twigs: 8,
+    perTwig: 5,
+    back: 22,
+    droop: 0.6,
+    colour: (rng) => vary(rng, LEAF.birch, 0.2),
+  });
+}

package/src/material/paint/foliage-common.ts

@@ -0,0 +1,93 @@
+// Shared growth helpers for foliage cells: quadratic stem curves sampled into points, per-leaf
+// colour jitter and the leaf palettes (linear RGB). Allocation is per leaf/stem, never per pixel.
+
+import type { Rng } from '../../core/index.ts';
+import type { Foliage, Rgb } from './foliage-raster.ts';
+
+/** A quadratic Bézier from p0 via p1 to p2, metres in the cell (anchor usually 0.5, 0.02). */
+export interface Curve {
+  readonly x: readonly number[];
+  readonly y: readonly number[];
+  /** Tangent angle per sample (0 = +V, + toward +U), the convention `Foliage.leaf` takes. */
+  readonly a: readonly number[];
+}
+
+export function curve(
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  x2: number,
+  y2: number,
+  n = 16,
+): Curve {
+  const x: number[] = [];
+  const y: number[] = [];
+  const a: number[] = [];
+  for (let i = 0; i <= n; i++) {
+    const t = i / n;
+    const u = 1 - t;
+    x.push(u * u * x0 + 2 * u * t * x1 + t * t * x2);
+    y.push(u * u * y0 + 2 * u * t * y1 + t * t * y2);
+    const dx = 2 * u * (x1 - x0) + 2 * t * (x2 - x1);
+    const dy = 2 * u * (y1 - y0) + 2 * t * (y2 - y1);
+    a.push(Math.atan2(dx, dy));
+  }
+  return { x, y, a };
+}
+
+/** Sample index nearest parameter t ∈ [0, 1]. */
+export const at = (c: Curve, t: number): number => Math.round(t * (c.x.length - 1));
+
+/** Draw a curve as a tapered stem. */
+export function drawStem(f: Foliage, c: Curve, w0: number, w1: number, col: Rgb): void {
+  const n = c.x.length - 1;
+  for (let i = 0; i < n; i++) {
+    const t0 = i / n;
+    const t1 = (i + 1) / n;
+    f.stem(
+      c.x[i] ?? 0,
+      c.y[i] ?? 0,
+      c.x[i + 1] ?? 0,
+      c.y[i + 1] ?? 0,
+      w0 + (w1 - w0) * t0,
+      w0 + (w1 - w0) * t1,
+      col,
+    );
+  }
+}
+
+/** Jitter a colour per leaf: brightness ±amt and a small hue drift between R and G. */
+export function vary(rng: Rng, col: Rgb, amt: number): Rgb {
+  const k = 1 + amt * (rng.next() * 2 - 1);
+  const drift = 1 + amt * 0.6 * (rng.next() * 2 - 1);
+  return [col[0] * k * drift, col[1] * k, (col[2] * k) / drift];
+}
+
+export const dim = (col: Rgb, k: number): Rgb => [col[0] * k, col[1] * k, col[2] * k];
+
+/** Leaf palettes, linear RGB (multiply by a near-white vertex colour on the card). */
+export const LEAF = {
+  beech: [0.09, 0.2, 0.035] as Rgb,
+  maple: [0.1, 0.24, 0.04] as Rgb,
+  birch: [0.16, 0.3, 0.05] as Rgb,
+  acacia: [0.11, 0.2, 0.06] as Rgb,
+  palm: [0.12, 0.22, 0.05] as Rgb,
+  dry: [0.3, 0.2, 0.08] as Rgb,
+  spruce: [0.035, 0.09, 0.04] as Rgb,
+  pine: [0.06, 0.13, 0.04] as Rgb,
+  willow: [0.2, 0.3, 0.08] as Rgb,
+  reed: [0.2, 0.28, 0.08] as Rgb,
+  snow: [0.85, 0.88, 0.92] as Rgb,
+  bark: [0.08, 0.055, 0.035] as Rgb,
+  twig: [0.12, 0.09, 0.05] as Rgb,
+} as const;
+
+/** Autumn maple: each leaf picks one of these, then gets jittered. */
+export const AUTUMN: readonly Rgb[] = [
+  [0.6, 0.08, 0.02],
+  [0.75, 0.25, 0.02],
+  [0.8, 0.45, 0.03],
+  [0.45, 0.04, 0.03],
+  [0.55, 0.35, 0.05],
+];

package/src/material/paint/foliage-compound.ts

@@ -0,0 +1,135 @@
+// Compound and strand foliage cells, all growing from the bottom-centre anchor toward +V:
+// pinnate acacia (rachis, paired pinnae, tiny leaflets), palm frond (arched rachis, lance
+// leaflets both sides, some dry brown tips), willow curtain (long fine strands of narrow leaves;
+// hang it by mapping the card with V down). A dimmed back layer goes down first.
+
+import { createRng } from '../../core/index.ts';
+import type { Canvas } from './canvas.ts';
+import { at, curve, dim, drawStem, LEAF, vary } from './foliage-common.ts';
+import { Foliage } from './foliage-raster.ts';
+
+export function paintAcacia(c: Canvas, seed: number): void {
+  const rng = createRng(seed);
+  const f = new Foliage(c);
+  const rachis = curve(0.5, 0.02, 0.48 + rng.range(-0.05, 0.05), 0.5, 0.5, 0.95);
+  for (let layer = 0; layer < 2; layer++) {
+    const k = layer === 0 ? 0.5 : 1;
+    if (layer === 1) drawStem(f, rachis, 0.01, 0.003, LEAF.twig);
+    const pairs = layer === 0 ? 6 : 8;
+    for (let p = 0; p < pairs; p++) {
+      const t = 0.15 + (p / pairs) * 0.8 + (layer === 0 ? 0.05 : 0);
+      const i = at(rachis, t);
+      for (const side of [-1, 1]) {
+        const a = (rachis.a[i] ?? 0) + side * rng.range(0.9, 1.2);
+        const len = 0.22 * (1 - t * 0.5);
+        const bx = rachis.x[i] ?? 0.5;
+        const by = rachis.y[i] ?? 0.5;
+        const pinna = curve(
+          bx,
+          by,
+          bx + Math.sin(a) * len * 0.5,
+          by + Math.cos(a) * len * 0.5 + 0.02,
+          bx + Math.sin(a) * len,
+          by + Math.cos(a) * len,
+          6,
+        );
+        drawStem(f, pinna, 0.003, 0.0015, dim(LEAF.twig, k));
+        for (let q = 1; q <= 12; q++) {
+          const j = at(pinna, q / 12.5);
+          const col = dim(vary(rng, LEAF.acacia, 0.15), k);
+          for (const s2 of [-1, 1])
+            f.leaf(
+              'ovate',
+              pinna.x[j] ?? 0,
+              pinna.y[j] ?? 0,
+              (pinna.a[j] ?? 0) + s2 * 1.1,
+              0.03,
+              0.011,
+              col,
+              0,
+              layer * 0.002,
+            );
+        }
+      }
+    }
+  }
+  f.finish(0.5, 0.25);
+}
+
+export function paintPalm(c: Canvas, seed: number): void {
+  const rng = createRng(seed);
+  const f = new Foliage(c);
+  const rachis = curve(0.5, 0.02, 0.3, 0.7, 0.78, 0.96, 24);
+  for (let layer = 0; layer < 2; layer++) {
+    const k = layer === 0 ? 0.55 : 1;
+    const n = 26;
+    for (let q = 0; q < n; q++) {
+      const t = 0.1 + (q / n) * 0.9 + (layer === 0 ? 0.015 : 0);
+      const i = at(rachis, Math.min(1, t));
+      const bx = rachis.x[i] ?? 0.5;
+      const by = rachis.y[i] ?? 0.5;
+      for (const side of [-1, 1]) {
+        const a = (rachis.a[i] ?? 0) + side * rng.range(0.75, 1.0);
+        const len = 0.3 * Math.sin(Math.PI * (0.2 + 0.75 * t)) * rng.range(0.85, 1.05);
+        const wid = 0.03;
+        f.leaf('lance', bx, by, a, len, wid, dim(vary(rng, LEAF.palm, 0.15), k), 0, layer * 0.002);
+        if (rng.next() < 0.3) {
+          const tx = bx + Math.sin(a) * len * 0.72;
+          const ty = by + Math.cos(a) * len * 0.72;
+          f.leaf(
+            'blade',
+            tx,
+            ty,
+            a,
+            len * 0.28,
+            wid * 0.55,
+            dim(vary(rng, LEAF.dry, 0.2), k),
+            0,
+            layer * 0.002 + 0.0002,
+          );
+        }
+      }
+    }
+    if (layer === 0) drawStem(f, rachis, 0.018, 0.004, dim(LEAF.palm, 0.8));
+  }
+  f.finish(0.5, 0.2);
+}
+
+export function paintWillow(c: Canvas, seed: number): void {
+  const rng = createRng(seed);
+  const f = new Foliage(c);
+  const strands = 9;
+  for (let s = 0; s < strands; s++) {
+    const back = s < 3;
+    const k = back ? 0.55 : 1;
+    const ex = 0.5 + rng.range(-0.4, 0.4);
+    const strand = curve(
+      0.5 + rng.range(-0.03, 0.03),
+      0.02,
+      (0.5 + ex) / 2 + rng.range(-0.1, 0.1),
+      0.5,
+      ex,
+      rng.range(0.85, 0.97),
+      24,
+    );
+    drawStem(f, strand, 0.006, 0.0015, dim(LEAF.twig, k));
+    for (let q = 2; q < 30; q++) {
+      const j = at(strand, q / 30);
+      const side = q % 2 === 0 ? 1 : -1;
+      const a = (strand.a[j] ?? 0) + side * rng.range(0.2, 0.45);
+      const col = dim(vary(rng, LEAF.willow, 0.18), k);
+      f.leaf(
+        'lance',
+        strand.x[j] ?? 0,
+        strand.y[j] ?? 0,
+        a,
+        rng.range(0.07, 0.1),
+        0.014,
+        col,
+        0,
+        back ? 0 : 0.002,
+      );
+    }
+  }
+  f.finish(0.5, 0.2);
+}