@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,272 @@
+// The brown bear, sculpted as a signed distance field.
+// Every primitive is attached to a bone (skinning) and a group (axial / limb / ear / jaw). A bear's
+// silhouette is mostly coat over fat and muscle: the barrel, the shoulder hump (trapezius /
+// rhomboid digging muscle plus fat and the long guard hair of the ruff), the heavy "trousers" of the
+// forearms and thighs are sculpted as volume, the shells add the hair on top.
+// params: hump (0 black bear .. 1.3 big grizzly male), dish (dished facial profile 0..1), headW,
+// muzzle, ear, juv (cub: domed head), girth, claw (claw length factor).
+import { HEAD_O, TAIL_SEGS, hlOf } from './rig.js';
+import { add, sub, mul, lerp, norm, cross } from '../../core/math/vec.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+
+// Eye geometry shared by the sculpt (lids + aperture) and the eyeball shader (head-local, left eye).
+// Small eyes (~16 x 11 mm palpebral fissure, eyeball r 12 mm), set forward (diverging ~20 deg),
+// ~90 mm apart (x headW; face1 / face2: the nose pad's bottom 0.91-0.98 eye separations under the eye line);
+// the eyeball front flush with the skin (1.08 r: at 0.043 / 0.0668 the brow, bridge and cheek stood 5 mm in
+// front of it, 1.36 r, and the lids were buried in a tunnel).
+export const EYE_BASE = { c: [0.045, 0.03, 0.0698], r: 0.014, back: 0.003, yaw: 0.36, pitch: 0.06, lid: 0.0018, R: 0.0116, d: 0.0049, off: -0.0014, tilt: (10 * Math.PI) / 180, irisZ: 0.0086, irisR: 0.0108 };
+export const eyeOf = (params = {}) => ({ ...EYE_BASE, c: [EYE_BASE.c[0] * (params.headW || 1), EYE_BASE.c[1], EYE_BASE.c[2]] });
+
+const X = [1, 0, 0];
+// the toe joints (ftoe / htoe) sit at the claw tips: the paw rolls about them at push-off, so the
+// claws never dig into the ground (m ahead of the toe pads)
+export const TOE_F = 0.05, TOE_H = 0.035;
+
+export function sculptBear(m, rig, params = {}) {
+  const J = rig.J;
+  const EYE = eyeOf(params);
+  const mz = params.muzzle || 1, hw = params.headW || 1, juv = params.juv || 0;
+  const hump = params.hump ?? 1, dish = params.dish ?? 1, girth = params.girth ?? 1;
+  const hl = hlOf(mz, hw);
+  const hr = (r) => [r[0] * hw, r[1], r[2]]; // radii in head space
+  const eyeFrame = (s) => eyeFrameOf(EYE, HEAD_O, s);
+
+  // Ellipsoid whose local Y follows `ydir`; radii = [lateral, along ydir, third axis]
+  const ellY = (o) => {
+    const y = norm(o.ydir);
+    const lat = o.lateral || X;
+    const z = norm(cross(lat, y));
+    return m.ell({ ...o, axis: z, up: y, r: [o.r[0], o.r[1], o.r[2]] });
+  };
+  const G = girth;
+  // the barrel is broad: from the front a brown bear's body with its coat is ~2x its head and ~3x its
+  // stance wide (tq2, front3); the torso's lateral radii carry this factor (1: the body read narrow,
+  // 1.3x its head, under an oversized head)
+  const GW = G * 1.12;
+
+  // ---------------------------------------------------------------- TORSO
+  // a deep, very broad barrel; the back line dips a little behind the hump and rises to the rump;
+  // the belly hangs low with its fringe of long hair
+  m.ell({ tag: 'ribcage', bone: 'spine3', c: [0, 0.665, 0.06], r: [0.235 * GW, 0.22, 0.32], axis: norm([0, 0.05, -1]), k: 0 });
+  m.ell({ tag: 'brisket', bone: 'chest', c: [0, 0.58, 0.29], r: [0.175 * GW, 0.17, 0.14], axis: norm([0, -0.3, 1]), k: 0.08 });
+  m.ell({ tag: 'pectoral', bone: 'chest', c: [0, 0.645, 0.38], r: [0.165 * GW, 0.15, 0.09], k: 0.07 });
+  m.ell({ tag: 'withers', bone: 'chest', c: [0, 0.84, 0.17], r: [0.15 * GW, 0.09, 0.18], axis: norm([0, -0.1, 1]), k: 0.08 });
+  // the hump: a mass of muscle and fat over the shoulder blades (absent in the black bear), a broad
+  // swell from the nape well back over the shoulders that runs into the back line (side1, side2, tq4);
+  // (a 32 cm long, 14 cm tall mound stood up on big males like a camel's hump)
+  // (moderate: the back's highest point over the shoulders, ~4-6 % of the height above the back behind it, side1 / side2;
+  // 12 cm above it, blended with k 0.12, the render's was 10-13 % and read as a big mound)
+  if (hump > 0.05) {
+    const ry = 0.03 * hump + 0.035;
+    m.ell({ tag: 'hump', bone: 'chest', c: [0, 0.905 + 0.03 * hump - ry, 0.225], r: [0.13 * GW * (0.7 + 0.3 * hump), ry, 0.24], axis: norm([0, 0.08, 1]), k: 0.07 });
+  }
+  m.ell({ tag: 'back', bone: 'spine3', c: [0, 0.82, -0.04], r: [0.17 * GW, 0.08, 0.18], k: 0.08 });
+  m.ell({ tag: 'abdomen', bone: 'spine2', c: [0, 0.655, -0.14], r: [0.195 * GW, 0.19, 0.22], axis: norm([0, 0.08, -1]), k: 0.08 });
+  // (4 cm lower and longer than before: the belly line hangs at 0.23-0.30 of the hump height in side1-3, the
+  // render's was 0.34-0.36)
+  // (its front end stays 5 cm behind the elbows: reaching them, it took forearm weight and the lying forearm
+  // pressed 11 mm into the ground as the bear rose from sleep)
+  m.ell({ tag: 'belly', bone: 'spine2', c: [0, 0.475, -0.05], r: [0.12 * GW, 0.09, 0.2], k: 0.08 });
+  m.ell({ tag: 'loin', bone: 'spine1', c: [0, 0.81, -0.21], r: [0.17 * GW, 0.08, 0.15], k: 0.07 });
+  m.ell({ tag: 'flank', bone: 'spine1', c: [0, 0.665, -0.28], r: [0.19 * GW, 0.17, 0.14], k: 0.07 });
+  m.ell({ tag: 'pelvis', bone: 'pelvis', c: [0, 0.73, -0.4], r: [0.19 * GW, 0.155, 0.15], k: 0.07 });
+  m.ell({ tag: 'croup', bone: 'pelvis', c: [0, 0.82, -0.38], r: [0.15 * GW, 0.07, 0.14], k: 0.06 });
+  // the crotch between the thighs belongs to the body (anchors the midline skin: the thighs fold
+  // forward when lying and pulled it apart)
+  m.ell({ tag: 'perineum', bone: 'pelvis', c: [0, 0.6, -0.45], r: [0.07, 0.07, 0.13], k: 0.06 });
+  for (const s of [1, -1]) {
+    // round heavy buttocks behind the thighs
+    m.ell({ tag: 'rump', bone: 'pelvis', c: [0.09 * s * GW, 0.7, -0.5], r: [0.105 * GW, 0.14, 0.1], k: 0.06 });
+  }
+
+  // ---------------------------------------------------------------- NECK (short, as thick as the head)
+  m.cone({ tag: 'neck', bone: 'neck1', a: [0, 0.72, 0.32], b: [0, 0.775, 0.49], ra: 0.17 * G, rb: 0.135, k: 0.08 });
+  m.cone({ tag: 'neck', bone: 'neck2', a: [0, 0.775, 0.49], b: [0, 0.785, 0.58], ra: 0.125, rb: 0.1, k: 0.07 });
+  m.ell({ tag: 'nape', bone: 'neck1', c: [0, 0.83, 0.37], r: [0.11 * G, 0.06, 0.13], axis: norm([0, 0.25, 1]), k: 0.07 });
+  m.ell({ tag: 'throat', bone: 'neck2', c: [0, 0.67, 0.51], r: [0.095, 0.09, 0.1], axis: norm([0, 0.6, 0.8]), k: 0.08 });
+  // ruff: long hair down the sides of the neck and under the throat
+  m.ell({ tag: 'ruff', bone: 'neck1', c: [0, 0.7, 0.42], r: [0.15 * G, 0.14, 0.12], axis: norm([0, 0.4, 1]), k: 0.07 });
+
+  // ---------------------------------------------------------------- HEAD (head-local coords, see HEAD_O)
+  // landmarks from profile / frontal photos (adult ~0.36 m occiput -> nose): nose tip
+  // (0, -0.012, 0.215), eyes (+-0.047, 0.03, 0.058), stop z ~0.085, chin (0, -0.085, 0.16), skull top
+  // ~0.1 (the forehead rises steeply from the muzzle: the "dished" profile), occiput -0.125,
+  // cheek width ~0.3 m with the cheek ruff. A cub has a domed skull and a short muzzle (params).
+  const H = { bone: 'head' };
+  // Profile (side2, face3_profile, the head levelled): the top line rises ~13 deg along the bridge from
+  // the nose pad to the eyes, then ~23 deg up a long forehead to a low crown between the ears (y ~0.11):
+  // a shallow dish at the stop, not a dome (a forehead climbing 8 cm within 4 cm in front of the eyes
+  // stood up as a cap). Straighter in the black bear (dish 0.15); a cub's skull is domed.
+  // braincase: long, broad, low-crowned
+  // (broad: at 8.8 cm wide the braincase with the crest read as a ball between ears on top of it)
+  m.ell({ ...H, tag: 'cranium', c: hl([0, 0.028 + 0.014 * juv, -0.04]), r: hr([0.094, 0.076 + 0.016 * juv, 0.1]), k: 0.05 });
+  // forehead: a broad slope from the stop between the eyes back and up to the crown
+  m.cone({ ...H, tag: 'forehead', a: hl([0, 0.02 + 0.006 * (1 - dish) + 0.008 * juv, 0.045]), b: hl([0, 0.042 + 0.012 * juv, -0.07]), ra: 0.041 * hw, rb: 0.068 * hw, k: 0.05 });
+  // crown between the ears (temporal muscles over the sagittal crest)
+  // (broad and flat between the ears: the temporal muscles fill the skull's top out to the ear bases)
+  m.ell({ ...H, tag: 'crest', c: hl([0, 0.068 + 0.012 * juv, -0.066]), r: hr([0.1, 0.04, 0.075]), k: 0.05 });
+  for (const s of [1, -1]) {
+    // (over the upper lid: face2 / face3_profile show hooded eyes under a brow; 5 mm higher and 4 mm further back
+    // the eyes were round beads with nothing over them)
+    m.ell({ ...H, tag: 'brow', c: hl([0.042 * s, 0.0475, 0.056]), r: hr([0.021, 0.0095, 0.017]), k: 0.012 });
+    // the widest part of the skull: the zygomatic arches at and behind the eyes
+    // (wider: the face is broadest across the cheekbones, face1 / face2)
+    m.ell({ ...H, tag: 'zygomatic', c: hl([0.079 * s, 0.004, -0.014]), r: hr([0.043, 0.043, 0.066]), axis: norm([-0.25 * s, 0, 1]), k: 0.06 });
+    // fleshy cheek over the upper jaw below the eye (no jowl: nothing hangs below the jaw line)
+    m.ell({ ...H, tag: 'cheek', c: hl([0.05 * s, -0.014, 0.035]), r: hr([0.036, 0.03, 0.052]), k: 0.05 });
+    // skin under the cheek ruff behind the zygoma (the broad face is hair: coat.js)
+    // (heavy and low, down beside the jaw: the cheeks run on into the neck, face1 / tq1 / front1)
+    m.ell({ ...H, tag: 'cheekruff', c: hl([0.076 * s, -0.016, -0.078]), r: hr([0.045, 0.056, 0.06]), axis: norm([0.3 * s, 0, 1]), k: 0.07 });
+    m.ell({ ...H, tag: 'masseter', c: hl([0.055 * s, -0.03, -0.04]), r: hr([0.032, 0.036, 0.048]), k: 0.06 });
+    // the upper lip hangs a little over the lower jaw
+    // (reaching back to the mouth corner below the front of the eye: the lip line runs straight back from
+    // the chin; a gap between the lip and the masseter bowed it up into a smile)
+    // (its rear end 1 cm lower: the mouth line runs straight back and a little down to the corner, face3_profile /
+    // tq1 / front1; rising toward the cheek it read as a smile)
+    m.ell({ ...H, tag: 'lip', c: hl([0.029 * s, -0.058, 0.112]), r: hr([0.018, 0.026, 0.09]), axis: norm([-0.2 * s, 0.06, 1]), k: 0.02 });
+    // (the upper lip's rear, back to the mouth corner below the front of the eye: the lip above tapered there and the head's
+    // lower outline rose ~2 cm over its last 4 cm, so the mouth line turned up toward the cheek, a smile in the low 3/4;
+    // tq1 / front1 / face3_profile: the line runs straight back and a little down to the corner)
+    m.ell({ ...H, tag: 'lip', c: hl([0.04 * s, -0.07, 0.035]), r: hr([0.017, 0.017, 0.048]), axis: norm([-0.3 * s, 0.14, 1]), k: 0.018 });
+    m.ell({ ...H, tag: 'whisker', c: hl([0.022 * s, -0.035, 0.172]), r: hr([0.017, 0.019, 0.03]), k: 0.018 });
+  }
+  // long, broad muzzle; a shallow concave line from the stop to the nose (straighter in the
+  // black bear), a big black nose pad standing proud of the muzzle
+  // (the bridge runs down to the nose pad's top edge: the pad is the tip of the muzzle)
+  // (the bridge runs straight down onto the top edge of the nose pad, side2: 1.4 cm above it the pad sat on the
+  // front of a round snout like a teddy's button nose)
+  m.cone({ ...H, tag: 'nasal', a: hl([0, 0.016 + 0.012 * (1 - dish), 0.07]), b: hl([0, -0.008, 0.19]), ra: 0.038 * hw, rb: 0.024 * hw, k: 0.03 });
+  // (narrower in front: face2 shows the muzzle 1.4 x the nose pad wide at the pad, the render was 1.8 x)
+  m.ell({ ...H, tag: 'muzzle', c: hl([0, -0.028, 0.13]), r: hr([0.04, 0.048, 0.08]), axis: norm([0, -0.1, 1]), k: 0.03 });
+  // (0.57 x the eye separation wide, as face1 / face2; flat in front, its top edge rolling back into the
+  // bridge; a ball-shaped pad read as a clown's nose)
+  // The pad (face2, face1, front3, tq1): a rounded trapezoid ~1.3 x as wide as tall (0.44-0.51 eye separations), its
+  // top edge broad and nearly straight, its front flat, the bottom straight across with the nostrils at its corners;
+  // two lobes (one smooth oval read as a rubber button)
+  // (flat-fronted: the old 14 mm deep lobes, the lower one narrowing to a point between the nostrils, made a glossy dome
+  // over a downward beak)
+  m.ell({ ...H, tag: 'nose', c: hl([0, 0.0078, 0.2105]), r: hr([0.0238, 0.0135, 0.0118]), axis: norm([0, -0.12, 1]), k: 0.006 });
+  m.ell({ ...H, tag: 'nose', c: hl([0, -0.009, 0.2105]), r: hr([0.0218, 0.0125, 0.0115]), axis: norm([0, -0.2, 1]), k: 0.008 });
+  // (the upper lip hangs as low in the middle as at the sides: a notch there showed the chin as a pout)
+  m.ell({ ...H, tag: 'philtrum', c: hl([0, -0.049, 0.194]), r: hr([0.018, 0.025, 0.013]), k: 0.014 });
+  for (const s of [1, -1]) {
+    const ef = eyeFrame(s);
+    const at = (u, v, w) => add(add(add(ef.c, mul(ef.x, u)), mul(ef.y, v)), mul(ef.z, w));
+    // orbit: a soft hollow so the brow, cheek and bridge fall away to the lids
+    ellY({ ...H, tag: 'orbit', c: at(-0.002 * s, 0.0, 0.02), ydir: ef.y, lateral: ef.x, r: [0.02, 0.014, 0.012], k: 0.01, carve: true });
+    m.sphere({ ...H, tag: 'eyelid', c: ef.c, rad: EYE.r + EYE.lid, k: 0.006 });
+    m.lens({ ...H, tag: 'eyesocket', c: add(ef.c, mul(ef.y, EYE.off)), x: ef.x, y: ef.y, z: ef.z, R: EYE.R, d: EYE.d, zMin: -0.002, zMax: 0.024, k: 0.0022, carve: true });
+    // nostrils (face2 / face1 / face3_profile / tq1): comma-shaped openings at the lower corners of the pad, a round
+    // opening that faces down and out (it is drilled along the pad's normal there) and a slit curving up and back along
+    // the side of the pad; from the front each reads as a dark crescent at the side, the wide septum between them
+    // (6.8 x 3.4 mm dimples were invisible from the front; round holes facing forward beside the midline
+    // read as the holes of a button)
+    m.ell({ ...H, tag: 'nostril', c: hl([0.0135 * s, -0.0138, 0.2172]), r: [0.0064, 0.0045, 0.009], axis: norm([0.35 * s, -0.5, 0.8]), up: [0, 1, 0], k: 0.002, carve: true });
+    m.ell({ ...H, tag: 'nostril', c: hl([0.0198 * s, -0.0078, 0.2132]), r: [0.0026, 0.0068, 0.0058], axis: norm([0.8 * s, -0.15, 0.6]), up: norm([0.5 * s, 1, 0]), k: 0.002, carve: true });
+    // canines, hidden behind the lips until the mouth opens
+    m.cone({ ...H, tag: 'canine', a: hl([0.019 * s, -0.052, 0.148]), b: hl([0.018 * s, -0.066, 0.146]), ra: 0.0055, rb: 0.002, k: 0.002 });
+  }
+  // the groove down the middle of the pad's lower half, between the nostrils (it runs on as the philtrum, coat.js)
+  // (ending above the pad's lower edge: cut through it, it left a lit cusp under the pad, a pale tick)
+  m.ell({ ...H, tag: 'nosegroove', c: hl([0, -0.0132, 0.2228]), r: [0.0021, 0.0056, 0.0032], axis: norm([0, -0.3, 1]), k: 0.0015, carve: true });
+
+  // ---------------------------------------------------------------- JAW (separate surface so the mouth can open)
+  const JW = { bone: 'jaw', group: 'jaw', part: 'jaw' };
+  // (shallow in front, its top lower toward the mouth corner: face3_profile / side2 show a small receding chin, the
+  // nose pad : upper lip : chin ~1 : 0.95 : 0.3 in depth, and a mouth line running straight back and a little down;
+  // a 3 cm deep jaw whose top rose toward the hinge bulged below a mouth line curving up into a smile)
+  m.cone({ ...JW, tag: 'mandible', a: hl([0, -0.07, -0.02]), b: hl([0, -0.076, 0.152]), ra: 0.026, rb: 0.012, k: 0 });
+  for (const s of [1, -1]) {
+    m.cone({ ...JW, tag: 'mandible', a: hl([0.05 * s, -0.066, -0.035]), b: hl([0.014 * s, -0.073, 0.152]), ra: 0.02, rb: 0.011, k: 0.025 });
+  }
+  // a small chin set back under the upper lip
+  // (small: a chin standing 2 cm below the upper lip, painted pale, read as a pout)
+  m.ell({ ...JW, tag: 'chin', c: hl([0, -0.079, 0.1]), r: hr([0.016, 0.01, 0.02]), k: 0.02 });
+  m.cone({ ...JW, tag: 'canine', a: hl([0.017, -0.078, 0.155]), b: hl([0.018, -0.068, 0.157]), ra: 0.005, rb: 0.0018, k: 0.002 });
+  m.cone({ ...JW, tag: 'canine', a: hl([-0.017, -0.078, 0.155]), b: hl([-0.018, -0.068, 0.157]), ra: 0.005, rb: 0.0018, k: 0.002 });
+
+  // ---------------------------------------------------------------- EARS
+  // small, round, furred, set wide on the top corners of the head
+  for (const S of ['L', 'R']) {
+    const s = S === 'L' ? 1 : -1;
+    const base = J['earBase' + S], tip = J['earTip' + S];
+    const up = norm(sub(tip, base));
+    // (turned a little more outward than before, 0.45: in profile the thin pinna was seen edge-on and its fur drew a
+    // tall, pointed ear; side1 / face3_profile show a short round ear from the side)
+    const facing = norm([0.6 * s, 0.05, 1]);
+    const lat = norm(cross(up, facing));
+    const ear = { bone: 'ear' + S, group: 'ear' + S, thin: true };
+    const at = (t) => lerp(base, tip, t);
+    const ek = params.ear || 1;
+    // (a thin pinna, 9 cm wide before the head warp, its bulk the hair: an 11 cm, 4 cm thick paddle with a
+    // round dish carved in front read as a teddy's cup ear with a thick rim; tq2, front2, face1 / face2 show
+    // small ears 0.6-0.9 x the eye separation wide with their fur)
+    ellY({ ...ear, tag: 'ear', c: at(0.3), ydir: up, lateral: lat, r: [0.045 * ek, 0.043 * ek, 0.012], k: 0.016 });
+    // (the top a little flatter: face2 / tq2 show a broad rounded top, not a disc)
+    ellY({ ...ear, tag: 'ear', c: at(0.7), ydir: up, lateral: lat, r: [0.045 * ek, 0.029 * ek, 0.0095], k: 0.016 });
+    ellY({ ...ear, tag: 'earinner', c: add(at(0.45), mul(facing, 0.0105)), ydir: up, lateral: lat, r: [0.026 * ek, 0.03 * ek, 0.0065], k: 0.006, carve: true });
+  }
+
+  // ---------------------------------------------------------------- LEGS
+  // massive columns; broad plantigrade feet with five toes (the long, curved, non-retractile claws: claws.js)
+  for (const S of ['L', 'R']) {
+    const s = S === 'L' ? 1 : -1;
+    const lat = [s, 0, 0];
+    const sx = (v) => [v[0] * s, v[1], v[2]];
+    const g = 'F' + S;
+    const Sc = J['scapTop' + S], Sh = J['shoulder' + S], E = J['elbow' + S], W = J['wrist' + S], M = J['mcp' + S], T = J['ftoe' + S];
+    ellY({ tag: 'scapmuscle', bone: 'scapula' + S, group: g, c: add(lerp(Sc, Sh, 0.5), sx([0.02, 0, 0])), ydir: sub(Sh, Sc), lateral: lat, r: [0.07, 0.17, 0.13], k: 0.08, bias: 0.004 });
+    m.cone({ tag: 'upperarm', bone: 'humerus' + S, group: g, a: Sh, b: E, ra: 0.11, rb: 0.085, k: 0.08 });
+    ellY({ tag: 'triceps', bone: 'humerus' + S, group: g, c: add(lerp(Sh, E, 0.5), [0, 0, -0.06]), ydir: sub(E, Sh), lateral: lat, r: [0.085, 0.15, 0.08], k: 0.07 });
+    ellY({ tag: 'armpit', bone: 'humerus' + S, group: g, c: add(lerp(Sh, E, 0.75), sx([-0.035, 0.02, 0.02])), ydir: sub(E, Sh), lateral: lat, r: [0.06, 0.1, 0.08], k: 0.08 });
+    m.sphere({ tag: 'olecranon', bone: 'radius' + S, group: g, c: add(E, [0, 0.02, -0.035]), rad: 0.045, k: 0.04 });
+    m.cone({ tag: 'forearm', bone: 'radius' + S, group: g, a: E, b: W, ra: 0.08, rb: 0.056, k: 0.04 });
+    ellY({ tag: 'forearmmuscle', bone: 'radius' + S, group: g, c: add(lerp(E, W, 0.3), sx([0.008, 0, 0.012])), ydir: sub(W, E), lateral: lat, r: [0.075, 0.13, 0.075], k: 0.05 });
+    // "sleeves": the long hair behind the forearm
+    ellY({ tag: 'feather', bone: 'radius' + S, group: g, c: add(lerp(E, W, 0.4), [0, 0, -0.045]), ydir: sub(W, E), lateral: lat, r: [0.055, 0.13, 0.045], k: 0.04 });
+    m.sphere({ tag: 'wrist', bone: 'metacarpus' + S, group: g, c: add(W, [0, -0.002, 0.0]), rad: 0.05, k: 0.03 });
+    // the forepaw: a broad pad of a hand, the palm flat on the ground
+    const dp = norm(sub(T, M));
+    // (flat: a flexed paw shows a flat palm, not a ball)
+    ellY({ tag: 'palm', bone: 'metacarpus' + S, group: g, c: add(lerp(W, M, 0.55), [0, -0.016, 0]), ydir: sub(M, W), lateral: lat, r: [0.07, 0.07, 0.027], k: 0.03 });
+    m.sphere({ tag: 'carpalpad', bone: 'metacarpus' + S, group: g, c: add(W, [0, -0.052, -0.02]), rad: 0.017, k: 0.015 });
+    ellY({ tag: 'paw', bone: 'fpaw' + S, group: g, c: add(add(M, mul(dp, 0.01)), [0, 0.003, 0]), ydir: dp, lateral: lat, r: [0.075, 0.045, 0.03], k: 0.022 });
+    // five toes in an arc (the claws are their own surfaces, claws.js)
+    const toeX = [-0.056, -0.028, 0.0, 0.028, 0.056], toeZ = [-0.02, -0.004, 0.002, -0.004, -0.02];
+    for (let i = 0; i < 5; i++) {
+      const tp = [T[0] + toeX[i] * s, 0.024, T[2] - TOE_F - 0.012 + toeZ[i]];
+      m.sphere({ tag: 'toe', bone: 'fpaw' + S, group: g, c: tp, rad: 0.019, k: 0.012 });
+    }
+
+    const h = 'H' + S;
+    const Hp = J['hip' + S], K = J['knee' + S], Hk = J['hock' + S], Mt = J['mtp' + S], Tt = J['htoe' + S];
+    // broad heavy thighs ("trousers" of long hair behind), the flank fold running into the belly
+    ellY({ tag: 'thigh', bone: 'femur' + S, group: h, c: add(lerp(Hp, K, 0.42), sx([0.02, 0, -0.03])), ydir: sub(K, Hp), lateral: lat, r: [0.1, 0.24, 0.16], k: 0.08, bias: 0.004 });
+    m.cone({ tag: 'thighfront', bone: 'femur' + S, group: h, a: sx([0.12, 0.7, -0.22]), b: add(K, sx([-0.01, 0.07, 0.02])), ra: 0.1, rb: 0.07, k: 0.08 });
+    m.cone({ tag: 'hamstring', bone: 'femur' + S, group: h, a: sx([0.13, 0.74, -0.46]), b: add(lerp(K, Hk, 0.3), [0, 0, -0.05]), ra: 0.1, rb: 0.07, k: 0.07 });
+    ellY({ tag: 'breeches', bone: 'femur' + S, group: h, c: add(lerp(Hp, K, 0.65), sx([0.015, -0.02, -0.12])), ydir: sub(K, Hp), lateral: lat, r: [0.075, 0.13, 0.06], k: 0.05 });
+    ellY({ tag: 'flankfold', bone: 'femur' + S, group: h, c: sx([0.13, 0.56, -0.16]), ydir: [-0.05, 0.2, 0.12], lateral: lat, r: [0.05, 0.13, 0.08], k: 0.08 });
+    m.sphere({ tag: 'stifle', bone: 'tibia' + S, group: h, c: add(K, sx([0.005, 0.01, 0.015])), rad: 0.055, k: 0.05 });
+    m.cone({ tag: 'shin', bone: 'tibia' + S, group: h, a: lerp(K, Hk, 0.05), b: Hk, ra: 0.065, rb: 0.052, k: 0.04 });
+    ellY({ tag: 'calf', bone: 'tibia' + S, group: h, c: add(lerp(K, Hk, 0.3), sx([0.004, 0.01, -0.045])), ydir: sub(Hk, K), lateral: lat, r: [0.065, 0.12, 0.06], k: 0.05 });
+    m.sphere({ tag: 'calcaneus', bone: 'metatarsus' + S, group: h, c: add(Hk, [0, -0.02, -0.035]), rad: 0.045, k: 0.03 });
+    m.sphere({ tag: 'hock', bone: 'metatarsus' + S, group: h, c: Hk, rad: 0.056, k: 0.03 });
+    // the long flat sole: heel pad on the ground behind the hock
+    const dh = norm(sub(Tt, Mt));
+    ellY({ tag: 'sole', bone: 'metatarsus' + S, group: h, c: add(lerp(Hk, Mt, 0.5), [0, -0.006, 0]), ydir: sub(Mt, Hk), lateral: lat, r: [0.062, 0.12, 0.032], k: 0.03 });
+    ellY({ tag: 'paw', bone: 'hpaw' + S, group: h, c: add(add(Mt, mul(dh, 0.012)), [0, 0.004, 0]), ydir: dh, lateral: lat, r: [0.066, 0.042, 0.03], k: 0.022 });
+    const hx = [-0.048, -0.024, 0.0, 0.024, 0.048], hz = [-0.018, -0.004, 0.002, -0.004, -0.016];
+    for (let i = 0; i < 5; i++) {
+      const tp = [Tt[0] + hx[i] * s, 0.022, Tt[2] - TOE_H - 0.012 + hz[i]];
+      m.sphere({ tag: 'toe', bone: 'hpaw' + S, group: h, c: tp, rad: 0.017, k: 0.011 });
+    }
+  }
+
+  // ---------------------------------------------------------------- TAIL
+  // a stubby tail (~10 cm with its hair), hidden in the rump fur
+  m.cone({ tag: 'tailroot', bone: 'tail0', a: [0, 0.77, -0.46], b: J.tail1, ra: 0.045, rb: 0.035, k: 0.04 });
+  for (let i = 0; i < TAIL_SEGS; i++) {
+    m.cone({ tag: 'tail', bone: 'tail' + i, a: J['tail' + i], b: J['tail' + (i + 1)], ra: 0.035 - 0.01 * i, rb: 0.025 - 0.01 * i, k: 0.02, thin: i === TAIL_SEGS - 1 });
+  }
+  return m;
+}

package/vendor/procedural-animals/src/species/boar/behaviour.js

@@ -0,0 +1,335 @@
+// Wild boar behaviour layer for the quadruped engine (species.motion.hooks, see core/motion/actions.js):
+//
+//   update(P, dt, layer)  every frame over the action layer: the mane (P.furRaise: the long dorsal
+//                         bristles rise when the boar is alarmed, charging, hit or galloping away;
+//                         `motion.input.alarm = true` raises it on demand), jaw champing in a threat,
+//                         ear flicks, the lazy tail swing, automatic idle variants (sniffing with the
+//                         snout raised, a bout of rooting, a head shake, grunting), the charge steering
+//                         of the attack and the spin of the hit
+//   actions               eat (rooting: the disc ploughs the ground in forward-upward thrusts, the head
+//                         swinging side to side), sniff (snout raised, the disc testing the air in
+//                         quick small movements, ears forward), grunt, headshake, attack (a threat with
+//                         the head low and champing jaws, then a fast head-low charge ending in an upward
+//                         tusk hook with a head toss: attackHit style 'tusk'), hit (squeal and spin round
+//                         toward the blow), lie (on the belly, forelegs folded), sleep (flat on the side,
+//                         legs out)
+//
+// Posture lengths (headRaise, neckReach, fwd, side) are engine units (x cfg.k): species metres /
+// cfg.unit.
+import * as THREE from 'three';
+import { clamp, smooth, TAU } from '../../core/motion/common.js';
+import { mx, ONESHOTS, POSTURES } from '../../core/motion/actions.js';
+
+const PI = Math.PI;
+const sm = (w) => w * w * (3 - 2 * w);
+
+function B(e) {
+  if (!e._boar) {
+    e._boar = {
+      ear: [{ age: 9, next: 2 + e.rand() * 4, a: 0 }, { age: 9, next: 3 + e.rand() * 5, a: 0 }],
+      idleT: 6 + e.rand() * 6,
+      raise: 0,
+      charge: null, spin: null,
+    };
+  }
+  return e._boar;
+}
+const busy = (L) => L.postures.length > 0 || L.oneshots.some((a) => !a.stopping);
+
+// ------------------------------------------------------------------------------------------------
+function update(P, dt, L) {
+  const e = L.engine, b = B(e), cfg = e.cfg;
+  const vn = e.speed / cfg.sq;
+  const still = 1 - smooth(0.1, 0.6, vn);
+
+  // --- mane: raised in alarm (galloping away, charging, hit, on demand)
+  let want = e.input.alarm ? 1 : 0;
+  want = Math.max(want, 0.55 * smooth(4.2, 6.5, vn) * P.gaitW);
+  for (const a of L.oneshots) {
+    const w = sm(a.w);
+    if (a.name === 'attack') want = Math.max(want, w);
+    else if (a.name === 'hit') want = Math.max(want, 0.8 * w);
+    else if (a.name === 'sniff') want = Math.max(want, 0.25 * w);
+  }
+  // (eased here as well as in the renderer: a smooth rise, a slower fall)
+  b.raise += (want - b.raise) * (1 - Math.exp(-dt * (want > b.raise ? 6 : 1.5)));
+  P.furRaise = Math.max(P.furRaise || 0, b.raise);
+  // alarm: head up, ears forward, tail out stiff
+  if (e.input.alarm) {
+    const k = still * (busy(L) ? 0.3 : 1);
+    mx(P, 'headRaise', 0.05 / cfg.unit, k); mx(P, 'headPitch', -0.2, k); mx(P, 'earFlat', -0.2, k);
+    mx(P, 'tailLift', 0.5, 1); mx(P, 'tailStiff', 1.6, 1);
+  }
+
+  // --- ear flicks (one ear at a time)
+  for (const E of b.ear) {
+    E.age += dt; E.next -= dt * (0.5 + 0.5 * still);
+    if (E.next <= 0) { E.next = 3 + e.rand() * 7; E.age = 0; E.a = 0.6 + 0.5 * e.rand(); }
+    if (E.age < 0.5) { const f = Math.sin(Math.min(1, E.age / 0.45) * PI) * E.a; mx(P, 'earTwitch', 2.2, f * (1 - P.eyelid)); }
+  }
+
+  // --- dead / flat on the side: ears fold back along the neck, out of the ground
+  const dead = L.postures.reduce((m, p) => (p.name === 'death' ? Math.max(m, p.w) : m), 0);
+  const flat = Math.max(smooth(0.3, 1.0, Math.abs(P.roll)), dead * smooth(0.3, 1, dead));
+  if (flat > 0) { mx(P, 'earFlat', 1.1, flat); mx(P, 'earTwitch', 0, flat); }
+  // ... and the long, deep head (carried 40 deg nose-down in the bind pose) lies level on its cheek:
+  // nose up to the horizontal, the occiput higher than a cat-sized skull, rolled with the body rather
+  // than twisted on the atlas (the throat stretched)
+  let side = 0, lift = 0;
+  for (const p of L.postures) {
+    const k = p.name === 'death' ? sm(clamp(p.w, 0, 1)) * smooth(0.35, 1.0, p.t) : p.name === 'sleep' && p.tune.style === 'lateral' ? sm(clamp(p.w, 0, 1)) * smooth(1.0, 3.0, p.t) : 0;
+    if (k > side) { side = k; lift = p.name === 'death' ? 0.08 * k + 0.12 * Math.sin(Math.PI * k) : 0.16 * k + 0.12 * Math.sin(Math.PI * k); }
+    // (going down to sleep: the head is held clear of the ground while the body settles and rolls)
+    if (p.name === 'sleep' && p.tune.style === 'lateral') {
+      const k2 = sm(clamp(p.w, 0, 1)) * smooth(0.4, 3.0, p.t);
+      lift = Math.max(lift, 0.16 * k2 + 0.16 * Math.sin(Math.PI * k2));
+      side = Math.max(side, 1e-4);
+    }
+  }
+  if (side > 0 && P.headW > 0) {
+    P.headPos.y += lift * cfg.s;
+    P.headPitch -= 0.3 * side;
+    P.headRoll *= 1 - 0.5 * side;
+  }
+  // the thin tail lies straight along the ground (no curl round the body)
+  P.tailSide *= 0.35;
+
+  // --- charge steering (attack)
+  const cg = b.charge;
+  if (cg) {
+    if (cg.run) {
+      e.wantSpeed = Math.max(e.wantSpeed, cg.speed * smooth(0, 0.4, cg.tRun));
+      e.wantHeading = cg.heading;
+    } else if (cg.brake) e.wantSpeed = Math.min(e.wantSpeed, 0);
+  }
+  // --- spin round toward a blow (hit)
+  const sp = b.spin;
+  if (sp) {
+    sp.t += dt;
+    if (sp.t < sp.dur && !L.holdsStill()) e.wantHeading = sp.heading;
+    else {
+      if (!(e.input.speed > 0.05) && e.input.heading !== undefined && e.input.heading !== null) e.input.heading = sp.heading;
+      b.spin = null;
+    }
+  }
+
+  // --- any other action interrupts rooting
+  if (L.oneshots.some((a) => !a.stopping && ['attack', 'jump', 'sniff', 'headshake'].includes(a.name))) for (const a of L.oneshots) if (a.name === 'eat' || a.name === 'drink') a.stopping = true;
+
+  // --- idle variants
+  if (e.idleVariants !== false && L.idle.w > 0.98 && !busy(L) && !e.input.look && !e.input.follow) {
+    b.idleT -= dt;
+    if (b.idleT <= 0) {
+      b.idleT = 8 + e.rand() * 9;
+      const r = e.rand();
+      if (r < 0.35) L.play('sniff');
+      else if (r < 0.6) L.play('eat', { duration: 3.5 + 3 * e.rand() });
+      else if (r < 0.75) L.play('headshake');
+      else L.play('grunt');
+    }
+  } else if (busy(L)) b.idleT = Math.max(b.idleT, 3);
+}
+
+// ------------------------------------------------------------------------------------------------
+// eat: rooting. The disc goes to the ground ahead of the forefeet (the engine's grazing posture),
+// then ploughs forward and flicks up and sideways, turning the soil; the head swings side to side,
+// the mouth closed but for short chews, a grunt now and then.
+const eat = {
+  kind: 'oneshot',
+  start(inst, L) { ONESHOTS.eat.start(inst, L); inst.grunt = 1 + L.engine.rand() * 2; inst.side = L.engine.rand() < 0.5 ? -1 : 1; },
+  update(inst, dt, L) {
+    inst.grunt -= dt;
+    if (inst.grunt <= 0) { inst.grunt = 1.5 + L.engine.rand() * 2.5; L.engine.emit('vocalize', { kind: 'grunt' }); }
+    return ONESHOTS.eat.update(inst, dt, L);
+  },
+  apply(P, w, inst, L) {
+    ONESHOTS.eat.apply(P, w, inst, L);
+    const e = L.engine, t = inst.t, s = e.cfg.s;
+    const k = w * smooth(0.6, 1.4, t);
+    // thrust cycle ~0.9 s: push the disc forward along the ground, then lever it up and aside
+    const c = (t * 1.1) % 1;
+    const push = smooth(0.0, 0.45, c) * (1 - smooth(0.55, 0.95, c));
+    const flick = smooth(0.4, 0.6, c) * (1 - smooth(0.62, 0.95, c));
+    const n = Math.floor(t * 1.1);
+    const side = ((n * 7919) % 3) - 1; // -1, 0, 1: flick direction per thrust
+    const sh = Math.sin(e.heading), ch = Math.cos(e.heading);
+    const fwd = 0.045 * s * push * k, lat = 0.03 * s * flick * side * k;
+    P.headPos.x += sh * fwd + ch * lat; P.headPos.z += ch * fwd - sh * lat;
+    P.headPos.y += 0.035 * s * flick * k;
+    P.headPitch -= 0.3 * flick * k;
+    P.headYaw += (0.22 * Math.sin(t * 0.8 + inst.side) + 0.15 * flick * side) * k;
+    P.headRoll += 0.12 * flick * side * k;
+    // the mouth stays closed while the disc ploughs (the engine's grazing chew would hang it open, red
+    // lining showing): only short chews, the lips barely parting
+    mx(P, 'jaw', 0.035 * Math.pow(Math.max(0, Math.sin(t * 5.5)), 4), w);
+    mx(P, 'earFlat', 0.15, k);
+  },
+};
+
+// sniff: stands still with the snout raised to wind, the disc testing the air in small quick moves,
+// ears forward; a short snort at the end
+const sniff = {
+  kind: 'oneshot', fade: 0.4,
+  start(inst, L) { const e = L.engine; inst.dur = inst.opts.duration ?? 3.2 + e.rand() * 1.5; inst.yaw = (e.rand() - 0.5) * 0.7; inst.snort = false; },
+  update(inst, dt, L) {
+    if (!inst.snort && inst.t > inst.dur - 0.6) { inst.snort = true; L.engine.emit('vocalize', { kind: 'snort' }); }
+    return inst.t >= inst.dur;
+  },
+  apply(P, w, inst, L) {
+    const e = L.engine, t = inst.t, u = 1 / e.cfg.unit;
+    const up = w * smooth(0, 0.6, t);
+    mx(P, 'lookW', 0, up);
+    mx(P, 'headRaise', 0.1 * u, up); mx(P, 'neckReach', 0.02 * u, up);
+    // (quick small movements of the raised snout: two frequencies)
+    const tw = 0.05 * Math.sin(t * TAU * 2.3) + 0.035 * Math.sin(t * TAU * 3.7 + 1);
+    mx(P, 'headPitch', -0.5 + tw, up); mx(P, 'headOmega', 2.2, up);
+    mx(P, 'headYaw', inst.yaw + 0.25 * Math.sin(t * 0.9) + 0.4 * tw, up);
+    mx(P, 'earFlat', -0.25, up); mx(P, 'earTwitch', 0.3, up);
+    const snort = smooth(inst.dur - 0.6, inst.dur - 0.5, t) * (1 - smooth(inst.dur - 0.4, inst.dur - 0.2, t));
+    mx(P, 'breathAmp', 2.5, snort * w); mx(P, 'headPitch', -0.3, snort * w);
+    mx(P, 'tailLift', 0.15, up);
+  },
+};
+
+// grunt: low grunts, the jaw barely opening, head a little down
+const grunt = {
+  kind: 'oneshot', fade: 0.2,
+  start(inst) { inst.dur = 1.4; inst.n = 0; },
+  update(inst, dt, L) {
+    const n = Math.floor((inst.t - 0.2) / 0.4);
+    if (n >= inst.n && n < 3 && inst.t > 0.2) { inst.n = n + 1; L.engine.emit('vocalize', { kind: 'grunt' }); }
+    return inst.t >= inst.dur;
+  },
+  apply(P, w, inst) {
+    const t = inst.t;
+    const g = Math.max(0, Math.sin(clamp((t - 0.2) / 0.4, 0, 3) * PI));
+    mx(P, 'jaw', 0.05 * g, w); mx(P, 'jawOmega', 25, w); mx(P, 'breathAmp', 1 + 1.5 * g, w);
+    mx(P, 'headPitch', 0.08, w * smooth(0, 0.3, t));
+  },
+};
+
+// head shake: fast rotations about the snout axis, ears flapping
+const headshake = {
+  kind: 'oneshot', fade: 0.12,
+  start(inst) { inst.dur = 0.9; },
+  update(inst) { return inst.t >= inst.dur; },
+  apply(P, w, inst) {
+    const t = inst.t;
+    const env = smooth(0, 0.12, t) * (1 - smooth(0.5, 0.85, t)) * w;
+    const s = Math.sin(t * TAU * 4.5);
+    mx(P, 'headOmega', 5, env);
+    mx(P, 'headRoll', 0.35 * s, env); mx(P, 'headYaw', 0.12 * s, env); mx(P, 'headPitch', -0.05, env);
+    mx(P, 'earTwitch', 2.5, env); mx(P, 'eyelid', 0.5, env); mx(P, 'lookW', 0, env);
+  },
+};
+
+// attack: standing, a short threat (head low, mane up, jaws champing) then the charge; already
+// running, straight into the charge. Head low and forward in the run, then at the target an upward
+// hook of the lower tusks with a toss of the head to one side (attackHit at the mouth, style 'tusk'),
+// then it brakes, ready to wheel and charge again.
+const attack = {
+  kind: 'oneshot', fade: 0.18, needsStand: true,
+  start(inst, L) {
+    const e = L.engine, b = B(e), cfg = e.cfg;
+    inst.run = smooth(1.2, 3.5, e.speed / cfg.sq);
+    inst.target = inst.opts.target ? inst.opts.target.clone() : null;
+    inst.side = inst.opts.side ?? (e.rand() < 0.5 ? -1 : 1);
+    inst.tThreat = inst.run > 0.3 ? 0.15 : 0.9;
+    let h = e.heading;
+    if (inst.target) h = Math.atan2(inst.target.x - e.pos.x, inst.target.z - e.pos.z);
+    const dist = inst.target ? Math.hypot(inst.target.x - e.pos.x, inst.target.z - e.pos.z) : 3.2 * cfg.s;
+    inst.vRun = clamp(dist * 1.4, 4, 7) * cfg.sq;
+    inst.tRun = clamp(dist / (inst.vRun * 0.75) + 0.4, 1.0, 2.8);
+    b.charge = { run: false, brake: false, heading: h, speed: inst.vRun, tRun: 0 };
+    inst.hitAt = inst.tThreat + inst.tRun;
+    inst.dur = inst.hitAt + 1.3;
+    inst.hit = false;
+  },
+  update(inst, dt, L) {
+    const e = L.engine, b = B(e);
+    const cg = b.charge;
+    if (cg) {
+      cg.run = inst.t >= inst.tThreat && inst.t < inst.hitAt + 0.1;
+      cg.brake = inst.t >= inst.hitAt + 0.1;
+      if (cg.run) cg.tRun += dt;
+    }
+    if (!inst.hit && inst.t >= inst.hitAt) {
+      inst.hit = true;
+      const p = new THREE.Vector3().copy(e.cfg.mouthLocal).applyQuaternion(e.headPose.quaternion).add(e.headPose.position);
+      const dir = e.forward(e.heading, new THREE.Vector3()).add(new THREE.Vector3(0, 0.6, 0)).normalize();
+      e.emit('attackHit', { position: p, direction: dir, style: 'tusk' });
+    }
+    if (inst.t >= inst.dur) { b.charge = null; return true; }
+    return false;
+  },
+  apply(P, w, inst, L) {
+    const e = L.engine, cfg = e.cfg, u = 1 / cfg.unit, t = inst.t, h = inst.hitAt;
+    if (inst.target) { P.look = inst.target; mx(P, 'lookW', 0.5, w); }
+    // threat: head low, jaws champing (tooth clacking)
+    const thr = smooth(0, 0.25, t) * (1 - smooth(inst.tThreat - 0.1, inst.tThreat + 0.1, t)) * (1 - inst.run);
+    mx(P, 'jaw', 0.12 * Math.max(0, Math.sin(t * TAU * 4.5)), thr * w); mx(P, 'jawOmega', 35, w);
+    mx(P, 'headPitch', 0.2, thr * w); mx(P, 'headRaise', -0.04 * u, thr * w); mx(P, 'dropF', 0.08, thr * w);
+    // charge: head low and forward, ears back, tail up
+    const low = smooth(inst.tThreat - 0.1, inst.tThreat + 0.3, t) * (1 - smooth(h - 0.12, h, t));
+    mx(P, 'headRaise', -0.07 * u, low * w); mx(P, 'headPitch', 0.3, low * w); mx(P, 'neckReach', 0.03 * u, low * w);
+    mx(P, 'earFlat', 0.9, w * smooth(0, 0.3, t)); mx(P, 'earTwitch', 0, w);
+    mx(P, 'tailLift', 0.7, w * smooth(0, 0.5, t)); mx(P, 'tailStiff', 1.6, w);
+    // the hook: from low and nose-down, the head tosses up and to one side, the jaw a little open
+    const hook = smooth(h - 0.12, h + 0.08, t) * (1 - smooth(h + 0.25, h + 0.75, t));
+    mx(P, 'headPitch', -0.5, hook * w); mx(P, 'headRaise', 0.06 * u, hook * w);
+    mx(P, 'headRoll', 0.45 * inst.side, hook * w); mx(P, 'headYaw', 0.35 * inst.side, hook * w);
+    mx(P, 'headOmega', 3, w * smooth(h - 0.3, h - 0.1, t) * (1 - smooth(h + 0.3, h + 0.6, t)));
+    mx(P, 'jaw', 0.12, hook * w);
+    // the forequarters drive up into the hook
+    mx(P, 'dropF', -0.06, hook * w); mx(P, 'pitch', -0.04, hook * w);
+  },
+};
+
+// hit: the engine's stagger with a squeal (mouth open, head up), then it spins round toward the blow
+const hit = {
+  ...ONESHOTS.hit,
+  kind: 'oneshot',
+  start(inst, L) {
+    ONESHOTS.hit.start(inst, L);
+    const e = L.engine, b = B(e);
+    inst.dur = 1.0;
+    inst.said = false;
+    // face the source of the blow (the blow travels along inst.dir)
+    const h = Math.atan2(-inst.dir.x, -inst.dir.z);
+    b.spin = { heading: h, t: 0, dur: 1.6 };
+  },
+  update(inst, dt, L) {
+    if (!inst.said && inst.t > 0.05) { inst.said = true; L.engine.emit('vocalize', { kind: 'squeal' }); }
+    return inst.t >= inst.dur;
+  },
+  apply(P, w, inst, L) {
+    ONESHOTS.hit.apply(P, w, inst, L);
+    const t = inst.t;
+    const sq = smooth(0.03, 0.12, t) * (1 - smooth(0.5, 0.8, t)) * w;
+    mx(P, 'jaw', 0.32 + 0.04 * Math.sin(t * TAU * 12), sq); mx(P, 'jawOmega', 35, w);
+    mx(P, 'headPitch', -0.3, sq); mx(P, 'eyelid', 0.4, sq);
+    mx(P, 'tailLift', 0.5, w); mx(P, 'tailStiff', 1.5, w);
+  },
+};
+
+// lie: on the belly, forelegs folded (the engine's kneeling lie, down front first, up front first),
+// with the rise finished a little before the posture is released so the end-first springs settle
+function lieApply(P, w, inst, L) {
+  const we = inst.target > 0 ? w : smooth(0.3, 1, w);
+  POSTURES.lie.apply(P, we, inst, L);
+}
+const lie = { kind: 'posture', fadeIn: 1.4, fadeOut: 1.3, apply: lieApply };
+
+// sleep: flat on the side, legs extended (lateral recumbency, the usual sleeping posture in the nest)
+const sleep = {
+  kind: 'posture', fadeIn: 1.5, fadeOut: 1.4,
+  apply(P, w, inst, L) {
+    const we = inst.target > 0 ? w : smooth(0.3, 1, w);
+    POSTURES.sleep.apply(P, we, inst, L);
+  },
+};
+
+export const hooks = {
+  update,
+  actions: { eat, sniff, grunt, headshake, attack, hit, lie, sleep },
+};