@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

package/vendor/procedural-animals/src/species/snake/sculpt.js

@@ -0,0 +1,122 @@
+// The snake sculpted as a signed distance field: a tube of round cones along the spine with a flat,
+// carved belly (loaf cross-section), a head modelled in head-local coordinates (origin at v0,
+// +Z forward), a separately meshed lower jaw, a forked tongue in two rigid pieces, hinged fangs
+// (rattlesnake) and a rattle.
+import { SPINE, bodyPlan } from './rig.js';
+import { add, sub, mul, norm, lerp } from '../../core/math/vec.js';
+import { sculptEyeSocket } from '../../core/sdf/eyeSocket.js';
+
+// Eye spec (core/sdf/eyeSocket.js) for this individual: round aperture (no lids: a spectacle),
+// iris filling the whole visible eye.
+export function eyeSpec(params) {
+  const B = bodyPlan(params);
+  const e = B.P.eye, k = B.kH * (params.age === 'juvenile' ? 1.15 : 1);
+  const r = e.r * k;
+  return {
+    c: [e.at[0] * B.kH, e.at[1] * B.kH, e.at[2] * B.kH], r, back: 0.0002 * B.kH, yaw: e.yaw, pitch: e.pitch,
+    lid: 0.00015 * B.kH, R: r * 0.96, d: 0, off: 0, tilt: 0, irisZ: r * 0.62, irisR: r * 0.9,
+  };
+}
+
+export function sculptSnake(m, rig, params) {
+  const J = rig.J, B = rig.plan, P = B.P, viper = params.variant === 'rattlesnake';
+  const HO = J.v0;
+  const hL = B.headLen, W = P.headW * B.kH, H = P.headH * B.kH;
+  const yB = -HO[1]; // head-local height of the belly / jaw underside (y = 0 in the world)
+  const hl = (v) => [HO[0] + v[0], HO[1] + v[1], HO[2] + v[2]];
+  const HB = { bone: 'head' };
+  const sym = (f) => { f(1); f(-1); };
+
+  // ---------------------------------------------------------------- BODY
+  // round cones of radius = half width; the axis sits at flat * hw, so the circle's lower part is
+  // carved off by the belly plane (flat belly with ventrolateral angles, rounded back)
+  const hwAt = [];
+  let total = 0;
+  const sig = [0];
+  for (let i = 0; i < SPINE; i++) { total += Math.hypot(...sub(J['v' + (i + 1)], J['v' + i])); sig.push(total); }
+  for (let i = 0; i <= SPINE; i++) hwAt.push(B.hw(sig[i] / total));
+  for (let i = 0; i < SPINE; i++) {
+    m.cone({ tag: i >= SPINE * (1 - B.tailFrac) ? 'tail' : i < 3 ? 'neck' : 'body', bone: 'spine' + i, a: J['v' + i], b: J['v' + (i + 1)], ra: hwAt[i], rb: hwAt[i + 1], k: 0 });
+  }
+  // thin tail tip: overlapping ellipsoids that the pipeline inflates at coarse tiers (minThick)
+  for (let i = SPINE - 12; i < SPINE; i++) {
+    const a = J['v' + i], b = J['v' + (i + 1)], rr = (hwAt[i] + hwAt[i + 1]) * 0.5;
+    m.ell({ tag: 'tailtip', bone: 'spine' + i, c: lerp(a, b, 0.5), axis: norm(sub(a, b)), r: [rr * 0.98, rr * 0.98, Math.hypot(...sub(a, b)) * 0.62], k: 0, thin: true });
+  }
+  // ---------------------------------------------------------------- HEAD (upper jaw + braincase)
+  if (viper) {
+    // broad, triangular: venom-gland bulges at the back, flat crown, blunt canthus, narrow neck
+    m.ell({ ...HB, tag: 'cranium', c: hl([0, yB + 0.62 * H, 0.36 * hL]), r: [0.33 * W, 0.34 * H, 0.36 * hL], k: 0.004 });
+    sym((s) => m.ell({ ...HB, tag: 'gland', c: hl([0.31 * W * s, yB + 0.5 * H, 0.22 * hL]), r: [0.28 * W, 0.34 * H, 0.27 * hL], axis: norm([0.35 * s, 0, 1]), k: 0.005 }));
+    sym((s) => m.ell({ ...HB, tag: 'cheek', c: hl([0.2 * W * s, yB + 0.5 * H, 0.52 * hL]), r: [0.22 * W, 0.3 * H, 0.3 * hL], axis: norm([-0.25 * s, 0, 1]), k: 0.005 }));
+    m.ell({ ...HB, tag: 'snout', c: hl([0, yB + 0.58 * H, 0.7 * hL]), r: [0.29 * W, 0.28 * H, 0.25 * hL], k: 0.005 });
+    sym((s) => m.ell({ ...HB, tag: 'lip', c: hl([0.26 * W * s, yB + 0.38 * H, 0.5 * hL]), r: [0.16 * W, 0.16 * H, 0.44 * hL], axis: norm([-0.28 * s, 0, 1]), k: 0.004 }));
+    m.sphere({ ...HB, tag: 'rostral', c: hl([0, yB + 0.5 * H, 0.94 * hL]), rad: 0.13 * W, k: 0.004 });
+    // supraocular scales: a brow shelf over each eye
+    const E = eyeSpec(params);
+    sym((s) => m.ell({ ...HB, tag: 'brow', c: hl([E.c[0] * s * 0.95, E.c[1] + E.r * 0.95, E.c[2]]), r: [E.r * 1.25, E.r * 0.5, E.r * 1.5], k: 0.0015 }));
+  } else {
+    // corn snake: barely wider than the neck, long rounded snout, domed crown
+    m.ell({ ...HB, tag: 'cranium', c: hl([0, yB + 0.6 * H, 0.34 * hL]), r: [0.42 * W, 0.4 * H, 0.4 * hL], k: 0.004 });
+    sym((s) => m.ell({ ...HB, tag: 'temporal', c: hl([0.2 * W * s, yB + 0.5 * H, 0.2 * hL]), r: [0.28 * W, 0.36 * H, 0.3 * hL], k: 0.004 }));
+    m.ell({ ...HB, tag: 'snout', c: hl([0, yB + 0.56 * H, 0.72 * hL]), r: [0.29 * W, 0.34 * H, 0.3 * hL], axis: norm([0, -0.08, 1]), k: 0.005 });
+    sym((s) => m.ell({ ...HB, tag: 'lip', c: hl([0.24 * W * s, yB + 0.4 * H, 0.52 * hL]), r: [0.19 * W, 0.2 * H, 0.42 * hL], axis: norm([-0.22 * s, 0, 1]), k: 0.004 }));
+    m.sphere({ ...HB, tag: 'rostral', c: hl([0, yB + 0.5 * H, 0.92 * hL]), rad: 0.17 * W, k: 0.004 });
+  }
+  // neck: blend the cranium into the first body cone
+  m.cone({ ...HB, tag: 'nape', a: hl([0, 0, 0.18 * hL]), b: hl([0, 0, -0.25 * hL]), ra: 0.3 * W, rb: hwAt[0] * 1.02, k: 0.01 });
+  // eyes in round sockets (the spectacle sits flush), nostrils, rostral notch for the tongue
+  const E = eyeSpec(params);
+  sym((s) => sculptEyeSocket(m, E, HO, s, { bone: 'head', orbit: { r: [E.r * 0.95, E.r * 0.8, E.r * 0.45], at: [0, 0, E.r * 1.0], k: E.r * 0.35 } }));
+  sym((s) => m.sphere({ ...HB, tag: 'nostril', c: hl([0.17 * W * s, yB + 0.62 * H, 0.95 * hL]), rad: 0.04 * W, k: 0.0006, carve: true }));
+  if (viper) sym((s) => m.sphere({ ...HB, tag: 'pit', c: hl([0.33 * W * s, yB + 0.48 * H, 0.8 * hL]), rad: 0.05 * W, k: 0.0006, carve: true }));
+  m.ell({ ...HB, tag: 'notch', c: hl([0, yB + 0.36 * H, 0.99 * hL]), r: [0.07 * W, 0.07 * H, 0.05 * hL], k: 0.0006, carve: true });
+
+  // palate: the upper jaw ends at the lip line (the lower jaw is its own surface)
+  m.ell({ ...HB, tag: 'palate', c: hl([0, yB + 0.1 * H, 0.62 * hL]), r: [0.33 * W, 0.26 * H, 0.5 * hL], k: 0.0012, carve: true });
+  // belly plane: a very flat carving ellipsoid whose top is y = 0 (sag < 0.2 mm over the body)
+  const zMid = (J.v0[2] + J['v' + SPINE][2]) * 0.5;
+  m.ell({ tag: 'belly', bone: 'spine' + (SPINE >> 1), c: [0, -0.012, zMid], r: [0.4, 0.012, 3.2], k: 0.18 * hwAt[SPINE >> 1], carve: true });
+
+  // ---------------------------------------------------------------- LOWER JAW (own surface)
+  const JW = { bone: 'jaw', group: 'jaw', part: 'jaw' };
+  sym((s) => m.cone({ ...JW, tag: 'mandible', a: hl([(viper ? 0.34 : 0.3) * W * s, yB + 0.22 * H, 0.08 * hL]), b: hl([0.07 * W * s, yB + 0.17 * H, 0.88 * hL]), ra: viper ? 0.14 * H + 0.05 * W : 0.11 * H + 0.03 * W, rb: viper ? 0.1 * H : 0.085 * H, k: 0.003 }));
+  m.ell({ ...JW, tag: 'jawfloor', c: hl([0, yB + 0.19 * H, 0.46 * hL]), r: [0.3 * W, 0.18 * H, 0.42 * hL], k: 0.003 });
+  m.sphere({ ...JW, tag: 'chin', c: hl([0, yB + 0.2 * H, 0.9 * hL]), rad: 0.14 * H, k: 0.003 });
+
+  // ---------------------------------------------------------------- TONGUE (two rigid pieces)
+  const tb = J.tongueBase, tf = J.tongueFork, tt = J.tongueTip;
+  const tr = 0.0007 * B.kH * (viper ? 1.25 : 1);
+  m.cone({ bone: 'tongue', group: 'tongue', part: 'tongue', tag: 'tongue', a: tb, b: add(tf, [0, 0, tr]), ra: tr * 1.1, rb: tr * 0.85, k: 0 });
+  const forkLen = Math.hypot(...sub(tt, tf));
+  sym((s) => m.cone({ bone: 'tongueTip', group: 'tongue', part: 'fork', tag: 'fork', a: add(tf, [0, 0, -tr * 0.5]), b: add(tt, [s * forkLen * 0.28, 0, 0]), ra: tr * 0.8, rb: tr * 0.32, k: tr * 0.6 }));
+
+  // ---------------------------------------------------------------- FANGS (rattlesnake)
+  if (viper) {
+    const fb = J.fangBase, ft = J.fangTip;
+    sym((s) => m.cone({ bone: 'fang', group: 'fang', part: 'fang', tag: 'fang', a: add(fb, [0.2 * W * s, 0, 0]), b: add(ft, [0.2 * W * s, 0, 0]), ra: 0.0009 * B.kH, rb: 0.00015, k: 0 }));
+  }
+
+  // ---------------------------------------------------------------- RATTLE
+  if (P.rattle) {
+    const last = 'spine' + (SPINE - 1);
+    const a = J['v' + (SPINE - 1)], b = J['v' + SPINE];
+    const d = norm(sub(b, a));
+    const nSeg = params.rattleSegs ?? P.rattle.segs;
+    const tip = hwAt[SPINE];
+    const segL = (P.rattle.len / P.rattle.segs) * (params.shape?.girth ?? 1);
+    for (let k = 0; k < nSeg; k++) {
+      const t = k / Math.max(1, P.rattle.segs - 1);
+      const w = tip * (1.35 - 0.3 * t);
+      const c0 = add(b, mul(d, segL * (k + 0.55)));
+      // the rattle rests on (not in) the ground: lift a segment whose half height exceeds the tip's axis height
+      const c = [c0[0], Math.max(c0[1], w * 0.78 + 0.0003), c0[2]];
+      // each segment: a flattened, bi-lobed bell overlapping the next
+      m.ell({ bone: last, part: 'rattle', group: 'rattle', tag: 'rattle', c, axis: d, r: [w, w * 0.78, segL * 0.62], k: segL * 0.25 });
+      m.ell({ bone: last, part: 'rattle', group: 'rattle', tag: 'rattle', c: add(c, mul(d, segL * 0.35)), axis: d, r: [w * 0.82, w * 0.62, segL * 0.38], k: segL * 0.2 });
+    }
+    // the tail tip plugs into the button
+    m.ell({ bone: last, part: 'rattle', group: 'rattle', tag: 'button', c: ((q) => [q[0], Math.max(q[1], tip * 0.9 + 0.0003), q[2]])(add(b, mul(d, -segL * 0.2))), axis: d, r: [tip * 1.05, tip * 0.9, segL * 0.7], k: 0 });
+  }
+  return m;
+}

package/vendor/procedural-animals/src/species/spider/coat.js

@@ -0,0 +1,279 @@
+// The spider's coat: chitin (material 8) under a covering of setae (shell hairs), and glossy bare
+// cuticle around the eyes and on the fangs (keratin-like, material 5).
+//
+// Wolf spider (Hogna / Lycosa type): dark brown carapace with a pale median band and pale
+// submarginal bands, dark striae radiating from the fovea, black ocular area; abdomen with a dark
+// lanceolate heart mark in front and pale chevrons behind; banded legs; black venter.
+// Tarantula morphs: red-knee (Brachypelma: velvet black, orange knee bands, pale rings, tan carapace
+// margin, reddish abdominal setae), rosy (Grammostola: pinkish brown) and pinktoe (Avicularia: black
+// with pink tarsi). Colours sampled from the reference photos.
+//
+// Pattern and mark distances are stored in "cheetah-equivalent" metres (real distance x PK) so the
+// covering shader's anti-aliasing widths and hair-level edge jitter, which are tuned for a cheetah,
+// stay proportionate on a 25 mm animal.
+import { spiderDims } from './rig.js';
+import { EYES, eyeSpec } from './sculpt.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+import { srgb, mix3 } from '../../core/build/coatKit.js';
+import { norm, sub, dot, cross, add, mul, smoothstep, clamp, mix, fbm3, len } from '../../core/math/vec.js';
+
+const MAT = { CHITIN: 8, KERATIN: 5 };
+
+function palette(p) {
+  const w = p.coatWarmth || 0, l = p.coatLightness || 0;
+  // warmth (rufous .. cool), lightness, and greyness (Pardosa-like grey individuals .. brown Hogna)
+  const gr = p.coatGrey || 0;
+  const tw = (c) => {
+    const r = c[0] * (1 + 0.12 * w + l), g = c[1] * (1 + 0.03 * w + l), b = c[2] * (1 - 0.12 * w + l);
+    const y = 0.3 * r + 0.55 * g + 0.15 * b;
+    return [mix(r, y, gr), mix(g, y, gr), mix(b, y * 1.04, gr)];
+  };
+  if (p.variant !== 'tarantula') {
+    return {
+      carapace: tw(srgb(0x3a2b1f)), stripe: tw(srgb(0xa08a6a)), margin: tw(srgb(0x8c7657)),
+      abdomen: tw(srgb(0x4e3b2a)), heart: tw(srgb(0x261b13)), chevron: tw(srgb(0x8e7a5c)), abdSide: tw(srgb(0x5d4935)),
+      leg: tw(srgb(0x5f4a35)), legBand: tw(srgb(0x9a8465)), legDark: tw(srgb(0x33261b)),
+      chel: srgb(0x1f1812), chelHair: tw(srgb(0x6a4a2c)), venter: srgb(0x1a1512), ocular: srgb(0x0d0b09),
+      fang: srgb(0x160f0b), palp: tw(srgb(0x5a4633)), spinneret: tw(srgb(0x6e5a44)),
+    };
+  }
+  const morph = p.morph || 'redknee';
+  const base = {
+    carapace: srgb(0x17120f), stripe: srgb(0x17120f), margin: srgb(0xc3884b),
+    abdomen: srgb(0x1a1411), heart: srgb(0x120d0b), chevron: srgb(0x6b3a22), abdSide: srgb(0x1c1512),
+    leg: srgb(0x15110e), legBand: srgb(0xd9651e), legDark: srgb(0x0f0c0a), legRing: srgb(0xe0a068),
+    chel: srgb(0x120e0c), chelHair: srgb(0x2a1d16), venter: srgb(0x0e0b09), ocular: srgb(0x0a0908),
+    fang: srgb(0x0e0a08), palp: srgb(0x16120f), spinneret: srgb(0x201813), tarsusTip: null,
+  };
+  if (morph === 'rosy') {
+    Object.assign(base, {
+      carapace: srgb(0x6e4c40), margin: srgb(0x9a7462), abdomen: srgb(0x5e4036), chevron: srgb(0x8a5a4a), abdSide: srgb(0x5a3e34),
+      leg: srgb(0x4a3530), legBand: srgb(0x86645a), legRing: srgb(0x9a7a6c), legDark: srgb(0x35261f), chelHair: srgb(0x6a4a3e), palp: srgb(0x4a3530),
+    });
+  } else if (morph === 'pinktoe') {
+    Object.assign(base, {
+      carapace: srgb(0x1b191d), margin: srgb(0x2a2630), abdomen: srgb(0x1c1a1e), chevron: srgb(0x3a3036), abdSide: srgb(0x1c1a1e),
+      leg: srgb(0x1a181c), legBand: srgb(0x2c2830), legRing: srgb(0x2c2830), legDark: srgb(0x121014), tarsusTip: srgb(0xe07a7a), palp: srgb(0x1a181c),
+    });
+  }
+  const tw2 = (c) => (c ? [c[0] * (1 + l), c[1] * (1 + l), c[2] * (1 + l)] : c);
+  for (const k of Object.keys(base)) base[k] = tw2(base[k]);
+  return base;
+}
+
+export function spiderCoat(ctx) {
+  const { rig, pos, nrm, regionOf, regionNames, weights, nV, params } = ctx;
+  const d = spiderDims(params);
+  const J = rig.J, BONES = rig.BONES;
+  const U = d.unit, F = U / 0.013, PK = 0.33 / U;
+  const wolf = d.variant === 'wolf';
+  const COL = palette(params);
+  const Mm = 0.001 * F; // one "wolf millimetre" at this variant's scale
+  const comb = new Float32Array(nV * 3), tint = new Float32Array(nV * 4), pattern = new Float32Array(nV).fill(1);
+  const mark = new Float32Array(nV).fill(1), furLen = new Float32Array(nV), patternColor = new Float32Array(nV * 4), surf = new Float32Array(nV * 4);
+  const dom = weights.dominant;
+  const contrast = params.patternContrast ?? 1;
+
+  // carapace landmarks
+  const z0 = J.pedA[2], z1 = J.front[2], Lc = z1 - z0;
+  const fovea = [0, 0, z0 + 0.36 * Lc];
+  const eyeC = add(J.ceph, [0, 0, 0.0]);
+  const halfW = (z) => {
+    // carapace half width along z (pear shape: widest behind the middle, narrow head)
+    const u = (z - z0) / Lc;
+    const wMax = d.carapace.wid * 0.0005, wHead = d.carapace.headW * 0.0005;
+    return u < 0.45 ? wMax * Math.sqrt(Math.max(0.05, 1 - ((0.45 - u) / 0.47) ** 2)) : mix(wMax, wHead, smoothstep(0.45, 0.85, u));
+  };
+  const eyes = [];
+  for (const e of EYES[d.variant]) { const E = eyeSpec(e); for (const s of [1, -1]) eyes.push({ c: eyeFrameOf(E, J.ceph, s).c, r: E.r }); }
+  const boneKind = BONES.map((b) => {
+    const m = /^(coxa|troch|femur|patella|tibia|meta|tarsus)(\d)([LR])$/.exec(b.name);
+    if (m) return { kind: 'leg', seg: m[1], leg: +m[2], S: m[3] };
+    if (/^palp/.test(b.name)) return { kind: 'palp', seg: b.name.replace(/^palp|[LR]$/g, '').toLowerCase() };
+    return { kind: b.name.replace(/[LR]$/, '') };
+  });
+  const segIdx = { coxa: 0, troch: 1, femur: 2, patella: 3, tibia: 4, meta: 5, tarsus: 6 };
+
+  for (let v = 0; v < nV; v++) {
+    const p = [pos[v * 3], pos[v * 3 + 1], pos[v * 3 + 2]];
+    const n = [nrm[v * 3], nrm[v * 3 + 1], nrm[v * 3 + 2]];
+    const rn = regionNames[regionOf[v]];
+    const b = BONES[dom[v]], bk = boneKind[dom[v]];
+    let col = COL.carapace, mat = MAT.CHITIN, fl = 0, gloss = 0.05, pat = 1, pcol = COL.stripe, pint = 0, mk = 1;
+    let cdir = [0, 0, -1];
+    const noise = fbm3(p[0] / (1.6 * Mm), p[1] / (1.6 * Mm), p[2] / (1.6 * Mm), 3) - 0.5;
+    const noiseF = fbm3(p[0] / (0.45 * Mm) + 7, p[1] / (0.45 * Mm), p[2] / (0.45 * Mm), 2) - 0.5;
+
+    if (rn.startsWith('fang')) {
+      mat = MAT.KERATIN; col = COL.fang; gloss = 0.9; fl = 0;
+      cdir = sub(J['fangTip' + rn.slice(-1)], J['cheTip' + rn.slice(-1)]);
+    } else if (rn.startsWith('chel')) {
+      const S = rn.slice(-1);
+      col = COL.chel; fl = (wolf ? 0.66 : 1.6) * Mm; gloss = 0.05;
+      cdir = sub(J['cheTip' + S], J['cheBase' + S]);
+      // hair on the front face, bare glossy cuticle near the tip (the fang base)
+      const t = dot(sub(p, J['cheBase' + S]), norm(cdir)) / len(cdir);
+      fl *= 1 - smoothstep(0.7, 0.95, t);
+      col = mix3(col, COL.chelHair, clamp(0.5 + noise, 0, 1) * (wolf ? 0.35 : 0.5) * (1 - smoothstep(0.6, 0.9, t)));
+    } else if (bk.kind === 'leg' || bk.kind === 'palp') {
+      // ---- legs and palps: distal hair flow, pale joint bands
+      const a = b.head, e = b.tail, ax = sub(e, a), L = len(ax);
+      cdir = ax;
+      const t = clamp(dot(sub(p, a), ax) / (L * L), 0, 1);
+      const seg = bk.kind === 'leg' ? bk.seg : bk.seg === 'coxa' ? 'coxa' : bk.seg === 'troch' ? 'troch' : bk.seg === 'femur' ? 'femur' : bk.seg === 'patella' ? 'patella' : bk.seg === 'tibia' ? 'tibia' : 'tarsus';
+      const si = segIdx[seg] ?? 6;
+      const up = n[1];
+      col = bk.kind === 'palp' ? COL.palp : COL.leg;
+      if (si <= 1) col = mix3(COL.venter, col, smoothstep(-0.2, 0.6, up));
+      // bands: pale rings near the distal end of femur, patella and tibia (wolf); red-knee: the
+      // orange band covers the patella top and the distal femur, pale rings at tibia / metatarsus ends
+      let bandD = 1e9, bandCol = COL.legBand;
+      const along = t * L; // metres from the segment start
+      if (wolf) {
+        if (si === 2) bandD = Math.min(Math.abs(along - L * 0.18) - 0.35 * Mm, Math.abs(along - L * 0.62) - 0.4 * Mm);
+        else if (si === 3) bandD = Math.abs(along - L * 0.5) - L * 0.22;
+        else if (si === 4) bandD = Math.min(Math.abs(along - L * 0.2) - 0.45 * Mm, Math.abs(along - L * 0.72) - 0.4 * Mm);
+        else if (si === 5) bandD = Math.abs(along - L * 0.12) - 0.3 * Mm;
+        // diffuse, mottled banding of the setae (not crisp rings)
+        bandD += 0.35 * Mm * noiseF + 0.25 * Mm * noise;
+      } else if ((params.morph || 'redknee') === 'redknee' || params.morph === 'rosy') {
+        if (si === 3) bandD = -0.2 * Mm + (0.25 - up) * 1.4 * Mm; // top of the patella
+        else if (si === 2) bandD = (L - along) - 0.12 * L + (0.2 - up) * 1.2 * Mm;
+        else if (si === 4) { bandD = Math.min(L - along - 0.07 * L, along - 0.04 * L) + (0.1 - up) * 0.8 * Mm; bandCol = COL.legRing; }
+        else if (si === 5) { bandD = (L - along) - 0.06 * L + (0.1 - up) * 0.8 * Mm; bandCol = COL.legRing; }
+        // "knee" stripes run lengthwise along the patella and tibia top in B. hamorii
+        if (si === 3 || si === 4) bandD = Math.min(bandD, Math.abs(dot(norm(cross(ax, [0, 1, 0])), sub(p, a))) - 0.4 * Mm + (0.5 - up) * 2 * Mm);
+      } else if (params.morph === 'pinktoe' && si === 6 && bk.kind === 'leg') {
+        col = COL.tarsusTip;
+      }
+      // (wolf: soft edges, about 3x the anti-aliasing width, and a lower contrast)
+      if (bandD < 1e8) { pat = bandD * PK * (wolf ? 0.33 : 1); pcol = bandCol; pint = contrast * (wolf ? 0.6 : 1); }
+      // darker ventral side and joint membranes
+      col = mix3(col, COL.legDark, smoothstep(0.1, -0.7, up) * 0.4);
+      const lens = wolf ? [0.62, 0.64, 0.85, 0.8, 0.8, 0.72, 0.66] : [1.8, 1.8, 3.4, 3.2, 3.2, 2.8, 2.4];
+      fl = lens[si] * Mm * (bk.kind === 'palp' ? 0.9 : 1) * (1 + 0.2 * noiseF);
+      if (!wolf && si === 6) fl *= 0.8;
+      gloss = 0.03;
+    } else if (bk.kind === 'abdomen' || bk.kind === 'pedicel' || bk.kind === 'spinnerets') {
+      // ---- abdomen: hair lying backwards, dorsal heart mark and chevrons, dark venter
+      const c = d.abdomen.c.map((x) => x * 0.001), r = d.abdomen.r.map((x) => x * 0.001);
+      const u = (p[2] - c[2]) / r[2]; // +1 front .. -1 rear
+      const up = n[1];
+      const dors = smoothstep(-0.1, 0.55, up);
+      col = mix3(COL.venter, mix3(COL.abdSide, COL.abdomen, dors), smoothstep(-0.75, -0.2, up));
+      cdir = [0, -0.15 * u, -1];
+      if (wolf) {
+        // lanceolate heart mark: a dark spear along the front half of the midline (tint), pale
+        // chevrons over the rear half (pattern)
+        const hw = mix(0.95, 0.15, clamp((0.95 - u) / 1.0, 0, 1)) * Mm;
+        const heart = (Math.abs(p[0]) - hw * (u > -0.1 ? 1 : 0)) / Mm;
+        col = mix3(col, COL.heart, smoothstep(0.3, -0.2, heart) * dors * contrast * smoothstep(-0.2, 0.2, u));
+        mk = Math.min(mk, u > -0.05 && u < 0.95 ? (Math.abs(Math.abs(p[0]) - hw) - 0.08 * Mm) * PK / (dors > 0.3 ? 1 : 1e3) : 1);
+        // rear half: pairs of pale spots flanking the midline, joined by faint, broken chevrons
+        let spots = 1e9, ch = 1e9;
+        for (let k = 0; k < 4; k++) {
+          const uz = -0.12 - k * 0.2;
+          spots = Math.min(spots, Math.hypot(Math.abs(p[0]) - r[0] * (0.3 - 0.03 * k), (u - uz) * r[2]) - 0.32 * Mm * (1 - 0.15 * k));
+          const vz = uz + Math.abs(p[0]) / r[0] * 0.25;
+          ch = Math.min(ch, Math.abs(u - vz) * r[2] - 0.1 * Mm * (1 - 0.2 * k));
+        }
+        ch = Math.max(ch, Math.abs(p[0]) - r[0] * 0.3, 0.25 * Mm * (noiseF + 0.2)); // broken up
+        // pale flanks: lateral pale bands (Hogna) framing the dorsum
+        const flank = Math.abs(Math.abs(p[0]) / r[0] - 0.72) * r[0] - 0.35 * Mm;
+        pat = (Math.min(spots, ch, flank + 0.3 * Mm * noise) + 0.2 * Mm * noiseF) * PK * 0.6;
+        pcol = COL.chevron;
+        pint = dors * contrast * 0.8 * smoothstep(-0.35, 0.1, up);
+        // mottling
+        col = [col[0] * (1 + 0.3 * noiseF), col[1] * (1 + 0.28 * noiseF), col[2] * (1 + 0.24 * noiseF)];
+        fl = 0.9 * Mm * (1 + 0.25 * noiseF);
+      } else {
+        // tarantula: long reddish setae on black; a bald urticating patch sometimes
+        // black under the hair, the long setae reddish (strand-mottled, stronger on the dorsum)
+        pat = (-0.5 * Mm + 0.2 * Mm * noise) * PK;
+        pcol = COL.chevron;
+        pint = smoothstep(-0.4, 0.3, up) * (0.4 + 0.3 * noiseF);
+        fl = (3.8 + 1.2 * noiseF) * Mm * smoothstep(-0.9, -0.3, up) + 1.2 * Mm;
+        if (params.bald) {
+          const bd = len([p[0] / r[0], (p[1] - c[1] - r[1] * 0.7) / r[1], (p[2] - c[2] + r[2] * 0.35) / r[2]]);
+          fl *= smoothstep(0.28, 0.42, bd + 0.05 * noise);
+        }
+      }
+      if (bk.kind === 'spinnerets') { col = COL.spinneret; fl *= 0.3; }
+      if (bk.kind === 'pedicel') fl *= 0.4;
+      gloss = 0.03;
+    } else {
+      // ---- prosoma: carapace, head, sternum
+      const up = n[1];
+      const x = p[0], z = p[2];
+      const W = halfW(z);
+      const dors = smoothstep(-0.15, 0.35, up);
+      col = mix3(COL.venter, COL.carapace, smoothstep(-0.55, -0.1, up));
+      // hair radiates back and out from the eye region
+      cdir = [x, 0, z - eyeC[2] - 0.001 * F];
+      const u = (z - z0) / Lc;
+      if (wolf) {
+        // median band: narrow between the eyes, widest over the thorax, narrowing to the rear
+        // (a narrow pale stripe between the eyes and down the face, widening behind the eyes)
+        const mw = (u > 0.72 ? mix(0.5, 0.35, smoothstep(0.72, 0.95, u)) : mix(0.4, 0.85, smoothstep(0.1, 0.55, u))) * Mm;
+        const median = Math.abs(x) - mw + 0.12 * Mm * noiseF;
+        // submarginal bands along the sides of the carapace
+        const rel = Math.abs(x) / Math.max(W, 1e-5);
+        const sub1 = Math.abs(rel - 0.8) * W - 0.13 * W + 0.1 * Mm * noise;
+        const subm = Math.max(sub1, (0.15 - up) * 3 * Mm, (u - 0.8) * 8 * Mm);
+        pat = Math.min(median, subm) * PK;
+        pint = dors * contrast;
+        pcol = COL.stripe;
+        // dark striae radiating from the fovea
+        let st = 1e9;
+        for (let k = 0; k < 4; k++) {
+          const ang = (-0.95 + k * 0.62);
+          const dir = [Math.sin(ang + Math.PI / 2), 0, Math.cos(ang + Math.PI / 2)];
+          const q = sub([Math.abs(x), 0, z], fovea);
+          const along = dot(q, dir);
+          if (along > 0.4 * Mm && along < W * 0.95) st = Math.min(st, Math.abs(q[0] * dir[2] - q[2] * dir[0]) - 0.08 * Mm * (1 - along / W));
+        }
+        mk = Math.min(mk, dors > 0.2 ? st * PK : 1);
+      } else {
+        // velvet black centre with a tan margin and faint radiating lines
+        const rel = Math.abs(x) / Math.max(W, 1e-5);
+        pat = (Math.max(0.78 - rel, 0) * W * 1.0 - 0.06 * Mm + (0.25 - up) * 0.5 * Mm) * PK;
+        if (up < -0.2) pat = 1;
+        pcol = COL.margin; pint = (params.morph === 'pinktoe' ? 0.3 : 1) * smoothstep(-0.2, 0.2, up);
+      }
+      // ocular area (and the tarantula's tubercle): bare, black, glossy
+      let eyeD = 1e9;
+      for (const e of eyes) eyeD = Math.min(eyeD, len(sub(p, e.c)) - e.r * 1.35);
+      if (eyeD < 0.5 * Mm * (wolf ? 1 : 0.6)) col = mix3(col, COL.ocular, smoothstep(0.5 * Mm, 0.05 * Mm, eyeD));
+      fl = (wolf ? 0.72 : 1.1) * Mm * smoothstep(0.05 * Mm, 0.6 * Mm, eyeD);
+      if (up < -0.5) fl *= 0.5; // sternum
+      gloss = eyeD < 0.3 * Mm ? 0.4 : 0.05;
+      if (b.name === 'head' && up > 0.2 && z > J.front[2] - 0.0015 * F) fl *= 0.6;
+    }
+
+    // low frequency colour noise
+    col = [col[0] * (1 + 0.22 * noise), col[1] * (1 + 0.2 * noise), col[2] * (1 + 0.16 * noise)];
+    // comb: tangent to the surface
+    let cd = sub(cdir, mul(n, dot(cdir, n)));
+    if (len(cd) < 1e-9) cd = norm(cross(n, [1, 0, 0])); else cd = norm(cd);
+    comb.set(cd, v * 3);
+    tint[v * 4] = col[0]; tint[v * 4 + 1] = col[1]; tint[v * 4 + 2] = col[2]; tint[v * 4 + 3] = mat;
+    pattern[v] = pat; mark[v] = mk; furLen[v] = fl;
+    patternColor[v * 4] = pcol[0]; patternColor[v * 4 + 1] = pcol[1]; patternColor[v * 4 + 2] = pcol[2]; patternColor[v * 4 + 3] = pint;
+    // gloss, feature scale (fine cuticle striation), agouti (banded setae), undercoat
+    surf[v * 4] = gloss; surf[v * 4 + 1] = -0.00012 * F; surf[v * 4 + 2] = wolf ? 0.35 : 0.1; surf[v * 4 + 3] = 0;
+  }
+
+  // smooth hair length so shells do not step
+  const nb = weights.neighbors, tmp = new Float32Array(nV);
+  for (let it = 0; it < 2; it++) {
+    for (let v = 0; v < nV; v++) {
+      const ns = nb[v];
+      if (!ns.length || tint[v * 4 + 3] !== MAT.CHITIN) { tmp[v] = furLen[v]; continue; }
+      let a = 0;
+      for (const u of ns) a += furLen[u];
+      tmp[v] = 0.5 * furLen[v] + (0.5 * a) / ns.length;
+    }
+    furLen.set(tmp);
+  }
+  return { comb, tint, pattern, mark, furLen, patternColor, surf, stats: { patternScale: PK } };
+}

package/vendor/procedural-animals/src/species/spider/index.js

@@ -0,0 +1,78 @@
+// Spider: wolf spider (Lycosidae, default) and tarantula (Theraphosidae, opts.variant = 'tarantula').
+// Body plan 'spider' (core/motion/spider.js): 8 legs x 7 segments, pedipalps, chelicerae with
+// fangs, eight simple eyes.
+import { spiderRig } from './rig.js';
+import { sculptSpider, EYES, eyeSpec } from './sculpt.js';
+import { spiderRegions } from './regions.js';
+import { spiderCoat } from './coat.js';
+import { motion } from './motion.js';
+
+// glossy black domes; the look.iris.outer colour tints the dome (dark amber-brown lens)
+const EYE_LOOK = {
+  pupil: 'round',
+  lids: 'simple',
+  // the dome colour comes from iris.outer: near black with a faint amber tapetum glint
+  iris: { inner: [0.02, 0.02, 0.02], mid: [0.03, 0.03, 0.025], hi: [0.05, 0.05, 0.04], outer: [0.3, 0.17, 0.05] },
+  sclera: { color: [0.02, 0.02, 0.02], visible: false },
+  lidColor: [0.02, 0.018, 0.015],
+  pupilSize: [0.4, 0.5],
+};
+
+export default {
+  id: 'spider',
+  name: 'Spider',
+  latin: 'Lycosidae / Theraphosidae',
+  group: 'others',
+  plan: 'spider',
+  covering: 'chitin',
+  variants: [
+    { id: 'wolf', name: 'Wolf spider', latin: 'Lycosidae' },
+    { id: 'tarantula', name: 'Tarantula', latin: 'Theraphosidae' },
+  ],
+
+  // Seeded individual. Females are larger with a heavy abdomen (gravid ones more so); males are
+  // smaller and leggier with swollen palpal bulbs; spiderlings are small and short-legged.
+  variation(R, o) {
+    const variant = o.variant === 'tarantula' ? 'tarantula' : 'wolf';
+    const sex = o.sex || (R() < 0.6 ? 'female' : 'male');
+    const age = o.age || 'adult';
+    const juv = age === 'juvenile';
+    const g = () => (R() + R() + R() - 1.5) / 1.5; // ~[-1, 1], peaked
+    const male = sex === 'male' && !juv;
+    const size = (male ? (variant === 'wolf' ? 0.82 : 0.88) : 1) * (1 + 0.08 * g()) * (juv ? 0.42 : 1);
+    const p = {
+      variant, sex, age, size,
+      quality: o.quality,
+      legK: (male ? 1.1 : 1) * (1 + 0.04 * g()) * (juv ? 0.9 : 1),
+      abdK: (male ? 0.78 : 1 + 0.08 * Math.abs(g()) + 0.05 * g()) * (juv ? 0.9 : 1),
+      palpBulb: male ? 1 : 0,
+      coatWarmth: 0.9 * g(),
+      coatLightness: 0.18 * g() + (male && variant === 'wolf' ? -0.08 : 0),
+      patternContrast: variant === 'wolf' ? 0.6 + 0.55 * R() : 1,
+      coatGrey: variant === 'wolf' ? 0.75 * R() ** 1.5 : 0,
+      coatSeed: Math.floor(R() * 1e6),
+      warps: [],
+    };
+    if (variant === 'tarantula') {
+      const m = R();
+      p.morph = m < 0.6 ? 'redknee' : m < 0.8 ? 'rosy' : 'pinktoe';
+      p.bald = R() < 0.3; // kicked off its urticating hairs
+    }
+    return p;
+  },
+  rig: (params) => spiderRig(params),
+  sculpt: (m, rig, params) => sculptSpider(m, rig, params),
+  regions: spiderRegions,
+  coat: spiderCoat,
+  eyeSpecs: (params, rig) => {
+    const out = [];
+    for (const e of EYES[params.variant === 'tarantula' ? 'tarantula' : 'wolf']) for (const side of [1, -1]) out.push({ side, spec: eyeSpec(e), headOrigin: rig.J.ceph, bone: 'head', look: EYE_LOOK });
+    return out;
+  },
+  motion,
+  // setae: fine but still resolvable strands (a few per millimetre), loosely tufted; the tarantula's
+  // long hair is coarser and fuzzier
+  render: (params) => (params?.variant === 'tarantula'
+    ? { markColor: [0.012, 0.009, 0.007], strandDensity: 3000, clumpDensity: 3, shellScale: 1, finWidth: 0.6 }
+    : { markColor: [0.012, 0.009, 0.007], strandDensity: 5000, clumpDensity: 5, shellScale: 1, finWidth: 0.45 }),
+};

package/vendor/procedural-animals/src/species/spider/motion.js

@@ -0,0 +1,72 @@
+// Spider motion data for the spider engine (schema: src/core/motion/spider.js).
+// Numbers are for the reference individual of each variant (params.size = 1); the engine scales
+// speeds by dynamic similarity (sqrt(size)) and reads every length from the joints.
+//
+// Gait: alternating tetrapod (L1 R2 L3 R4 against R1 L2 R3 L4) with a back-to-front metachronal lag
+// inside each tetrapod (Biancardi et al. 2011 on Grammostola: quadruped lag 16 % slow, 8 % fast;
+// Weihmann 2013 on Cupiennius: contralateral pairs in antiphase, body oscillation tiny). Offsets are
+// touchdown phases relative to L4, in the order L1 L2 L3 L4 R1 R2 R3 R4.
+// Duty factor falls with speed (d = 0.666 - 0.531 v for Grammostola; Cupiennius < 0.5 when fast);
+// stride frequency rises with speed (f = 14.4 v + 0.14 Hz for an 18 g tarantula, faster for the
+// smaller wolf spider by dynamic similarity).
+const slow = [0.74, 0.16, 0.58, 0.0, 0.24, 0.66, 0.08, 0.5];
+const fast = [0.62, 0.08, 0.54, 0.0, 0.12, 0.58, 0.04, 0.5];
+const G = (name, v, f, D, off, o = {}) => ({ name, v, f, D, off, ...o });
+
+export const motion = {
+  // ---------------------------------------------------------------- wolf spider (default)
+  maxSpeed: 0.32, // m/s: a dash (wolf spiders sprint at 0.3-0.6 m/s over short distances)
+  accel: 1.6, // m/s^2: wolf spiders reach full speed within a stride or two
+  decel: 2.4, // and freeze abruptly
+  turnRate: 4.0, // rad/s (on the spot and at a walk)
+  latAccelMax: 0.4, // m/s^2: at speed it turns in arcs of a few body lengths
+  gears: { walk: 0.05, run: 0.14, sprint: 0.3 },
+  gaits: [
+    G('walk', 0.0, 1.6, 0.72, slow, { lift: 0.0022, bob: 0.00008, sway: 0.015 }),
+    G('walk', 0.05, 2.4, 0.66, slow, { lift: 0.0026, bob: 0.00012, sway: 0.015 }),
+    G('run', 0.1, 3.3, 0.58, fast, { lift: 0.003, bob: 0.00016, sway: 0.01 }),
+    G('run', 0.18, 4.9, 0.5, fast, { lift: 0.0034, bob: 0.0002, sway: 0.008 }),
+    G('run', 0.3, 6.0, 0.48, fast, { lift: 0.0038, bob: 0.00022, sway: 0.006 }),
+  ],
+  // neutral footholds: bind claw positions pulled toward the coxa (legs are not fully spread in
+  // stance) and the stance height relative to the bind pose
+  stance: { reach: [0.8, 0.9, 0.9, 0.78], height: 1.0, width: 1.0 },
+  feet: { contact: 'claw', heelLift: 12 },
+  abdomen: { stiffness: 16, lag: 0.12, droop: 0.05 },
+  breath: { rate: 0.55, amp: 0.018 },
+  chelicerae: { fang: 'labidognath', fangOpen: 1.25, spread: 0.35, pitch: 0.45 },
+  palps: { twitch: 1, tap: 0.6 },
+  idle: { twitch: 1, raiseFront: 0.12, look: 0.35 },
+  look: { yaw: 0.45, pitch: 0.32 },
+  actions: {
+    jump: { height: 0.016, distance: 0.035, crouch: 0.25 },
+    attack: { style: 'threat-lunge', rear: 0.3, lunge: 0.005, threat: 0.7 },
+    sleep: { tuck: 0.85 },
+  },
+
+  // ---------------------------------------------------------------- tarantula
+  variants: {
+    tarantula: {
+      maxSpeed: 0.18,
+      accel: 1.2,
+      decel: 2.4,
+      turnRate: 3.2,
+      gears: { walk: 0.035, run: 0.1, sprint: 0.2 },
+      gaits: [
+        G('walk', 0.0, 0.8, 0.7, slow, { lift: 0.005, bob: 0.00015, sway: 0.012 }),
+        G('walk', 0.04, 1.4, 0.65, slow, { lift: 0.0055, bob: 0.0002, sway: 0.012 }),
+        G('run', 0.11, 2.4, 0.6, fast, { lift: 0.0065, bob: 0.0003, sway: 0.008 }),
+        G('run', 0.236, 3.6, 0.54, fast, { lift: 0.0075, bob: 0.0004, sway: 0.006 }),
+      ],
+      stance: { reach: [0.88, 0.93, 0.93, 0.88], height: 1.0, width: 1.0 },
+      breath: { rate: 0.35, amp: 0.012 },
+      chelicerae: { fang: 'orthognath', fangOpen: 1.2, spread: 0.12, pitch: 0.55 },
+      idle: { twitch: 0.5, raiseFront: 0.05, look: 0.2 },
+      actions: {
+        jump: { height: 0.012, distance: 0.05, crouch: 0.2 },
+        attack: { style: 'threat-lunge', rear: 0.7, raise2: 0.65, lunge: 0.008, threat: 0.9 },
+        sleep: { tuck: 0.8 },
+      },
+    },
+  },
+};

package/vendor/procedural-animals/src/species/spider/regions.js

@@ -0,0 +1,87 @@
+// Meshing plan. A spider is mostly thin legs spread over a wide box, so one dense grid would be
+// wasteful: the body (prosoma, abdomen, palps, coxae, trochanters) is one region, every leg its
+// own region from the middle of the trochanter outward, and the chelicerae and fangs are rigid
+// regions of their own (they move on their own bones). Legs and body overlap across a cut plane
+// through the trochanter and cross-fade there (both surfaces see the same primitives near the cut).
+import { spiderDims } from './rig.js';
+import { legJoints, LEG_KEYS } from '../../core/rig/spider.js';
+import { lerp, norm, sub, smoothstep } from '../../core/math/vec.js';
+
+// cut planes through the trochanters (reference space)
+export function legCuts(J, d) {
+  const F = d.unit / 0.013;
+  return LEG_KEYS.map((key) => {
+    const S = key[0], i = +key[1];
+    const lj = legJoints(i, S);
+    const t = J[lj[1]], f = J[lj[2]];
+    return { key, p: lerp(t, f, 0.5), n: norm(sub(f, t)), e: J[lj[3]], r: d.legR[2][0] * 0.001 * 2.2 * (i === 4 ? d.hindR : 1) };
+  });
+}
+
+function box(points, pad) {
+  const mn = [1e9, 1e9, 1e9], mx = [-1e9, -1e9, -1e9];
+  for (const p of points) for (let k = 0; k < 3; k++) { mn[k] = Math.min(mn[k], p[k] - pad); mx[k] = Math.max(mx[k], p[k] + pad); }
+  return [mn, mx];
+}
+
+export function spiderRegions(rig, params, Q) {
+  const J = rig.J, d = spiderDims(params);
+  // the tarantula is stockier (thicker legs, bigger abdomen for its unit): slightly coarser cells
+  const F = (d.unit / 0.013) * (d.variant === 'tarantula' ? 1.12 : 1), r = Q.res;
+  const hB = 0.156e-3 * F * r, hL = 0.148e-3 * F * r, hC = 0.115e-3 * F * r;
+  const B = 2.2 * Math.max(hB, hL);
+  const cuts = legCuts(J, d);
+  // s: signed distance along the cut normal; near: within reach of the leg (distance to the segment
+  // from the cut centre to the knee)
+  for (const c of cuts) { c.ab = sub(c.e, c.p); c.ab2 = c.ab[0] ** 2 + c.ab[1] ** 2 + c.ab[2] ** 2; }
+  const inCut = (c, x, y, z) => {
+    const dx = x - c.p[0], dy = y - c.p[1], dz = z - c.p[2];
+    const s = dx * c.n[0] + dy * c.n[1] + dz * c.n[2];
+    const t = Math.max(0, Math.min(1, (dx * c.ab[0] + dy * c.ab[1] + dz * c.ab[2]) / c.ab2));
+    const ex = dx - c.ab[0] * t, ey = dy - c.ab[1] * t, ez = dz - c.ab[2] * t;
+    return { s, near: ex * ex + ey * ey + ez * ez < c.r * c.r };
+  };
+  const bodyClip = (x, y, z) => {
+    for (const c of cuts) { const q = inCut(c, x, y, z); if (q.near && q.s > B) return false; }
+    return true;
+  };
+  const maxR = Math.max(...d.legR.map((q) => q[0])) * 0.001 * d.hindR;
+  const minPad = 0.4e-3 * F;
+  // body box: axial joints, palps, coxae, trochanters, the start of the femora
+  const bodyPts = [];
+  for (const k of Object.keys(J)) if (!/^(femur|patella|tibia|meta|tarsus|claw)/.test(k)) bodyPts.push(J[k]);
+  for (const c of cuts) bodyPts.push(c.p);
+  const abd = d.abdomen.r.map((x) => x * 0.001);
+  const [bmin, bmax] = box(bodyPts, Math.max(abd[0], abd[1]) + minPad);
+  bmin[1] = Math.max(bmin[1], -0.2e-3 * F);
+  const regions = [{ name: 'body', part: 'body', bmin, bmax, h: hB, F: 5, clip: bodyClip }];
+  const rigid = [];
+  for (const S of ['L', 'R']) {
+    const [cmin, cmax] = box([J['cheBase' + S], J['cheTip' + S]], d.chel.r[0] * 0.0013 + minPad);
+    rigid.push({ name: 'chel' + S, part: 'chel' + S, bmin: cmin, bmax: cmax, h: hC, F: 5, rigidBone: 'chelicera' + S });
+    const [fmin, fmax] = box([J['cheTip' + S], J['fangTip' + S]], d.chel.fangR * 0.0015 + minPad * 0.5);
+    rigid.push({ name: 'fang' + S, part: 'fang' + S, bmin: fmin, bmax: fmax, h: hC * 0.8, F: 5, rigidBone: 'fang' + S });
+  }
+  const legs = { L: [], R: [] };
+  for (const c of cuts) {
+    const S = c.key[0], i = +c.key[1];
+    const lj = legJoints(i, S).slice(1).map((n) => J[n]);
+    const [lmin, lmax] = box(lj, maxR * 1.3 + minPad);
+    legs[S].push({ name: 'leg' + c.key, part: 'leg' + c.key, bmin: lmin, bmax: lmax, h: hL, F: 5, clip: (x, y, z) => inCut(c, x, y, z).s > -B });
+  }
+  return {
+    jobs: [[...regions, ...rigid], legs.L, legs.R],
+    fade(x, y, z, name) {
+      if (name === 'body') {
+        let f = 1;
+        for (const c of cuts) { const q = inCut(c, x, y, z); if (q.near) f *= 1 - smoothstep(-B, B, q.s); }
+        return f;
+      }
+      if (name.startsWith('leg')) {
+        const c = cuts.find((q) => 'leg' + q.key === name);
+        return smoothstep(-B, B, inCut(c, x, y, z).s);
+      }
+      return 1;
+    },
+  };
+}