@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/src/kinds/vegetation-mesh.ts

@@ -0,0 +1,174 @@
+// Skeleton → wood meshes: stems as tapered sweeps (LOD sets radial and path resolution), the
+// trunk with a bark gradient and marks, the buttressed root flare as a lobed `loft`. Plus the
+// fit that scales the finished tree onto its real height and crown spread.
+
+import { boundsOf, type Mesh, merge, type Rng, type Vec3 } from '../core/index.ts';
+import { loft, ringXY, sweep } from '../primitives/index.ts';
+import type { TreeParams } from './vegetation-params.ts';
+import type { Stem } from './vegetation-skeleton.ts';
+
+/** Radial segments per [level][lod]. The trunk's 8 keeps ring vertices on ±Y (exact DBH). */
+const RADIAL = [
+  [8, 6, 5],
+  [6, 4, 4],
+  [4, 3, 3],
+  [3, 3, 3],
+];
+export const radialSegments = (level: number, lod: number): number =>
+  RADIAL[Math.min(3, level)]?.[lod] ?? 3;
+
+/** Every `step`-th path point (always keeping both ends): LOD1 halves path resolution. */
+export function coarsen(st: Stem, step: number): { pts: Vec3[]; radii: number[] } {
+  const pts: Vec3[] = [];
+  const radii: number[] = [];
+  const last = st.pts.length - 1;
+  for (let i = 0; i <= last; i += step) {
+    pts.push(st.pts[i] ?? [0, 0, 0]);
+    radii.push(st.radii[i] ?? 0);
+  }
+  if (last % step !== 0) {
+    pts.push(st.pts[last] ?? [0, 0, 0]);
+    radii.push(st.radii[last] ?? 0);
+  }
+  return { pts, radii };
+}
+
+/** All stems with level in [lo, hi], merged. */
+export function stemsMesh(
+  stems: readonly Stem[],
+  lo: number,
+  hi: number,
+  lod: number,
+  color: Vec3,
+): Mesh {
+  const out: Mesh[] = [];
+  for (const st of stems) {
+    if (st.level < lo || st.level > hi) continue;
+    const { pts, radii } = coarsen(st, lod === 0 ? 1 : 2);
+    out.push(
+      sweep({
+        section: { radius: 1, segments: radialSegments(st.level, lod) },
+        path: pts,
+        scale: radii,
+        color,
+        strip: 'wood',
+      }),
+    );
+  }
+  return merge(out);
+}
+
+const mix = (a: Vec3, b: Vec3, t: number): [number, number, number] => [
+  a[0] + (b[0] - a[0]) * t,
+  a[1] + (b[1] - a[1]) * t,
+  a[2] + (b[2] - a[2]) * t,
+];
+
+/** Bark colour by height (bark → barkTop) with seeded marks; rewrites the mesh's colours. */
+export function barkTint(m: Mesh, p: TreeParams, top: number, rng: Rng): Mesh {
+  const hi = p.barkTop ?? p.bark;
+  for (let i = 0; i < m.colors.length / 3; i++) {
+    const z = m.positions[i * 3 + 2] ?? 0;
+    const t = Math.min(1, Math.max(0, (z / Math.max(0.1, top) - 0.3) / 0.4));
+    let c = mix(p.bark, hi, t * t * (3 - 2 * t));
+    if (p.barkMarks && rng.next() < p.barkMarks.amount) c = mix(c, p.barkMarks.color, 0.85);
+    const k = 1 + rng.range(-0.06, 0.06);
+    m.colors.set([c[0] * k, c[1] * k, c[2] * k], i * 3);
+  }
+  return m;
+}
+
+/** The trunk, radius scaled by `radiusScale` (the fit's 1/sy keeps DBH exact after scaling). */
+export function trunkMesh(
+  trunk: Stem,
+  p: TreeParams,
+  lod: number,
+  radiusScale: number,
+  rng: Rng,
+): Mesh {
+  const { pts, radii } = coarsen(trunk, lod === 0 ? 1 : 2);
+  const m = sweep({
+    section: { radius: 1, segments: radialSegments(0, lod) },
+    path: pts,
+    scale: radii.map((r) => r * radiusScale),
+    color: p.bark,
+    strip: 'wood',
+    caps: p.impostor === 'cards' ? 'end' : false,
+  });
+  return barkTint(m, p, pts[pts.length - 1]?.[2] ?? 1, rng);
+}
+
+/** Trunk axis point at height z (linear between path points). */
+function axisAt(trunk: Stem, z: number): Vec3 {
+  for (let i = 1; i < trunk.pts.length; i++) {
+    const a = trunk.pts[i - 1] ?? [0, 0, 0];
+    const b = trunk.pts[i] ?? a;
+    if (b[2] >= z || i === trunk.pts.length - 1) {
+      const f = Math.min(1, Math.max(0, (z - a[2]) / (b[2] - a[2] || 1)));
+      return [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f, z];
+    }
+  }
+  return [0, 0, z];
+}
+
+/** Buttressed flare: `p.roots` lobes, wide at the ground, melting into the trunk by ~2·DBH. */
+export function rootsMesh(
+  trunk: Stem,
+  p: TreeParams,
+  lod: number,
+  radiusScale: number,
+  rng: Rng,
+): Mesh {
+  const r0 = (trunk.radii[0] ?? 0.2) * radiusScale;
+  const lobes = p.roots ?? 0;
+  const phase = rng.range(0, Math.PI * 2);
+  const levels = [
+    { z: -0.1, k: 1.7, amp: 0.7 },
+    { z: 0.5 * r0, k: 1.3, amp: 0.4 },
+    { z: 1.3 * r0, k: 1.04, amp: 0.15 },
+    { z: 2.4 * r0, k: 0.9, amp: 0 },
+  ];
+  const segs = lod === 0 ? 16 : 10;
+  const rings = levels.map(({ z, k, amp }) => {
+    const c = axisAt(trunk, z);
+    const lobe = (a: number): number => 1 + amp * Math.max(0, Math.cos(lobes * (a - phase))) ** 2;
+    return ringXY(c, r0 * k, r0 * k, segs, lobe);
+  });
+  const m = loft({ rings, color: p.bark, strip: 'wood' });
+  return barkTint(m, p, trunk.pts[trunk.pts.length - 1]?.[2] ?? 1, rng);
+}
+
+/** Per-axis factors that bring the union of `meshes` to `target` = [X, Y, Z] spans. */
+export function fitFactors(meshes: readonly Mesh[], target: Vec3): Vec3 {
+  const lo = [Infinity, Infinity, Infinity];
+  const hi = [-Infinity, -Infinity, -Infinity];
+  for (const m of meshes) {
+    if (m.indices.length === 0) continue;
+    const b = boundsOf(m);
+    for (let k = 0; k < 3; k++) {
+      lo[k] = Math.min(lo[k] ?? 0, b.min[k] ?? 0);
+      hi[k] = Math.max(hi[k] ?? 0, b.max[k] ?? 0);
+    }
+  }
+  const f = (k: 0 | 1 | 2): number => target[k] / Math.max(1e-6, (hi[k] ?? 1) - (lo[k] ?? 0));
+  return [f(0), f(1), f(2)];
+}
+
+/** Non-uniform scale about the origin; normals by the inverse transpose, renormalised. */
+export function scaleMesh(m: Mesh, s: Vec3): Mesh {
+  const positions = new Float32Array(m.positions.length);
+  const normals = new Float32Array(m.normals.length);
+  for (let i = 0; i < positions.length; i += 3) {
+    positions[i] = (m.positions[i] ?? 0) * s[0];
+    positions[i + 1] = (m.positions[i + 1] ?? 0) * s[1];
+    positions[i + 2] = (m.positions[i + 2] ?? 0) * s[2];
+    const nx = (m.normals[i] ?? 0) / s[0];
+    const ny = (m.normals[i + 1] ?? 0) / s[1];
+    const nz = (m.normals[i + 2] ?? 0) / s[2];
+    const l = Math.hypot(nx, ny, nz) || 1;
+    normals[i] = nx / l;
+    normals[i + 1] = ny / l;
+    normals[i + 2] = nz / l;
+  }
+  return { ...m, positions, normals };
+}

package/src/kinds/vegetation-params.ts

@@ -0,0 +1,147 @@
+// Tree vocabulary: Weber & Penn 1995 ("Creation and Rendering of Realistic Trees", SIGGRAPH)
+// parameters, trimmed to what a game tree needs. Plain data, so presets are objects a recipe
+// spreads and overrides.
+
+import type { Vec2, Vec3 } from '../core/index.ts';
+
+/** Crown envelope: how level-1 branch length varies up the trunk (Weber–Penn `Shape`). */
+export type CrownShape =
+  | 'conical'
+  | 'spherical'
+  | 'hemispherical'
+  | 'cylindrical'
+  | 'tapered'
+  | 'flame';
+
+/** One recursion level. Level 0 is the trunk; levels 1–3 are branches, sub-branches, twigs. */
+export interface BranchLevel {
+  /** Children per parent (level 1: along the trunk). Ignored for level 0. */
+  readonly branches: number;
+  /** Level 0: fraction of tree height. Level ≥ 1: fraction of the parent's length. */
+  readonly length: number;
+  /** ± relative random length variation. */
+  readonly lengthVar?: number;
+  /** Degrees between child and parent axis at the attachment. */
+  readonly downAngle: number;
+  /** Added to downAngle from the first child (bottom) to the last (top) of the parent's zone. */
+  readonly downAngleV?: number;
+  /** Phyllotaxis step about the parent, degrees (golden angle 137.5° by default). */
+  readonly rotate?: number;
+  /** Total bend over the stem, degrees: + towards the sky, − towards the ground. Trunk: + bends
+   * back against `lean` (towards −X). */
+  readonly curve?: number;
+  /** If set, the second half bends by this instead (S-curves, weeping tips). */
+  readonly curveBack?: number;
+  /** Seeded wobble per path segment, ± degrees. */
+  readonly curveVar?: number;
+  /** Where children start along this stem's parent, as a fraction (level 1 uses `baseSize`). */
+  readonly start?: number;
+  /** Path segments at LOD0 (LOD1 halves them). */
+  readonly segments: number;
+}
+
+export type LeafShape = 'oval' | 'lobed' | 'tuft' | 'strand' | 'frond';
+
+/** Card outlines: u along the card (0 = stem end), v across (±0.5). */
+export const OUTLINES: Record<Exclude<LeafShape, 'frond'>, readonly Vec2[]> = {
+  oval: [
+    [0, 0],
+    [0.25, -0.4],
+    [0.65, -0.5],
+    [1, 0],
+    [0.65, 0.5],
+    [0.25, 0.4],
+  ],
+  lobed: [
+    [0, 0],
+    [0.3, -0.45],
+    [0.5, -0.3],
+    [0.75, -0.5],
+    [1, 0],
+    [0.75, 0.5],
+    [0.5, 0.3],
+    [0.3, 0.45],
+  ],
+  tuft: [
+    [0, 0],
+    [0.35, -0.5],
+    [0.45, -0.15],
+    [0.75, -0.4],
+    [1, 0],
+    [0.75, 0.4],
+    [0.45, 0.15],
+    [0.35, 0.5],
+  ],
+  strand: [
+    [0, 0],
+    [0.1, -0.5],
+    [1, 0],
+    [0.1, 0.5],
+  ],
+};
+
+export interface LeafParams {
+  readonly shape: LeafShape;
+  /** Card length at LOD0, metres. Cards stand for a cluster of leaves, not one leaf. */
+  readonly size: number;
+  /** Card width as a fraction of its length (fronds: leaflet length as a fraction of frond). */
+  readonly width: number;
+  /** Cards per terminal stem (fronds: leaflets per side). */
+  readonly perStem: number;
+  /** Where cards start along a terminal stem, 0–1 (default 0.3; tufts sit near the tip). */
+  readonly from?: number;
+  readonly color: Vec3;
+  /** ± relative colour variation per card. */
+  readonly colorVar: number;
+  /** 0–1: lay cards level, like the horizontal needle pads of a pine. */
+  readonly flat?: number;
+  /** 0 = cards splay outward, 1 = they hang straight down (willow strands). */
+  readonly hang?: number;
+}
+
+export interface TreeParams {
+  readonly shape: CrownShape;
+  /** Fraction of the trunk free of branches (clear bole). */
+  readonly baseSize: number;
+  /** [trunk, level 1, level 2?, level 3?]. */
+  readonly levels: readonly BranchLevel[];
+  /** Child radius = parent radius · (child length / parent length)^ratioPower. */
+  readonly ratioPower: number;
+  /** Trunk radius at the top as a fraction of its radius at breast height. */
+  readonly taper: number;
+  /** Trunk lean from vertical towards +X, degrees. The trunk stays in the XZ plane. */
+  readonly lean?: number;
+  readonly bark: Vec3;
+  /** Bark colour at the top of the trunk (Scots pine's orange upper bark); default `bark`. */
+  readonly barkTop?: Vec3;
+  /** Dark bark marks scattered per vertex (birch lenticels): colour + fraction of vertices. */
+  readonly barkMarks?: { readonly color: Vec3; readonly amount: number };
+  readonly leaves: LeafParams;
+  /** Buttress lobes in the root flare at the base (LOD0/1); 0 or absent = no `roots` part. */
+  readonly roots?: number;
+  /** Fruit hung under the crown (coconuts), merged into `branches`. LOD0 only. */
+  readonly fruit?: { readonly count: number; readonly radius: number; readonly color: Vec3 };
+  /** LOD2 stand-in: a lathe of the crown envelope, or a few coarse frond cards. */
+  readonly impostor: 'blob' | 'cards';
+  /** Typical mature size this preset was tuned on (used when the caller omits spread/dbh). */
+  readonly typical: { readonly height: number; readonly spread: number; readonly dbh: number };
+}
+
+/** Weber–Penn ShapeRatio; `r` is 1 at the crown base and 0 at the trunk tip. */
+export function shapeRatio(shape: CrownShape, r: number): number {
+  const x = Math.min(1, Math.max(0, r));
+  switch (shape) {
+    case 'conical':
+      return 0.2 + 0.8 * x;
+    case 'spherical':
+      return 0.2 + 0.8 * Math.sin(Math.PI * x);
+    case 'hemispherical':
+      return 0.2 + 0.8 * Math.sin((Math.PI / 2) * x);
+    case 'cylindrical':
+      return 1;
+    case 'tapered':
+      return 0.5 + 0.5 * x;
+    case 'flame':
+      return x <= 0.7 ? 0.15 + (0.85 * x) / 0.7 : 0.15 + (0.85 * (1 - x)) / 0.3;
+  }
+}

package/src/kinds/vegetation-presets.ts

@@ -0,0 +1,184 @@
+// Species presets: plain `TreeParams` objects — spread one and override what you need
+// (`{ ...oak, leaves: { ...oak.leaves, color: hex('#7a8a2a') } }` is an autumn oak).
+// `typical` sizes are mature open-grown trees; sources in each comment and in recipes/<name>/README.md.
+
+import { hex } from '../material/index.ts';
+import type { TreeParams } from './vegetation-params.ts';
+
+/** Quercus robur (English oak): 20–25 m, crown about as wide; girth 4–12 m. Spreading, crooked limbs. */
+export const oak: TreeParams = {
+  shape: 'hemispherical',
+  baseSize: 0.3,
+  ratioPower: 1.15,
+  taper: 0.3,
+  levels: [
+    { branches: 0, length: 0.55, downAngle: 0, curveVar: 5, segments: 8 },
+    {
+      branches: 8,
+      length: 0.95,
+      downAngle: 58,
+      downAngleV: -18,
+      curve: -8,
+      curveVar: 16,
+      segments: 7,
+    },
+    { branches: 6, length: 0.55, downAngle: 50, curve: 12, curveVar: 18, start: 0.2, segments: 4 },
+    { branches: 5, length: 0.5, downAngle: 45, curveVar: 14, start: 0.15, segments: 2 },
+  ],
+  bark: hex('#4a4036'),
+  barkTop: hex('#5a5045'),
+  leaves: {
+    shape: 'lobed',
+    size: 1.7,
+    width: 0.8,
+    perStem: 5,
+    color: hex('#3d6022'),
+    colorVar: 0.16,
+  },
+  roots: 5,
+  impostor: 'blob',
+  typical: { height: 22, spread: 22, dbh: 1.3 },
+};
+
+/** Pinus sylvestris (Scots pine): 25–35 m, DBH up to 1 m; long clean bole, orange upper bark,
+ * flat-topped crown in the top third, dark blue-green needle tufts on upturned tips. */
+export const pine: TreeParams = {
+  shape: 'cylindrical',
+  baseSize: 0.6,
+  ratioPower: 1.2,
+  taper: 0.12,
+  levels: [
+    { branches: 0, length: 0.94, downAngle: 0, curveVar: 3, segments: 10 },
+    {
+      branches: 13,
+      length: 0.34,
+      downAngle: 94,
+      downAngleV: -14,
+      curve: 16,
+      curveVar: 14,
+      segments: 5,
+    },
+    { branches: 5, length: 0.42, downAngle: 60, curve: 18, curveVar: 14, start: 0.3, segments: 3 },
+  ],
+  bark: hex('#4a3a30'),
+  barkTop: hex('#c0652c'),
+  leaves: {
+    shape: 'tuft',
+    size: 2.1,
+    width: 0.95,
+    perStem: 5,
+    from: 0.5,
+    flat: 0.8,
+    color: hex('#24422e'),
+    colorVar: 0.1,
+  },
+  roots: 4,
+  impostor: 'blob',
+  typical: { height: 25, spread: 9, dbh: 0.6 },
+};
+
+/** Cocos nucifera (coconut palm): up to 30 m; single ringed stem 30–40 cm; 4–6 m pinnate fronds. */
+export const palm: TreeParams = {
+  shape: 'cylindrical',
+  baseSize: 0.95,
+  ratioPower: 1.1,
+  taper: 0.7,
+  lean: 12,
+  levels: [
+    { branches: 0, length: 1, downAngle: 0, curve: 24, curveVar: 1.5, segments: 12 },
+    {
+      branches: 22,
+      length: 0.26,
+      downAngle: 115,
+      downAngleV: -85,
+      rotate: 137.5,
+      curve: -55,
+      curveVar: 4,
+      segments: 8,
+    },
+  ],
+  bark: hex('#6b5d4a'),
+  barkTop: hex('#8a7a62'),
+  leaves: {
+    shape: 'frond',
+    size: 0,
+    width: 0.2,
+    perStem: 26,
+    color: hex('#4f7a2a'),
+    colorVar: 0.12,
+  },
+  roots: 9,
+  fruit: { count: 7, radius: 0.13, color: hex('#5f6a22') },
+  impostor: 'cards',
+  typical: { height: 20, spread: 9, dbh: 0.35 },
+};
+
+/** Betula pendula (silver birch): 15–25 m, narrow crown, white bark with black marks, weeping twigs. */
+export const birch: TreeParams = {
+  shape: 'flame',
+  baseSize: 0.3,
+  ratioPower: 1.4,
+  taper: 0.1,
+  levels: [
+    { branches: 0, length: 1, downAngle: 0, curveVar: 3, segments: 10 },
+    {
+      branches: 22,
+      length: 0.32,
+      downAngle: 45,
+      downAngleV: 10,
+      curve: -25,
+      curveVar: 8,
+      segments: 4,
+    },
+    { branches: 5, length: 0.55, downAngle: 30, curve: -45, curveVar: 10, start: 0.2, segments: 3 },
+  ],
+  bark: hex('#d9d6cc'),
+  barkMarks: { color: hex('#24221f'), amount: 0.12 },
+  leaves: {
+    shape: 'oval',
+    size: 0.8,
+    width: 0.7,
+    perStem: 4,
+    color: hex('#6f9a32'),
+    colorVar: 0.15,
+  },
+  impostor: 'blob',
+  typical: { height: 18, spread: 8, dbh: 0.4 },
+};
+
+/** Salix babylonica (weeping willow): 10–15 m, wider than tall; long hanging leafy strands. */
+export const willow: TreeParams = {
+  shape: 'hemispherical',
+  baseSize: 0.25,
+  ratioPower: 1.7,
+  taper: 0.35,
+  levels: [
+    { branches: 0, length: 0.55, downAngle: 0, curveVar: 5, segments: 6 },
+    {
+      branches: 8,
+      length: 0.95,
+      downAngle: 42,
+      curve: 40,
+      curveBack: -70,
+      curveVar: 8,
+      segments: 6,
+    },
+    { branches: 7, length: 0.55, downAngle: 35, curve: -80, curveVar: 8, start: 0.3, segments: 4 },
+  ],
+  bark: hex('#4f463a'),
+  leaves: {
+    shape: 'strand',
+    size: 2.6,
+    width: 0.22,
+    perStem: 4,
+    color: hex('#8aa83e'),
+    colorVar: 0.12,
+    hang: 0.92,
+  },
+  roots: 6,
+  impostor: 'blob',
+  typical: { height: 12, spread: 14, dbh: 0.8 },
+};
+
+export const SPECIES = { oak, pine, palm, birch, willow } as const;
+export type SpeciesName = keyof typeof SPECIES;

package/src/kinds/vegetation-skeleton.ts

@@ -0,0 +1,168 @@
+// The botanical skeleton: Weber–Penn recursive stems as plain polylines + radii. Always grown at
+// full depth and LOD0 resolution from one seeded stream, so every LOD is the same tree; meshing
+// decides what to emit. Children start inside their parent (centre offset r_parent − r_child along
+// the attachment normal), so each one physically grows out of the bark.
+
+import type { Rng, Vec3 } from '../core/index.ts';
+import { arcLengths, transportFrames } from '../primitives/index.ts';
+import { type BranchLevel, shapeRatio, type TreeParams } from './vegetation-params.ts';
+
+export interface Stem {
+  readonly level: number;
+  readonly pts: readonly Vec3[];
+  readonly radii: readonly number[];
+  readonly length: number;
+  /** Index of the parent stem, −1 for the trunk. */
+  readonly parent: number;
+  /** Attachment point on the parent's bark (cluster cards root here at LOD1). */
+  readonly surface: Vec3;
+  /** Nominal length before shape/variation: drives the child count. */
+  readonly maxLength: number;
+}
+
+const deg = Math.PI / 180;
+const unit = (a: Vec3): Vec3 => {
+  const l = Math.hypot(a[0], a[1], a[2]) || 1;
+  return [a[0] / l, a[1] / l, a[2] / l];
+};
+
+/** Rodrigues rotation of v about unit axis k by angle a (radians). */
+export function rotate(v: Vec3, k: Vec3, a: number): Vec3 {
+  const c = Math.cos(a);
+  const s = Math.sin(a);
+  const d = (k[0] * v[0] + k[1] * v[1] + k[2] * v[2]) * (1 - c);
+  return [
+    v[0] * c + (k[1] * v[2] - k[2] * v[1]) * s + k[0] * d,
+    v[1] * c + (k[2] * v[0] - k[0] * v[2]) * s + k[1] * d,
+    v[2] * c + (k[0] * v[1] - k[1] * v[0]) * s + k[2] * d,
+  ];
+}
+
+/** Axis that turns `dir` towards +Z when rotated by a positive angle. */
+function upAxis(dir: Vec3): Vec3 {
+  const k: Vec3 = [dir[1], -dir[0], 0]; // dir × Z
+  return Math.hypot(k[0], k[1]) < 1e-4 ? [0, 1, 0] : unit(k);
+}
+
+/** A stem's polyline: `res` segments, bending by curve/curveBack plus seeded wobble. */
+function path(start: Vec3, dir0: Vec3, len: number, lv: BranchLevel, trunk: boolean, rng: Rng) {
+  const res = Math.max(1, lv.segments);
+  const step = len / res;
+  const pts: Vec3[] = [start];
+  let dir = dir0;
+  let p = start;
+  for (let i = 0; i < res; i++) {
+    const half = lv.curveBack !== undefined && i >= res / 2;
+    const bend = half
+      ? (lv.curveBack ?? 0) / Math.ceil(res / 2)
+      : (lv.curve ?? 0) / (lv.curveBack !== undefined ? Math.max(1, Math.floor(res / 2)) : res);
+    const wob = lv.curveVar ?? 0;
+    // The trunk stays in the XZ plane and bends about Y: + curve swings it back against the lean
+    // (−X), so a leaning palm bows and its crown comes back over its base.
+    if (trunk) dir = rotate(dir, [0, 1, 0], -(bend + rng.range(-wob, wob)) * deg);
+    else {
+      dir = rotate(dir, upAxis(dir), (bend + rng.range(-wob, wob)) * deg);
+      dir = rotate(dir, [0, 0, 1], rng.range(-wob, wob) * deg);
+    }
+    dir = unit(dir);
+    p = [p[0] + dir[0] * step, p[1] + dir[1] * step, p[2] + dir[2] * step];
+    pts.push(p);
+  }
+  return pts;
+}
+
+export function grow(p: TreeParams, size: { height: number; dbh: number }, rng: Rng): Stem[] {
+  const t0 = p.levels[0];
+  if (!t0) return [];
+  const L0 = size.height * t0.length;
+  const r0 = size.dbh / 2;
+  const lean = (p.lean ?? 0) * deg;
+  const trunkPts = path([0, 0, -0.05], [Math.sin(lean), 0, Math.cos(lean)], L0, t0, true, rng);
+  const arc0 = arcLengths(trunkPts);
+  const bh = 1.3; // breast height, metres (forestry DBH convention)
+  const trunkR = arc0.map((s) => {
+    const f = Math.max(0, (s - bh) / Math.max(0.1, L0 - bh));
+    return r0 * (1 - (1 - p.taper) * f);
+  });
+  const stems: Stem[] = [
+    {
+      level: 0,
+      pts: trunkPts,
+      radii: trunkR,
+      length: L0,
+      parent: -1,
+      surface: [0, 0, 0],
+      maxLength: L0,
+    },
+  ];
+  for (let si = 0; si < stems.length; si++) {
+    const par = stems[si];
+    const lv = par ? p.levels[par.level + 1] : undefined;
+    if (!par || !lv) continue;
+    const arc = arcLengths(par.pts);
+    const frames = transportFrames(par.pts);
+    const s0 = (par.level === 0 ? p.baseSize : (lv.start ?? 0.1)) * par.length;
+    const s1 = par.length * 0.97;
+    const fill = par.level === 0 ? 1 : Math.min(1, par.length / par.maxLength);
+    const n = par.level === 0 ? lv.branches : Math.round(lv.branches * (0.25 + 0.75 * fill));
+    let phi = rng.range(0, 360);
+    for (let i = 0; i < n; i++) {
+      const s = s0 + ((s1 - s0) * (i + rng.range(0.15, 0.85))) / Math.max(1, n);
+      let j = 0;
+      while (j < arc.length - 2 && (arc[j + 1] ?? 0) < s) j++;
+      const a = par.pts[j] ?? [0, 0, 0];
+      const b = par.pts[j + 1] ?? a;
+      const f = (s - (arc[j] ?? 0)) / ((arc[j + 1] ?? 1) - (arc[j] ?? 0) || 1);
+      const c: Vec3 = [
+        a[0] + (b[0] - a[0]) * f,
+        a[1] + (b[1] - a[1]) * f,
+        a[2] + (b[2] - a[2]) * f,
+      ];
+      const rp = (par.radii[j] ?? 0) * (1 - f) + (par.radii[j + 1] ?? 0) * f;
+      const T = unit([b[0] - a[0], b[1] - a[1], b[2] - a[2]]);
+      const fr = frames[j] ?? { n: [1, 0, 0], b: [0, 1, 0] };
+      phi += (lv.rotate ?? 137.5) + rng.range(-10, 10);
+      const cp = Math.cos(phi * deg);
+      const sp = Math.sin(phi * deg);
+      const raw: Vec3 = [
+        cp * fr.n[0] + sp * fr.b[0],
+        cp * fr.n[1] + sp * fr.b[1],
+        cp * fr.n[2] + sp * fr.b[2],
+      ];
+      const tdot = raw[0] * T[0] + raw[1] * T[1] + raw[2] * T[2];
+      const np = unit([raw[0] - tdot * T[0], raw[1] - tdot * T[1], raw[2] - tdot * T[2]]);
+      const zone = (s - s0) / Math.max(1e-6, s1 - s0);
+      const down = (lv.downAngle + (lv.downAngleV ?? 0) * zone + rng.range(-5, 5)) * deg;
+      const dir = unit([
+        T[0] * Math.cos(down) + np[0] * Math.sin(down),
+        T[1] * Math.cos(down) + np[1] * Math.sin(down),
+        T[2] * Math.cos(down) + np[2] * Math.sin(down),
+      ]);
+      const vary = 1 + rng.range(-(lv.lengthVar ?? 0.15), lv.lengthVar ?? 0.15);
+      const maxLength = lv.length * par.length;
+      const base =
+        par.level === 0
+          ? maxLength * shapeRatio(p.shape, (par.length - s) / Math.max(1e-6, par.length - s0))
+          : lv.length * (par.length - 0.6 * s);
+      const len = Math.max(0.15, base * vary);
+      const r0c = par.radii[0] ?? rp;
+      const rc = Math.max(0.006, Math.min(0.8 * rp, r0c * (len / par.length) ** p.ratioPower));
+      const start: Vec3 = [
+        c[0] + np[0] * (rp - rc),
+        c[1] + np[1] * (rp - rc),
+        c[2] + np[2] * (rp - rc),
+      ];
+      const pts = path(start, dir, len, lv, false, rng);
+      stems.push({
+        level: par.level + 1,
+        pts,
+        radii: pts.map((_, k) => rc * (1 - (0.75 * k) / Math.max(1, pts.length - 1))),
+        length: len,
+        parent: si,
+        surface: [c[0] + np[0] * rp, c[1] + np[1] * rp, c[2] + np[2] * rp],
+        maxLength,
+      });
+    }
+  }
+  return stems;
+}