@developerz.ai/ts23d 0.1.0 → 0.2.0

package/src/kinds/head-armour.ts

@@ -1,25 +1,27 @@
-// The orc's armoured bust gear as sculpt groups: layered metal pauldron lames (domes trimmed by a
-// tilted plane, each with a rolled rim), bone spikes, a leather baldric that follows the chest
-// (a shell of the chest ∩ a diagonal slab) with an iron buckle, and a fur mantle of clumped,
-// tapering strands. Head units, mirrored across Y unless an edit opts out.
+// 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, op: 'intersect' | 'subtract' = 'intersect'): SculptEdit => {
+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,
+    op: 'intersect',
   };
 };
 
@@ -32,84 +34,119 @@ const slab = (p: Vec3, deg: number, t: number): SculptEdit => ({
   op: 'intersect',
 });
 
-/** Chest ellipsoid of the bust (shared with head-bust.ts so the strap hugs it). */
-export const chestOf = (cx: number, s: number, b: number): { at: Vec3; r: Vec3 } => ({
-  at: [cx - 0.04, 0, b + 0.2],
-  r: [0.36, s * 0.75, 0.42],
+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],
 });
 
-export function armour(p: HeadParams, cx: number, s: number, b: number, nz: number): SculptEdit[] {
+/** 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[] = [];
-  // Pauldrons: three lames, top one biggest, stepping down and out; rims a darker iron.
-  for (let k = 0; k < 3; k++) {
-    const at: Vec3 = [cx - 0.03, s * (0.78 + k * 0.1), b + 0.53 - k * 0.12];
-    const r: Vec3 = [0.31 - k * 0.02, 0.27 - k * 0.03, 0.19 - k * 0.02];
-    const tilt = -(28 + k * 14);
-    const cut: Vec3 = [at[0], at[1], at[2] - r[2] * 0.35];
-    out.push(
-      {
-        group: [{ shape: 'ellipsoid', at, size: r }, above(cut, tilt)],
-        color: shade(metal, 1 - k * 0.12),
-        blend: 0.008,
-      },
-      {
-        group: [
-          { shape: 'ellipsoid', at, size: [r[0] + 0.018, r[1] + 0.018, r[2] + 0.018] },
-          slab(cut, tilt, 0.035),
-        ],
-        color: shade(metal, 0.55),
-        blend: 0.004,
-      },
-    );
-    // Rivets along the top of each lame's rim.
+  // 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 t = (j - 1.5) * 0.11;
+      const x = at[0] + (j - 1.5) * 0.12;
       out.push({
         shape: 'sphere',
-        at: [at[0] + t, at[1] + Math.sin(-tilt * RAD) * r[1] * 0.55, cut[2] + 0.03],
-        size: 0.016,
-        color: shade(metal, 1.4),
+        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,
       });
     }
   }
-  // Bone spikes along the top lame's ridge.
+  // 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: [cx - 0.17 + k * 0.14, s * 0.84, b + 0.68 - Math.abs(k - 1) * 0.03],
-      size: [0.065, 0.006, 0.26 - Math.abs(k - 1) * 0.08],
-      rotate: alongZ(unit([(k - 1) * 0.35, 0.45, 1])),
+      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.01,
+      blend: 0.015,
     });
-  // Baldric: a shell of the chest cut to a diagonal band, over the left shoulder; iron buckle.
-  const chest = chestOf(cx, s, b);
-  const grow = (g: number): Vec3 => [chest.r[0] + g, chest.r[1] + g, chest.r[2] + g];
-  const band: Vec3 = [cx, 0, b + 0.28];
+  // 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: [{ shape: 'ellipsoid', at: chest.at, size: grow(0.03) }, slab(band, 52, 0.17)],
+      group: [{ group: torsoForms(f, 0.03) }, slab(band, 50, 0.15), bustCut(f)],
       color: c.leather,
       blend: 0.006,
       mirror: false,
     },
     {
       group: [
-        { shape: 'ellipsoid', at: chest.at, size: grow(0.055) },
+        { group: torsoForms(f, 0.055) },
+        bustCut(f),
         {
           shape: 'roundBox',
-          at: [cx + 0.3, 0.02, b + 0.3],
-          size: [0.3, 0.15, 0.15],
-          rotate: [52, 0, 0],
+          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.3],
-          size: [0.1, 0.045, 0.045],
+          at: [cx + 0.42, 0.02, b + 0.38],
+          size: [0.1, 0.04, 0.04],
           op: 'subtract',
         },
       ],
@@ -118,33 +155,26 @@ export function armour(p: HeadParams, cx: number, s: number, b: number, nz: numb
       mirror: false,
     },
   );
-  // Fur mantle: a thick base roll, then clumped strands fanning out and down from it.
+  // Fur mantle over the trapezius: clumped strands fanning back and out from behind the neck.
   const fur = c.fur ?? c.leather;
-  const R = p.neck.radius + 0.1;
-  out.push({
-    shape: 'torus',
-    at: [cx - 0.08, 0, nz + 0.02],
-    size: [R, 0.07],
-    color: shade(fur, 0.75),
-    blend: 0.04,
-  });
-  for (let row = 0; row < 2; row++)
-    for (let i = 0; i < 10; i++) {
-      const a = (-85 + i * 20 + row * 10) * RAD;
-      const rr = R + row * 0.05;
+  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.08 + Math.cos(a) * rr,
-        Math.abs(Math.sin(a)) * rr + 0.015,
-        nz + 0.07 - row * 0.06,
+        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([Math.cos(a), Math.abs(Math.sin(a)), -0.5 - ((i + row) % 2) * 0.35]);
+      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.07 - row * 0.01, 0.012, 0.13 + ((i + row) % 3) * 0.03],
+        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.7),
-        blend: 0.03,
+        color: (i + row) % 2 ? fur : shade(fur, 0.72),
+        blend: 0.035,
       });
     }
   return out;

package/src/kinds/head-bust.ts

@@ -1,38 +1,22 @@
-// 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.
+// 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 } from '../primitives/index.ts';
-import { armour, chestOf } from './head-armour.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';
-
-/** 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,
-    },
-  ];
-}
+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;
@@ -80,14 +64,16 @@ function hood(p: HeadParams, cx: number, nz: number): SculptEdit[] {
   ];
 }
 
-function tunic(p: HeadParams, cx: number, s: number, b: number, nz: number): SculptEdit[] {
+function tunic(p: HeadParams, f: BustFrame): 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 { 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 => ({
@@ -117,6 +103,7 @@ function tunic(p: HeadParams, cx: number, s: number, b: number, nz: number): Scu
         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,
@@ -154,68 +141,44 @@ function tunic(p: HeadParams, cx: number, s: number, b: number, nz: number): Scu
       blend: 0.004,
       mirror: false,
     },
-    ...[0.42, 0.3, 0.18].map(
+    // Brass buttons seated on the chest surface (probed along −X at the midline).
+    ...[0.5, 0.38, 0.26].map(
       (z): SculptEdit => ({
-        group: [
-          shell(0.03),
-          { shape: 'sphere', at: [cx + 0.3, 0, b + z], size: 0.03, op: 'intersect' },
-        ],
+        shape: 'sphere',
+        at: [front(b + z) + 0.014, 0, b + z],
+        size: 0.028,
         color: c.metal,
-        blend: 0.003,
+        blend: 0.004,
         mirror: false,
       }),
     ),
   ];
 }
 
-export function bustEdits(p: HeadParams, l: HeadLayout): SculptEdit[] {
+/** `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 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 f = frameOf(p, l);
+  const style = p.bust.style;
+  const bare = style === 'pauldrons' || style === 'vest';
   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,
-    },
+    ...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: 'capsule',
-      at: [cx - 0.08, 0, nz - 0.05],
-      to: [cx - 0.1, 0, nz + 0.12],
-      size: p.neck.radius * 1.05,
+      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.03,
+      blend: 0.04,
     },
   ];
-  // 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));
+  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, b - 1], size: [4, 4, 2], op: 'subtract' });
+  e.push({ shape: 'roundBox', at: [0, 0, f.floor - 1], size: [4, 4, 2], op: 'subtract' });
   return e;
 }