@developerz.ai/ts23d 0.0.0-stage → 0.1.0

package/src/kinds/head-bust.ts

@@ -0,0 +1,221 @@
+// The bust under the head: chest, trapezius and deltoid caps, cut flat at the base and at the arms
+// (the classic sculpted bust), plus the gear that sells the race at a glance — layered spiked
+// pauldrons and a fur mantle (orc), a draped hood (goblin), a tunic with cloak and clasp (human).
+// Head units, mirrored across Y; the neck itself belongs to the head.
+
+import type { Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { armour, chestOf } from './head-armour.ts';
+import type { HeadLayout } from './head-layout.ts';
+import type { HeadParams } from './head-params.ts';
+
+/** Bare-chested torso forms under the armour: pectorals with a sternal groove, deltoid caps. */
+function torso(p: HeadParams, cx: number, b: number): SculptEdit[] {
+  const c = p.colors;
+  return [
+    {
+      shape: 'ellipsoid',
+      at: [cx + 0.17, 0.16, b + 0.32],
+      size: [0.16, 0.19, 0.12],
+      rotate: [0, 0, 12],
+      color: c.skin,
+      blend: 0.07,
+    },
+    {
+      shape: 'capsule',
+      at: [cx + 0.33, 0, b + 0.42],
+      to: [cx + 0.34, 0, b + 0.1],
+      size: 0.012,
+      op: 'subtract',
+      blend: 0.04,
+      color: c.shade,
+      mirror: false,
+    },
+  ];
+}
+
+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, cx: number, s: number, b: number, nz: number): SculptEdit[] {
+  const c = p.colors;
+  const chest = chestOf(cx, s, b);
+  const shell = (g: number): SculptEdit => ({
+    shape: 'ellipsoid',
+    at: chest.at,
+    size: [chest.r[0] + g, chest.r[1] + g, chest.r[2] + g],
+  });
+  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,
+      ],
+      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,
+    },
+    ...[0.42, 0.3, 0.18].map(
+      (z): SculptEdit => ({
+        group: [
+          shell(0.03),
+          { shape: 'sphere', at: [cx + 0.3, 0, b + z], size: 0.03, op: 'intersect' },
+        ],
+        color: c.metal,
+        blend: 0.003,
+        mirror: false,
+      }),
+    ),
+  ];
+}
+
+export function bustEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  const c = p.colors;
+  const cx = l.cranium.at[0] + p.jaw.muzzle * 0.3;
+  const s = p.bust.shoulders;
+  const b = l.base;
+  const nz = b + 0.6; // neck root
+  const body = p.bust.style === 'pauldrons' ? c.skin : c.cloth;
+  const e: SculptEdit[] = [
+    { shape: 'ellipsoid', at: chestOf(cx, s, b).at, size: chestOf(cx, s, b).r, color: body },
+    {
+      shape: 'capsule',
+      at: [cx - 0.16, 0.1, nz + 0.16],
+      to: [cx - 0.1, s * 0.78, b + 0.44],
+      size: 0.15,
+      color: body,
+      blend: 0.15,
+    },
+    { shape: 'sphere', at: [cx - 0.04, s * 0.84, b + 0.3], size: 0.2, color: body, blend: 0.1 },
+    // Trapezius: from high behind the neck down to the shoulder.
+    {
+      shape: 'capsule',
+      at: [cx - 0.2, 0.08, nz + 0.3],
+      to: [cx - 0.1, s * 0.62, b + 0.5],
+      size: 0.1 + p.neck.radius * 0.2,
+      color: body,
+      blend: 0.12,
+    },
+    {
+      shape: 'capsule',
+      at: [cx - 0.08, 0, nz - 0.05],
+      to: [cx - 0.1, 0, nz + 0.12],
+      size: p.neck.radius * 1.05,
+      color: c.skin,
+      blend: 0.03,
+    },
+  ];
+  // Arms cut flat at the shoulders (before the gear, so pauldrons overhang the cut).
+  e.push({
+    shape: 'roundBox',
+    at: [0, s + 1.02, b + 0.5],
+    size: [4, 2, 4],
+    op: 'subtract',
+    color: body,
+  });
+  if (p.bust.style === 'pauldrons') e.push(...torso(p, cx, b), ...armour(p, cx, s, b, nz));
+  else if (p.bust.style === 'hood') e.push(...hood(p, cx, nz));
+  else e.push(...tunic(p, cx, s, b, nz));
+  // Base cut flat at z = base.
+  e.push({ shape: 'roundBox', at: [0, 0, b - 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,
+    };
+  });
+}

package/src/kinds/head-face.ts

@@ -0,0 +1,222 @@
+// The skull edit list, primary → secondary forms (the ZBrush order): cranium, face plate, cheek
+// bones, muzzle, mandible + chin, neck; then sockets, brow ridge, lids, nose, lips and the mouth
+// line. Head units, mirrored across Y. The jaw cut (head-split.ts) later divides this one field
+// into the `head` and `jaw` parts, so their surfaces meet without a seam.
+
+import type { Vec3 } from '../core/index.ts';
+import type { SculptEdit } from '../primitives/index.ts';
+import { alongX, alongZ, unit } from './head-geom.ts';
+import type { HeadLayout } from './head-layout.ts';
+import type { HeadParams } from './head-params.ts';
+
+/** Brain case + face plate: the forms the eyes are seated against (head.ts probes them). */
+export function primaryEdits(l: HeadLayout): SculptEdit[] {
+  const [cx, , cz] = l.cranium.at;
+  const [rx, ry, rz] = l.cranium.r;
+  return [
+    { shape: 'ellipsoid', at: [cx, 0, cz], size: [rx, ry, rz] },
+    {
+      shape: 'ellipsoid',
+      at: [l.faceX - 0.19, 0, l.eye[2] - 0.03],
+      size: [0.2, ry * 0.86, 0.24],
+      blend: 0.08,
+    },
+  ];
+}
+
+export function skullEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  const c = p.colors;
+  const cx = l.cranium.at[0];
+  const [ex, ey, ez] = l.eye;
+  const r = l.eyeR;
+  const lipT = p.mouth.lips;
+  const mw = p.mouth.width;
+  const [ax, ay, az] = l.angle;
+  const [hx, hz] = l.hinge;
+  const chin = l.chin;
+  const tipX = l.faceX + 0.06 + p.nose.length * 0.25 + p.nose.bridge + p.jaw.muzzle * 0.5;
+  const tipZ = l.noseZ + 0.035 - p.nose.hook;
+  const e: SculptEdit[] = [
+    // Primary: brain case, face plate, cheek bones, muzzle, mandible, chin, neck.
+    ...primaryEdits(l),
+    {
+      shape: 'ellipsoid',
+      at: [ex - 0.03, (ey + 0.06) * p.cheeks.width, ez - r - 0.065 * p.cheeks.size],
+      size: [0.09 * p.cheeks.size, 0.08 * p.cheeks.size, 0.065 * p.cheeks.size],
+      rotate: [0, 0, 25],
+      blend: 0.09,
+    },
+    // Maxilla: fills the midface between cheekbones, nose and muzzle.
+    {
+      shape: 'ellipsoid',
+      at: [l.faceX - 0.13 + p.jaw.muzzle * 0.6, 0, l.noseZ + 0.01],
+      size: [0.15, 0.2 * p.cheeks.width, 0.13],
+      blend: 0.08,
+    },
+    {
+      shape: 'ellipsoid',
+      at: [l.mouthX - 0.13, 0, l.mouthZ + 0.02],
+      size: [0.14, Math.max(mw * 1.15, 0.13), 0.12 + p.jaw.drop * 0.2],
+      blend: 0.07,
+    },
+    // Mandible: a U of bone — body from the jaw angles to the chin, ramus up to the hinge.
+    {
+      shape: 'roundBox',
+      at: [(ax + chin[0]) / 2 + 0.01, 0, (az + chin[2]) / 2 + 0.03],
+      size: [chin[0] - ax + 0.04, ay * 1.75, 0.16 + p.jaw.drop * 0.5],
+      round: 0.07,
+      rotate: [0, Math.atan2(az - chin[2], chin[0] - ax) * (180 / Math.PI) * 0.6, 0],
+      blend: 0.08,
+    },
+    {
+      shape: 'capsule',
+      at: [hx - 0.04, ay * 0.85, hz],
+      to: [ax, ay, az],
+      size: 0.055,
+      blend: 0.07,
+    },
+    { shape: 'sphere', at: [ax + 0.02, ay * 0.95, az], size: 0.065, blend: 0.07 },
+    {
+      shape: 'ellipsoid',
+      at: chin,
+      size: [0.065 * p.jaw.chin, 0.09 * p.jaw.chin, 0.07 * p.jaw.chin],
+      blend: 0.06,
+    },
+    {
+      shape: 'capsule',
+      at: [cx + 0.02, 0, ez - 0.22],
+      to: [cx - 0.05, 0, l.base + 0.45],
+      size: p.neck.radius,
+      blend: 0.1,
+    },
+    // Secondary: sockets, brow, lids.
+    {
+      shape: 'capsule',
+      at: [ex + r * 0.75, 0.025, l.browZ - p.brow.scowl],
+      to: [ex + r * 0.1, ey + r * 1.25, l.browZ + p.brow.scowl * 0.5],
+      size: p.brow.ridge,
+      blend: 0.06,
+    },
+    { shape: 'sphere', at: l.eye, size: r * 1.12, op: 'subtract', blend: r * 0.5, color: c.shade },
+  ];
+  // Lids: a shell over the eyeball, kept above (upper) / below (lower) a plane through the eye
+  // centre tilted to the lid angle, so the lid edge crosses the cornea exactly at that angle.
+  const lid = (deg: number, upper: boolean): SculptEdit => {
+    const t = (deg * Math.PI) / 180;
+    const n: Vec3 = upper ? [-Math.sin(t), 0, Math.cos(t)] : [Math.sin(t), 0, Math.cos(t)];
+    const k = upper ? 1 : -1;
+    return {
+      group: [
+        { shape: 'sphere', at: l.eye, size: r * (upper ? 1.14 : 1.1) },
+        {
+          shape: 'roundBox',
+          at: [ex + n[0] * k, ey, ez + n[2] * k],
+          size: [4, 4, 2],
+          rotate: [0, upper ? -deg : deg, 0],
+          op: 'intersect',
+        },
+      ],
+      blend: r * 0.22,
+    };
+  };
+  e.push(lid(p.eyes.lid, true), lid(p.eyes.lowerLid, false));
+  // Nose: bridge (humped by `hook`), tip, wings, nostrils.
+  const noseRoot: Vec3 = [ex + r * 0.4, 0, ez - r * 0.4];
+  const noseDir: Vec3 = [tipX - noseRoot[0], 0, tipZ + 0.01 - noseRoot[2]];
+  const midNose: Vec3 = [
+    (ex + r * 0.6 + tipX) / 2,
+    0,
+    (ez - 0.02 + tipZ) / 2 + p.nose.hook * 0.6 + 0.01,
+  ];
+  e.push(
+    {
+      shape: 'cone',
+      at: noseRoot,
+      size: [0.02 + p.nose.width * 0.6, p.nose.tip * 0.8, Math.hypot(...noseDir)],
+      rotate: alongZ(noseDir),
+      blend: 0.04,
+    },
+    { shape: 'sphere', at: midNose, size: 0.02 + p.nose.width * 0.2, blend: 0.04 },
+    { shape: 'sphere', at: [tipX, 0, tipZ], size: p.nose.tip, blend: 0.03 },
+    {
+      shape: 'ellipsoid',
+      at: [tipX - p.nose.tip * 1.2, p.nose.width, l.noseZ + 0.02],
+      size: [0.045, 0.035, 0.032],
+      blend: 0.025,
+    },
+    {
+      shape: 'ellipsoid',
+      at: [tipX - p.nose.tip * 0.6, p.nose.width * 0.55, l.noseZ + 0.005],
+      size: [0.022, 0.014, 0.012],
+      op: 'subtract',
+      blend: 0.008,
+      color: c.mouth,
+    },
+  );
+  // Lips and the mouth line (a grin opens it and lifts the corners).
+  const g = p.mouth.grin;
+  e.push(
+    {
+      shape: 'ellipsoid',
+      at: [l.mouthX - 0.01, 0, l.mouthZ + lipT * 0.7],
+      size: [0.032, mw, lipT],
+      color: c.lips,
+      blend: 0.03,
+    },
+    {
+      shape: 'ellipsoid',
+      at: [l.mouthX - 0.015 + p.jaw.underbite * 0.7, 0, l.mouthZ - lipT * 0.8],
+      size: [0.034, mw * 0.85, lipT * 1.1],
+      color: c.lips,
+      blend: 0.03,
+    },
+    {
+      shape: 'capsule',
+      at: [l.mouthX + 0.05, 0, l.mouthZ],
+      to: [l.mouthX - 0.03 - 0.02 * g, mw * 0.98, l.mouthZ + 0.012 + g * 0.05],
+      size: 0.006 + g * 0.022,
+      op: 'subtract',
+      blend: 0.012,
+      color: c.mouth,
+    },
+  );
+  if (g > 0.15) e.push(...teethRows(p, l));
+  // Nasolabial fold from the nose wing towards the mouth corner.
+  const fold = unit([-0.02, mw - p.nose.width, l.mouthZ - l.noseZ]);
+  e.push({
+    shape: 'ellipsoid',
+    at: [tipX - p.nose.tip * 1.5 - 0.035, p.nose.width + 0.05, l.noseZ - 0.035],
+    size: [0.08, 0.006, 0.006],
+    rotate: alongX(fold),
+    op: 'subtract',
+    blend: 0.03,
+    color: c.shade,
+  });
+  return e;
+}
+
+/** Upper and lower teeth, visible in a grin: rounded blocks along the dental arch. */
+function teethRows(p: HeadParams, l: HeadLayout): SculptEdit[] {
+  const out: SculptEdit[] = [];
+  const mw = p.mouth.width * 0.8;
+  for (let i = 0; i < 4; i++) {
+    const a = ((i + 0.5) / 4) * 0.9;
+    const y = Math.sin(a) * mw;
+    const x = l.mouthX - 0.025 - (1 - Math.cos(a)) * mw * 0.9;
+    const z = l.mouthZ + 0.004 + p.mouth.grin * 0.03 * (i / 4);
+    for (const [dz, h] of [
+      [0.016, 0.02],
+      [-0.016, 0.018],
+    ] as const)
+      out.push({
+        shape: 'roundBox',
+        at: [x, y, z + dz * (1 + p.mouth.grin)],
+        size: [0.02, 0.028, h * (1 + p.mouth.grin * 0.6)],
+        round: 0.006,
+        rotate: [0, 0, (a * 180) / Math.PI],
+        color: p.colors.teeth,
+        blend: 0.003,
+      });
+  }
+  return out;
+}

package/src/kinds/head-geom.ts

@@ -0,0 +1,31 @@
+// Small geometry helpers for head edit lists: the `rotate` that points an edit's local X (or Z) along
+// a direction, and point/vector helpers.
+
+import type { Vec3 } from '../core/index.ts';
+
+const DEG = 180 / Math.PI;
+
+/** `rotate` (deg, X→Y→Z) taking local +X onto `d`, then rolling `roll` deg about it. */
+export function alongX(d: Vec3, roll = 0): Vec3 {
+  const yaw = Math.atan2(d[1], d[0]);
+  const pitch = -Math.atan2(d[2], Math.hypot(d[0], d[1]));
+  return [roll, pitch * DEG, yaw * DEG];
+}
+
+/** `rotate` taking local +Z (a cone's axis) onto `d`. */
+export function alongZ(d: Vec3): Vec3 {
+  const len = Math.hypot(d[0], d[1], d[2]) || 1;
+  const tilt = Math.acos(Math.max(-1, Math.min(1, d[2] / len)));
+  return [0, tilt * DEG, Math.atan2(d[1], d[0]) * DEG];
+}
+
+export const unit = (d: Vec3): Vec3 => {
+  const l = Math.hypot(d[0], d[1], d[2]) || 1;
+  return [d[0] / l, d[1] / l, d[2] / l];
+};
+
+export const along = (a: Vec3, d: Vec3, t: number): Vec3 => [
+  a[0] + d[0] * t,
+  a[1] + d[1] * t,
+  a[2] + d[2] * t,
+];