@developerz.ai/ts23d 0.0.0-stage → 0.2.0

package/src/kinds/head-armour.ts

@@ -0,0 +1,181 @@
+// The orc's armoured bust gear as sculpt groups: plate pauldrons built like real armour — a domed
+// shoulder cap and two shingled lames, each a hollow shell (so its edge shows a thickness and a
+// shadowed underside) with a rolled rim, a raised crest and bone spikes along it, rivets — plus a
+// leather baldric that hugs the chest (a shell of the torso ∩ a diagonal slab) with an iron buckle,
+// and a fur mantle of clumped, tapering strands over the trapezius. Head units, mirrored across Y.
+
+import type { Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { alongZ, unit } from './head-geom.ts';
+import type { HeadParams } from './head-params.ts';
+import { type BustFrame, bustCut, torsoForms } from './head-torso.ts';
+
+const RAD = Math.PI / 180;
+const shade = (c: Vec3, k: number): Vec3 => [c[0] * k, c[1] * k, c[2] * k];
+
+/** Half-space kept above the plane through `p` whose normal is +Z rolled `deg` about X. */
+const above = (p: Vec3, deg: number): SculptEdit => {
+  const n: Vec3 = [0, -Math.sin(deg * RAD), Math.cos(deg * RAD)];
+  return {
+    shape: 'roundBox',
+    at: [p[0] + n[0], p[1] + n[1], p[2] + n[2]],
+    size: [4, 4, 2],
+    rotate: [deg, 0, 0],
+    op: 'intersect',
+  };
+};
+
+/** Thin slab (thickness `t`) through `p`, normal +Z rolled `deg` about X. */
+const slab = (p: Vec3, deg: number, t: number): SculptEdit => ({
+  shape: 'roundBox',
+  at: p,
+  size: [4, 4, t],
+  rotate: [deg, 0, 0],
+  op: 'intersect',
+});
+
+const ell = (at: Vec3, r: Vec3, g: number, roll: number): SculptEdit => ({
+  shape: 'ellipsoid',
+  at,
+  size: [r[0] + g, r[1] + g, r[2] + g],
+  rotate: [roll, 0, 0],
+});
+
+/** One plate: a shell of thickness `t` trimmed above a tilted plane, with a rolled rim. */
+function plate(
+  at: Vec3,
+  r: Vec3,
+  roll: number,
+  cut: Vec3,
+  tilt: number,
+  c: Vec3,
+  t: number,
+): SculptEdit[] {
+  return [
+    {
+      group: [
+        ell(at, r, 0, roll),
+        // Hollow only while the shell is thinner than the plate itself (fine LODs).
+        ...(t < Math.min(...r) * 0.6 ? [{ ...ell(at, r, -t, roll), op: 'subtract' as const }] : []),
+        above(cut, tilt),
+      ],
+      color: c,
+      blend: 0.006,
+    },
+    {
+      group: [
+        ell(at, r, 0.022, roll),
+        ...(t < Math.min(...r) * 0.6
+          ? [{ ...ell(at, r, -t * 0.8, roll), op: 'subtract' as const }]
+          : []),
+        slab(cut, tilt, 0.05),
+      ],
+      // Worn edge: the rim catches the light (a painter's edge highlight).
+      color: shade(c, 1.3),
+      blend: 0.006,
+    },
+  ];
+}
+
+/** `cell`: the bust's sculpt cell; plates thicken to ≈ 2.5 cells so far LODs stay closed. */
+export function armour(p: HeadParams, f: BustFrame, cell = 0): SculptEdit[] {
+  const t = Math.max(0.085, cell * 2.5);
+  const c = p.colors;
+  const { cx, s, b, nz } = f;
+  const metal = c.metal;
+  const out: SculptEdit[] = [];
+  // Pauldron: a big shoulder cap, then two lames shingled out and down over the arm.
+  const cap: Vec3 = [cx - 0.04, s * 0.8, b + 0.66];
+  for (let k = 1; k >= 0; k--) {
+    const at: Vec3 = [cap[0], cap[1] + k * 0.07 * s, cap[2] - k * 0.17];
+    const r: Vec3 = k === 0 ? [0.27, 0.29, 0.25] : [0.23, 0.25, 0.19];
+    const tilt = -(38 + k * 14);
+    const cut: Vec3 = [at[0], at[1], at[2] - r[2] * 0.45];
+    out.push(...plate(at, r, -25 - k * 10, cut, tilt, shade(metal, 1 - k * 0.15), t));
+    // Rivets along each plate's rim.
+    for (let j = 0; j < 4; j++) {
+      const x = at[0] + (j - 1.5) * 0.12;
+      out.push({
+        shape: 'sphere',
+        at: [x, at[1] + r[1] * 0.62, cut[2] + 0.02 - r[1] * 0.62 * Math.tan(-tilt * RAD) * 0.4],
+        size: 0.017,
+        color: shade(metal, 1.35),
+        blend: 0.004,
+      });
+    }
+  }
+  // Crest along the cap's crown, bone spikes rising out of it.
+  const crest: Vec3 = [cap[0], cap[1] - 0.03, cap[2] + 0.25];
+  out.push({
+    shape: 'ellipsoid',
+    at: crest,
+    size: [0.25, 0.028, 0.07],
+    rotate: [-22, 0, 0],
+    color: shade(metal, 0.75),
+    blend: 0.02,
+  });
+  for (let k = 0; k < 3; k++)
+    out.push({
+      shape: 'cone',
+      at: [crest[0] - 0.14 + k * 0.14, crest[1] + 0.01, crest[2] + 0.02 - Math.abs(k - 1) * 0.03],
+      size: [0.075, 0.012, 0.36 - Math.abs(k - 1) * 0.12],
+      rotate: alongZ(unit([(k - 1) * 0.3, 0.55, 1])),
+      color: c.teeth,
+      blend: 0.015,
+    });
+  // Baldric: a shell of the chest cut to a diagonal band over the left shoulder; iron buckle.
+  const band: Vec3 = [cx, 0, b + 0.36];
+  out.push(
+    {
+      group: [{ group: torsoForms(f, 0.03) }, slab(band, 50, 0.15), bustCut(f)],
+      color: c.leather,
+      blend: 0.006,
+      mirror: false,
+    },
+    {
+      group: [
+        { group: torsoForms(f, 0.055) },
+        bustCut(f),
+        {
+          shape: 'roundBox',
+          at: [cx + 0.3, 0.02, b + 0.38],
+          size: [0.3, 0.14, 0.14],
+          rotate: [50, 0, 0],
+          op: 'intersect',
+        },
+        {
+          shape: 'ellipsoid',
+          at: [cx + 0.42, 0.02, b + 0.38],
+          size: [0.1, 0.04, 0.04],
+          op: 'subtract',
+        },
+      ],
+      color: shade(metal, 0.8),
+      blend: 0.004,
+      mirror: false,
+    },
+  );
+  // Fur mantle over the trapezius: clumped strands fanning back and out from behind the neck.
+  const fur = c.fur ?? c.leather;
+  const R = f.n + 0.08;
+  for (let row = 0; row < 3; row++)
+    for (let i = 0; i < 8; i++) {
+      const a = (-80 + i * 22 + row * 11) * RAD;
+      const rr = R + row * 0.07;
+      const root: Vec3 = [
+        cx - 0.1 - Math.abs(Math.cos(a)) * rr * 0.9,
+        Math.abs(Math.sin(a)) * rr + 0.02,
+        nz + 0.16 - row * 0.05,
+      ];
+      const dir = unit([-0.7, Math.abs(Math.sin(a)) * 0.8, -0.55 - ((i + row) % 2) * 0.3]);
+      out.push({
+        shape: 'cone',
+        at: root,
+        size: [0.075 - row * 0.008, 0.012, 0.16 + ((i + row) % 3) * 0.04],
+        rotate: alongZ(dir),
+        color: (i + row) % 2 ? fur : shade(fur, 0.72),
+        blend: 0.035,
+      });
+    }
+  return out;
+}

package/src/kinds/head-beard.ts

@@ -0,0 +1,133 @@
+// Facial hair as sculpt groups, part of the skull field (so a beard splits with the jaw):
+// eyebrows riding just proud of the brow ridge (tapered, arched), and beards built as one clipped
+// volume — a mass around jaw and chin, trimmed above a cheek line that rises to the ears, the lips
+// carved clear — plus a two-segment moustache and optional braid. Head units, mirrored across Y.
+
+import type { Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { along, unit } from './head-geom.ts';
+import type { HeadLayout } from './head-layout.ts';
+import type { HeadParams } from './head-params.ts';
+
+const RAD = Math.PI / 180;
+
+/** Eyebrows: two capsule segments (inner thick → outer thin) offset off the brow ridge. */
+export function browEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  const h = p.brow.hair ?? 0;
+  if (h <= 0) return [];
+  const [ex, ey] = l.eye;
+  const r = l.eyeR;
+  const lift: Vec3 = [p.brow.ridge * 0.55 + 0.012, 0, p.brow.ridge * 0.8 + 0.018];
+  const inner: Vec3 = [ex + r * 0.75 + lift[0], 0.035, l.browZ - p.brow.scowl + lift[2]];
+  const outer: Vec3 = [
+    ex + r * 0.1 + lift[0] * 0.6,
+    ey + r * 1.25,
+    l.browZ + p.brow.scowl * 0.5 + lift[2] * 0.7,
+  ];
+  const mid: Vec3 = [
+    (inner[0] + outer[0]) / 2,
+    inner[1] + (outer[1] - inner[1]) * 0.55,
+    (inner[2] + outer[2]) / 2 + 0.014,
+  ];
+  return [
+    {
+      group: [
+        { shape: 'capsule', at: inner, to: mid, size: h },
+        { shape: 'capsule', at: mid, to: outer, size: h * 0.65, blend: 0.006 },
+      ],
+      color: p.colors.hair,
+      blend: 0.006,
+    },
+  ];
+}
+
+/** Box whose top face is the plane through `p` tilted `deg` about Y (positive: higher at back). */
+const below = (p: Vec3, deg: number): SculptEdit => {
+  const n: Vec3 = [-Math.sin(deg * RAD), 0, Math.cos(deg * RAD)];
+  return {
+    shape: 'roundBox',
+    at: [p[0] - n[0], p[1], p[2] - n[2]],
+    size: [4, 4, 2],
+    rotate: [0, -deg, 0],
+    op: 'intersect',
+    blend: 0.02,
+  };
+};
+
+export function beardEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  if (p.beard === 'none') return [];
+  const h = p.colors.hair;
+  const light: Vec3 = [h[0] * 1.35, h[1] * 1.35, h[2] * 1.35];
+  const [ax, ay, az] = l.angle;
+  const ch = l.chin;
+  const mw = p.mouth.width;
+  const lipT = p.mouth.lips;
+  const full = p.beard !== 'goatee';
+  const mass: SculptEdit = full
+    ? {
+        shape: 'ellipsoid',
+        at: [(ax + ch[0]) / 2 + 0.03, 0, (az + ch[2]) / 2 + 0.01],
+        size: [(ch[0] - ax) / 2 + 0.08, ay + 0.065, 0.17],
+      }
+    : { shape: 'ellipsoid', at: [ch[0] + 0.01, 0, ch[2] + 0.02], size: [0.09, mw * 0.9, 0.11] };
+  const out: SculptEdit[] = [
+    {
+      group: [
+        mass,
+        // Chin volume: the beard grows forward and down off the chin.
+        {
+          shape: 'ellipsoid',
+          at: [ch[0] + 0.025, 0, ch[2] - 0.03],
+          size: [0.08, full ? 0.13 : 0.08, 0.1],
+          blend: 0.04,
+        },
+        // Trimmed below a cheek line that rises towards the ears.
+        below([l.mouthX, 0, l.mouthZ + 0.03], full ? 28 : 0),
+        // Lips carved clear.
+        {
+          shape: 'ellipsoid',
+          at: [l.mouthX + 0.02, 0, l.mouthZ - lipT * 0.3],
+          size: [0.07, mw * 1.05, lipT * 2.3],
+          op: 'subtract',
+          blend: 0.012,
+        },
+        // Clump grooves down the chin.
+        ...[-0.05, 0.05].map(
+          (y): SculptEdit => ({
+            shape: 'capsule',
+            at: [ch[0] + 0.12, y, l.mouthZ - 0.06],
+            to: [ch[0] + 0.06, y * 1.3, ch[2] - 0.14],
+            size: 0.008,
+            op: 'subtract',
+            blend: 0.012,
+            mirror: false,
+          }),
+        ),
+      ],
+      color: h,
+      blend: 0.012,
+    },
+  ];
+  if (p.beard === 'braided')
+    out.push({
+      shape: 'capsule',
+      at: [ch[0] + 0.03, 0.035, ch[2] - 0.08],
+      to: [ch[0] + 0.01, 0.045, ch[2] - 0.34],
+      size: 0.032,
+      color: light,
+      blend: 0.02,
+    });
+  // Moustache: from under the nose, over the lip corners, drooping past them.
+  const root: Vec3 = [l.mouthX + 0.02, 0.012, l.mouthZ + lipT * 1.9];
+  const bend: Vec3 = [l.mouthX - 0.005, mw * 0.85, l.mouthZ + lipT * 0.6];
+  const tip = along(bend, unit([-0.4, 0.5, -1]), 0.05);
+  out.push({
+    group: [
+      { shape: 'capsule', at: root, to: bend, size: 0.024 },
+      { shape: 'capsule', at: bend, to: tip, size: 0.016, blend: 0.01 },
+    ],
+    color: light,
+    blend: 0.008,
+  });
+  return out;
+}

package/src/kinds/head-bust.ts

@@ -0,0 +1,184 @@
+// The bust under the head: the anatomy, bust cut and plinth (head-torso.ts) plus the gear that
+// sells the race at a glance — spiked plate pauldrons and a fur mantle (orc, head-armour.ts), a
+// leather vest, scarf and cowl (goblin, head-garb.ts), a draped hood, or a tunic with mantle and
+// brooch (human). Head units, mirrored across Y; the neck itself belongs to the head.
+
+import type { Vec3 } from '../core/index.ts';
+import { type SculptEdit, sculptField } from '../primitives/index.ts';
+import { armour } from './head-armour.ts';
+import { vest } from './head-garb.ts';
+import type { HeadLayout } from './head-layout.ts';
+import type { HeadParams } from './head-params.ts';
+import {
+  type BustFrame,
+  bodyEdits,
+  bustCut,
+  frameOf,
+  plinthEdits,
+  torsoForms,
+} from './head-torso.ts';
+
+function hood(p: HeadParams, cx: number, nz: number): SculptEdit[] {
+  const c = p.colors;
+  return [
+    {
+      shape: 'torus',
+      at: [cx - 0.08, 0, nz + 0.04],
+      size: [p.neck.radius + 0.13, 0.11],
+      color: c.cloth,
+      blend: 0.05,
+    },
+    {
+      shape: 'ellipsoid',
+      at: [cx - 0.36, 0, nz + 0.14],
+      size: [0.16, 0.3, 0.2],
+      color: c.cloth,
+      blend: 0.08,
+    },
+    {
+      shape: 'cone',
+      at: [cx - 0.42, 0, nz + 0.1],
+      size: [0.12, 0.02, 0.32],
+      rotate: [0, -165, 0],
+      color: c.cloth,
+      blend: 0.05,
+    },
+    {
+      shape: 'roundBox',
+      at: [cx + 0.1, 0.32, nz - 0.02],
+      size: [0.04, 0.1, 0.08],
+      round: 0.01,
+      rotate: [20, 0, 0],
+      color: c.leather,
+      blend: 0.005,
+      mirror: false,
+    },
+    {
+      shape: 'capsule',
+      at: [cx + 0.18, 0.12, nz - 0.02],
+      to: [cx + 0.26, 0.05, nz - 0.32],
+      size: 0.018,
+      color: c.leather,
+      blend: 0.01,
+    },
+  ];
+}
+
+function tunic(p: HeadParams, f: BustFrame): SculptEdit[] {
+  const c = p.colors;
+  const { cx, s, b, nz } = f;
+  const shell = (g: number): SculptEdit => ({ group: torsoForms(f, g) });
+  const torso = sculptField(torsoForms(f), { color: c.cloth, mirror: 'y' }).field;
+  const front = (z: number): number => {
+    let x = cx + 0.7;
+    for (let i = 0; i < 300 && torso([x, 0, z]) > 0; i++) x -= 0.004;
+    return x;
+  };
+  const n = p.neck.radius;
+  const axis = (z: number): Vec3 => [cx - 0.08, 0, z];
+  const mantle = (g: number): SculptEdit => ({
+    shape: 'ellipsoid',
+    at: [cx - 0.1, 0, b + 0.45],
+    size: [0.42 + g, s + 0.06 + g, 0.3 + g],
+  });
+  const opening: SculptEdit = {
+    shape: 'ellipsoid',
+    at: [cx + 0.38, 0, nz - 0.1],
+    size: [0.3, s * 0.45, 0.5],
+    op: 'subtract',
+    blend: 0.02,
+  };
+  const brooch = (y: number): SculptEdit => ({
+    group: [
+      mantle(0.03),
+      { shape: 'sphere', at: [cx + 0.17, y, b + 0.5], size: 0.065, op: 'intersect' },
+    ],
+    color: c.metal,
+    blend: 0.004,
+  });
+  return [
+    // Mantle: a dome over shoulders and back, cut level below, open at the front.
+    {
+      group: [
+        mantle(0),
+        { shape: 'roundBox', at: [0, 0, b + 0.3 + 1], size: [4, 4, 2], op: 'intersect' },
+        opening,
+        bustCut(f),
+      ],
+      color: c.cape ?? c.leather,
+      blend: 0.01,
+    },
+    brooch(s * 0.4),
+    // Standing collar, notched open at the throat.
+    {
+      group: [
+        { shape: 'capsule', at: axis(nz - 0.06), to: axis(nz + 0.1), size: n + 0.08 },
+        {
+          shape: 'capsule',
+          at: axis(nz - 0.2),
+          to: axis(nz + 0.3),
+          size: n + 0.02,
+          op: 'subtract',
+        },
+        {
+          shape: 'ellipsoid',
+          at: [cx + 0.2, 0, nz + 0.12],
+          size: [0.12, 0.08, 0.14],
+          op: 'subtract',
+          blend: 0.02,
+        },
+      ],
+      color: c.leather,
+      blend: 0.015,
+    },
+    // Leather placket with three brass buttons down the chest.
+    {
+      group: [
+        shell(0.012),
+        { shape: 'roundBox', at: [cx + 0.3, 0, b + 0.2], size: [0.4, 0.07, 0.6], op: 'intersect' },
+      ],
+      color: c.leather,
+      blend: 0.004,
+      mirror: false,
+    },
+    // Brass buttons seated on the chest surface (probed along −X at the midline).
+    ...[0.5, 0.38, 0.26].map(
+      (z): SculptEdit => ({
+        shape: 'sphere',
+        at: [front(b + z) + 0.014, 0, b + z],
+        size: 0.028,
+        color: c.metal,
+        blend: 0.004,
+        mirror: false,
+      }),
+    ),
+  ];
+}
+
+/** `cell`: the bust's sculpt cell (head units), floors the plinth disc so far LODs keep it. */
+export function bustEdits(p: HeadParams, l: HeadLayout, cell = 0): SculptEdit[] {
+  const c = p.colors;
+  const f = frameOf(p, l);
+  const style = p.bust.style;
+  const bare = style === 'pauldrons' || style === 'vest';
+  const e: SculptEdit[] = [
+    ...bodyEdits(p, f, bare ? c.skin : c.cloth),
+    // Neck root in skin, so the head's neck seats into the bust without a cloth ring (flattened,
+    // so it never pokes through the chest below the collar).
+    {
+      shape: 'ellipsoid',
+      at: [f.cx - 0.09, 0, f.nz + 0.06],
+      size: [f.n * 1.02, f.n * 1.02, 0.12],
+      color: c.skin,
+      blend: 0.04,
+    },
+  ];
+  if (style === 'pauldrons') e.push(...armour(p, f, cell));
+  else if (style === 'hood') e.push(...hood(p, f.cx, f.nz));
+  else if (style === 'vest') e.push(...vest(p, f));
+  else e.push(...tunic(p, f));
+  e.push(...plinthEdits(p, f, cell * 1.5));
+  // Base cut flat at z = base.
+  e.push({ shape: 'roundBox', at: [0, 0, f.floor - 1], size: [4, 4, 2], op: 'subtract' });
+  return e;
+}

package/src/kinds/head-extras.ts

@@ -0,0 +1,150 @@
+// Tertiary head forms as edit lists: ears (added to the head after the jaw cut, so the cut never
+// clips a lobe), tusks (added to the jaw), war paint and warts (part of the skull field). Hair and
+// beards: head-hair.ts. Head units, mirrored across Y unless an edit opts out.
+
+import type { Rng, Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { along, alongX, alongZ, unit } from './head-geom.ts';
+import type { HeadLayout } from './head-layout.ts';
+import type { HeadParams } from './head-params.ts';
+
+const RAD = Math.PI / 180;
+
+/** `minThick`: the blade's floor thickness (≈ a cell), so far LODs keep their ears attached. */
+export function earEdits(p: HeadParams, l: HeadLayout, minThick = 0): SculptEdit[] {
+  const { length, width, sweep, lift, shape } = p.ears;
+  const cx = l.cranium.at[0];
+  const ry = l.cranium.r[1];
+  const root: Vec3 = [cx + 0.02, ry * 0.9, l.eye[2] - 0.05];
+  const d = unit([-Math.sin(sweep * RAD), Math.cos(sweep * RAD), Math.tan(lift * RAD)]);
+  const rot = alongX(d, shape === 'pointed' ? -10 : 0);
+  const thick = Math.max(0.022 + width * 0.06, minThick);
+  const front: Vec3 = [Math.cos(sweep * RAD), Math.sin(sweep * RAD), 0];
+  const shade = p.colors.shade;
+  if (shape === 'round') {
+    // A human/dwarf ear: upright oval, the long axis vertical, set just behind the jaw hinge.
+    const at = along(root, d, 0.03);
+    const rot2: Vec3 = [0, -lift, 90 + sweep];
+    return [
+      { shape: 'ellipsoid', at, size: [width / 2, thick, length / 2], rotate: rot2, blend: 0.02 },
+      {
+        shape: 'ellipsoid',
+        at: along(along(at, d, thick * 0.6), front, 0.004),
+        size: [width * 0.3, thick * 0.55, length * 0.3],
+        rotate: rot2,
+        op: 'subtract',
+        blend: 0.012,
+        color: shade,
+      },
+      {
+        shape: 'ellipsoid',
+        at: [at[0], at[1] + thick * 0.4, at[2] - length * 0.33],
+        size: [width * 0.24, thick * 0.9, length * 0.16],
+        blend: 0.015,
+      },
+    ];
+  }
+  // A pointed leaf ear: broad root blade, tapering tip blade, a hollow facing forward.
+  return [
+    {
+      shape: 'ellipsoid',
+      at: along(root, d, length * 0.3),
+      size: [length * 0.36, thick, width * 0.5],
+      rotate: rot,
+      blend: 0.03,
+    },
+    {
+      shape: 'ellipsoid',
+      at: along(root, d, length * 0.68),
+      size: [length * 0.34, thick * 0.75, width * 0.22],
+      rotate: rot,
+      blend: 0.04,
+    },
+    {
+      shape: 'ellipsoid',
+      at: along(along(root, d, length * 0.42), front, thick * 0.85),
+      size: [length * 0.36, thick * 0.6, width * 0.3],
+      rotate: rot,
+      op: 'subtract',
+      blend: 0.015,
+      color: shade,
+    },
+    { shape: 'sphere', at: root, size: 0.04, blend: 0.03 },
+  ];
+}
+
+/** Lower tusks rising from the jaw past the upper lip, curving out and back (3 cone segments). */
+/** `minR`: radius floor (≈ half a cell) so far LODs keep the tusks. */
+export function tuskEdits(p: HeadParams, l: HeadLayout, minR = 0): SculptEdit[] {
+  const t = p.tusks;
+  if (!t) return [];
+  const out: SculptEdit[] = [];
+  let at: Vec3 = [l.mouthX - 0.03 + p.jaw.underbite * 0.5, t.spread, l.mouthZ - 0.02];
+  let dir = unit([0.25, t.flare * 0.5, 1]);
+  const seg = t.length / 3;
+  for (let i = 0; i < 3; i++) {
+    const r0 = Math.max(t.radius * (1 - i / 3.4), minR);
+    const r1 = Math.max(t.radius * (1 - (i + 1) / 3.4), minR * 0.6);
+    out.push({
+      shape: 'cone',
+      at,
+      size: [r0, Math.max(r1, 0.004), seg * 1.05],
+      rotate: alongZ(dir),
+      color: p.colors.teeth,
+      blend: i === 0 ? 0.02 : 0.004,
+    });
+    at = along(at, dir, seg);
+    dir = unit([dir[0] - 0.22, dir[1] + t.flare * 0.15, dir[2]]);
+  }
+  return out;
+}
+
+/** War paint: thin deep ellipsoids painted through the skin, so each stripe is a clean band of
+ *  constant width wherever it crosses the surface — two claw marks per cheek, a crest stripe up
+ *  the forehead, three down the chin. */
+export function paintEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  const c = p.colors.paint;
+  if (!c) return [];
+  const [ex, ey, ez] = l.eye;
+  const band = (at: Vec3, r: Vec3, mirror = true, tilt = 0): SculptEdit => ({
+    shape: 'ellipsoid',
+    at,
+    size: r,
+    rotate: [tilt, 0, 0],
+    op: 'paint',
+    color: c,
+    blend: 0.006,
+    mirror,
+  });
+  const chinZ = (l.mouthZ + l.chin[2]) / 2 - 0.02;
+  return [
+    band([ex + 0.1, ey - 0.035, ez - 0.13], [0.45, 0.016, 0.09], true, -8),
+    band([ex + 0.1, ey + 0.035, ez - 0.12], [0.45, 0.016, 0.085], true, -8),
+    band([l.cranium.at[0], 0, l.browZ + 0.14], [0.6, 0.028, 0.13], false),
+    band([l.chin[0], 0, chinZ], [0.4, 0.012, 0.06], false),
+    band([l.chin[0], 0.055, chinZ], [0.4, 0.012, 0.05]),
+  ];
+}
+
+/** Seeded warts and bumps on the cranium and cheeks. */
+export function wartEdits(p: HeadParams, l: HeadLayout, rng: Rng): SculptEdit[] {
+  const cx = l.cranium.at[0];
+  const [rx, ry, rz] = l.cranium.r;
+  return Array.from({ length: p.warts }, (): SculptEdit => {
+    const yaw = rng.range(-1.2, 1.2);
+    const el = rng.range(-0.1, 0.9);
+    const at: Vec3 = [
+      cx + rx * Math.cos(el) * Math.cos(yaw),
+      ry * Math.cos(el) * Math.sin(yaw),
+      l.cranium.at[2] + rz * Math.sin(el),
+    ];
+    return {
+      shape: 'sphere',
+      at,
+      size: rng.range(0.008, 0.016),
+      color: p.colors.shade,
+      blend: 0.01,
+      mirror: false,
+    };
+  });
+}