@bitefoundry/retrieviewer 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,111 @@
+// Lion (Panthera leo). A heavy, deep-chested digitigrade cat: massive head and forequarters, short
+// legs relative to its bulk; the male's mane, the lioness, and woolly spotted cubs.
+import { lionRig, HEAD_O } from './rig.js';
+import { sculptLion, EYE } from './sculpt.js';
+import { lionRegions, EYE_CENTRES } from './regions.js';
+import { lionCoat } from './coat.js';
+import { motion } from './motion.js';
+import { lionWhiskers } from './whiskers.js';
+
+export default {
+  id: 'lion',
+  name: 'Lion',
+  latin: 'Panthera leo',
+  group: 'paws',
+  plan: 'quadruped',
+  covering: 'fur',
+  variants: ['tawny', 'white'],
+
+  // Seeded individual. Males ~1.075 x the reference size (withers
+  // ~1.15 m), a bigger, broader head and a mane whose extent grows with age (young / "maneless"
+  // Tsavo-type males carry a short ruff) and whose colour runs from blond to black-fringed; lionesses
+  // ~0.935 (withers ~1.0 m), no mane, a flatter head. Cubs (age 'juvenile', ~4-6 months): ~0.42 size,
+  // big head, ears and paws, short legs, woolly greyer coat with faint rosettes, grey-amber eyes.
+  // Individuals vary in leg length, body length, head size, coat warmth / lightness, nose freckling
+  // (age), faint leg spots. Rare leucistic "white lion" (variant 'white', ~3 %).
+  variation(R, o) {
+    const sex = o.sex || (R() < 0.5 ? 'male' : 'female');
+    const age = o.age || 'adult';
+    const juv = age === 'juvenile' ? 1 : 0;
+    const male = sex === 'male' && !juv;
+    const g = () => R() + R() - 1; // [-1, 1], triangular
+    let variant = o.variant;
+    if (!variant) variant = R() < 0.03 ? 'white' : 'tawny'; else R();
+    const prime = R(); // 0 young adult .. 1 prime / old (mane extent and darkness, nose freckling)
+    const maneless = R() < 0.08;
+    const mane = male ? (maneless ? 0.12 : Math.min(1, 0.3 + 0.75 * prime * (0.8 + 0.2 * R()))) : 0;
+    const maneDark = male ? Math.min(1, Math.max(0, 0.1 + 0.65 * prime + 0.3 * g())) : 0;
+    const size = (male ? 1.075 : 0.935) * (1 + 0.06 * g()) * (juv ? 0.42 : 1);
+    const legs = 1 + 0.045 * g() - 0.08 * juv;
+    const head = (male ? 1.12 : 1.07) * (1 + 0.04 * g()) * (juv ? 1.28 : 1);
+    return {
+      sex, age, size, variant, juv,
+      mane, maneDark,
+      noseDark: juv ? 0 : Math.min(1, Math.max(0, 0.15 + 0.6 * prime + 0.15 * g())),
+      legSpots: juv ? 1 : Math.max(0, 0.15 + 0.2 * g()),
+      coatWarmth: 1.1 * g(),
+      coatLightness: 0.25 * g(), // (+-0.16 read as a pride of clones)
+      coatSeed: Math.floor(R() * 1e6),
+      minThick: 0.005,
+      warps: [
+        // cubs (research 1, cub_lying1): a short muzzle (the face in front of the eyes 22 % shorter) and eyes 15 %
+        // bigger, in reference space before the other warps (the adult's muzzle scaled down)
+        ...(juv ? [{ type: 'length', k: 0.7, z0: 0.878, z1: 1.03 }, ...EYE_CENTRES.map((c) => ({ type: 'scaleAbout', c, k: 1.15, r0: 0.026, r1: 0.05 }))] : []),
+        { type: 'legs', k: legs, top: 0.55 },
+        { type: 'length', k: 1 + 0.07 * g() - 0.05 * juv, z0: -0.55, z1: 0.4 },
+        { type: 'scaleAbout', c: HEAD_O, k: head, r0: 0.14, r1: 0.32 },
+        // (cub paws: sculpt.js, longer and deeper; a warp about them also made them wider, and they lay in the ground)
+      ],
+      // (drawn after everything above, so a seed keeps its sex, mane, size and coat)
+      earDark: 0.55 + 0.45 * R(), // ear backs from sooty brown to black
+      belly: 0.6 + 0.8 * R(), // the loose belly fold (primordial pouch), small .. heavy
+    };
+  },
+  rig: () => lionRig(),
+  sculpt: (m, rig, params) => sculptLion(m, rig, params),
+  regions: lionRegions,
+  coat: lionCoat,
+  eyeSpecs: (params) => [1, -1].map((side) => ({ side, spec: params.juv ? CUB_EYE_SPEC : EYE, headOrigin: HEAD_O, bone: 'head', look: params.juv ? CUB_EYE : EYE_LOOK })),
+  motion,
+  surfaces: lionWhiskers, // the whiskers (strands on a bone per side)
+  render: {
+    markColor: [0.012, 0.009, 0.007],
+    strandDensity: 560,
+    // silhouette fins on the mane, the tufts and the fringes only (hair >= 24 mm): on the face, the cheeks and a cub's
+    // soft head their dark roots drew a dark outline wherever the head turns side-on, a hood round a cub's face; the core option finMinLen (default 5.8 mm)
+    finMinLen: 0.024,
+    // the shells' strands cross-faded between two hashing planes near a switch of the plane (the core option
+    // strandBlend, default off): the broad forehead tilted ~45 deg drew a rectangle where the plane switched
+    // (0.35: at 0.12 the bridge, sloping ~45 deg and convex, still drew two or three horizontal bands of
+    // stretched strands across it and one across the top of the forehead, stitches or creases from the front)
+    strandBlend: 0.35,
+    clumpDensity: 0.85,
+    leatherTint: 1, // nose leather in its tint: pink-brown to mottled black by age (coat.js), pink in the white lion
+  },
+};
+
+// Round pupil (constricts to a small circle), amber iris (#b8802f, darker limbal ring), no visible
+// sclera, black lid margins.
+export const EYE_LOOK = {
+  pupil: 'round',
+  lids: 'mammal',
+  // (amber-gold: face_male1 amber, face_female1 paler gold; a saturated orange read as a cartoon eye, a
+  // grey-gold hazel as a washed-out yellow in sunlight)
+  iris: { inner: [0.3, 0.16, 0.035], mid: [0.5, 0.3, 0.075], hi: [0.7, 0.47, 0.15], outer: [0.13, 0.07, 0.018] },
+  sclera: { color: [0.2, 0.15, 0.11], visible: false },
+  lidColor: [0.015, 0.012, 0.01],
+  pupilSize: [0.2, 0.55], // (about 0.25-0.3 of the iris in daylight, the photos; ~0.5 measured in the harness light)
+};
+// cubs (4-6 months): amber-brown, duller than an adult's (blue-grey until ~3 months, amber by the end of the first year;
+// cub_lying1: amber-brown; a grey-blue iris read as a doll's eye)
+// (a cub's iris fills more of its opening, cub_Alert_cub_*, cub_Krueger_lion_cub: the dark eyeball round a
+// small iris read as dark bluish rings, eye make-up or bruises, in the showcase's sky light)
+const CUB_EYE_SPEC = { ...EYE, irisR: EYE.irisR * 1.14 };
+export const CUB_EYE = {
+  ...EYE_LOOK,
+  sclera: { color: [0.26, 0.17, 0.1], visible: false },
+  // (the upper lid that covers the iris's top in a cub's bigger opening: tawny furred skin with the dark margin at its edge; black, it
+  // reflected the sky as a dark blue band over the iris)
+  lidColor: [0.18, 0.1, 0.045],
+  iris: { inner: [0.22, 0.13, 0.05], mid: [0.38, 0.24, 0.09], hi: [0.52, 0.36, 0.16], outer: [0.1, 0.06, 0.025] },
+};

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

@@ -0,0 +1,87 @@
+// Lion motion data for the quadruped engine (schema: src/core/motion/quadruped.js).
+// Numbers are for the reference individual (params.size = 1, withers ~1.07 m); the engine scales them
+// by dynamic similarity for cubs and big males.
+//
+// Gaits: a slow, heavy lateral-sequence walk (0.8-1.6 m/s, 0.6-0.8 Hz,
+// duty 0.72-0.64, [LF .27, RF .77, LH 0, RH .5]), head carried low; a trot that lions rarely use
+// (2-4 m/s, 1.3-1.7 Hz, duty 0.46-0.4: a narrow band between walk and gallop); the transverse gallop
+// (4.5-8 m/s, 1.8-2.2 Hz, duty 0.36-0.3) and the rotary gallop of the charge (8-16 m/s, 2.2-2.6 Hz,
+// duty 0.3-0.22, LH-RH-RF-LF); top speed ~14-16 m/s in bursts (98th percentile 13.9 m/s, Wilson et
+// al. 2018), hard acceleration and even harder braking.
+import { lionHooks } from './behaviour.js';
+
+const G = (name, v, f, D, off, o) => ({ name, v, f, D, off, ...o });
+
+export const motion = {
+  hooks: lionHooks,
+  maxSpeed: 16,
+  accel: [6, 9.5],
+  decel: 13,
+  // a heavy cat turns slowly and wide: ~50 deg/s at the walk, ~0.7 rad/s at a 7 m/s gallop (10 m radius,
+  // a ~23 deg lean at speed),
+  // wider at the charge (88 deg/s at the walk and a 5 m gallop radius read as a swinging rod)
+  turnRate: 1.1,
+  latAccelMax: 5,
+  gears: { walk: 1.2, trot: 2.9, gallop: 7, sprint: 14 },
+  gallopBlend: [4.2, 8],
+  gaits: [
+    G('walk', 0.0, 0.62, 0.72, [0.27, 0.77, 0.0, 0.5], { liftF: 0.075, liftH: 0.06, bobF: 0.008, bobH: 0.008, flex: 0.0, lat: 0.05, fold: 1.0, heel: 35, tail: 0, drop: 0.0, width: 0.95 }),
+    G('walk', 1.5, 0.82, 0.64, [0.27, 0.77, 0.0, 0.5], { liftF: 0.1, liftH: 0.075, bobF: 0.014, bobH: 0.012, flex: 0.0, lat: 0.05, fold: 1.2, heel: 42, tail: 0.1, drop: 0.0, width: 0.9 }),
+    G('trot', 2.1, 1.35, 0.46, [0.5, 0.02, 0.0, 0.5], { liftF: 0.13, liftH: 0.11, bobF: 0.025, bobH: 0.025, flex: 0.02, lat: 0.015, fold: 1.45, heel: 50, tail: 0.3, drop: 0.01, width: 0.95 }),
+    G('trot', 3.6, 1.6, 0.4, [0.5, 0.02, 0.0, 0.5], { liftF: 0.15, liftH: 0.13, bobF: 0.03, bobH: 0.03, flex: 0.03, lat: 0.01, fold: 1.55, heel: 56, tail: 0.4, drop: 0.015, width: 0.95 }),
+    G('gallop', 4.8, 1.85, 0.36, [0.46, 0.58, 0.0, 0.12], { liftF: 0.2, liftH: 0.18, bobF: 0.03, bobH: 0.045, flex: 0.22, lat: 0, fold: 1.75, heel: 62, tail: 0.6, drop: 0.03, width: 0.9 }),
+    // (transverse up to 7.5 m/s, rotary from 9.5: in between the leads swap, and the 7 m/s gear read both
+    // forefeet landing together, a half-bound)
+    G('gallop', 7.5, 2.1, 0.32, [0.46, 0.58, 0.0, 0.12], { liftF: 0.235, liftH: 0.215, bobF: 0.033, bobH: 0.055, flex: 0.3, lat: 0, fold: 1.85, heel: 66, tail: 0.75, drop: 0.035, width: 0.95 }),
+    G('gallop', 9.5, 2.25, 0.29, [0.58, 0.46, 0.0, 0.12], { liftF: 0.25, liftH: 0.23, bobF: 0.035, bobH: 0.06, flex: 0.34, lat: 0, fold: 1.9, heel: 68, tail: 0.8, drop: 0.04, width: 1 }),
+    G('gallop', 16, 2.6, 0.23, [0.58, 0.46, 0.0, 0.12], { liftF: 0.3, liftH: 0.28, bobF: 0.04, bobH: 0.07, flex: 0.44, lat: 0, fold: 2.0, heel: 72, tail: 0.95, drop: 0.07, width: 1 }),
+  ],
+  feet: {
+    front: { type: 'digitigrade', curl: 55 },
+    hind: { type: 'digitigrade', curl: 65 },
+  },
+  stance: { width: 1, gallopWidth: 0.6, sprawl: 0, crouch: 0.03 }, // (a tall walk on straight legs: 0.15 walked crouched)
+  // torso cross-sections (bind, reference size): centre height, half height, half width (from the mesh)
+  body: {
+    chest: { y: 0.745, hh: 0.28, hw: 0.185 },
+    pelvis: { y: 0.79, hh: 0.25, hw: 0.18 }, // incl. the thigh muscles a lion lying on its side rests on
+    rump: { z: -0.765, y: 0.81, hh: 0.17, hw: 0.165 },
+    back: 0.13,
+  },
+  head: {
+    // [speed, raise (m), reach (m), pitch (rad, + = nose down)]: standing head at about withers
+    // height; the relaxed walk carries it low (crown below the withers, nose ~30 deg down) and the
+    // charge stretches it forward in line with the spine
+    carriage: [[0, 0.02, 0.0, -0.06], [1.0, -0.075, 0.04, 0.27], [2.4, -0.08, 0.05, 0.24], [4.5, -0.085, 0.07, 0.2], [9, -0.1, 0.09, 0.16]],
+    stab: [[0, 0], [0.9, 0.25], [1.8, 0.3], [4.5, 0.34], [9, 0.6]],
+    neckBend: 30, neckPivot: 0.4, yaw: 0.85, pitchUp: 0.45, pitchDown: 0.6,
+  },
+  tail: {
+    // [speed, pitch per segment from horizontal (deg), base -> tip]: J-hang with the tuft curled up at
+    // rest and in the walk; lifted into a shallow curve in the gallop
+    carriage: [
+      [0.0, [-40, -62, -74, -80, -82, -80, -72, -54, -24, 12]],
+      [1.2, [-36, -58, -71, -77, -79, -76, -66, -46, -16, 16]],
+      [3.0, [-24, -38, -46, -50, -50, -46, -38, -24, -6, 12]],
+      [6.0, [-16, -20, -20, -18, -14, -9, -3, 4, 10, 16]],
+      [12, [-10, -10, -8, -6, -3, 0, 3, 6, 9, 12]],
+    ],
+    stiffness: 0.9, sway: 6, flick: 1, wag: 0, swish: 0, curl: 0,
+    balance: 0.6, // counterweight in turns and speed changes: the tuft lags and overshoots
+    radius: [0.055, 0.045], // (coat and the tuft included)
+  },
+  ears: { rest: [0, 0], mobility: 0.6, speedFlatten: 0.45, twitch: 1, prick: 0.3 },
+  breath: { rate: 0.25, amp: 0.012, pant: true, pantRate: 2.2, pantAmp: 0.045, heatSpeed: 7 },
+  actions: {
+    attack: { style: 'pounce' }, // replaced by the species action (stalk, charge, pounce, neck bite): behaviour.js
+    eat: { style: 'tear', dropF: 0.45, dropH: 0.5, ahead: 0.75, pitch: 0.85 }, // (the lion's own eat lies down: behaviour.js)
+    drink: { dropF: 0.72, dropH: 0.35, ahead: 0.7, pitch: 0.9 }, // crouched at the edge, elbows out, lapping
+    jump: { height: 1.2, distance: 3.6 },
+    sit: {},
+    lie: { dropF: 0.93, dropH: 0.97 },
+    // sphinx: forelegs stretched forward along the ground (paws ~0.7 leg lengths ahead of the shoulder;
+    // the thick forearm lies on the ground instead of folding into it)
+    fold: { front: { z: 0.03, k: -1.45, beta: 0 } },
+    sleep: { style: 'lateral' }, // flat on one flank, legs out
+  },
+};

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

@@ -0,0 +1,106 @@
+// Meshing plan: body at 8.1 mm (the cheetah's 5.4 mm scaled to the lion's size), head at 4.2 mm
+// (overlapping across the upper neck and cross-faded), eyelid patches at 1.5 mm, and the lower jaw
+// as its own surface so the mouth can open.
+import { lionJoints, HEAD_O, fe } from './rig.js';
+import { EYE } from './sculpt.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+import { lerp, norm, sub, smoothstep } from '../../core/math/vec.js';
+
+// the neck cut is fixed in reference space (joints of the reference individual)
+const J0 = lionJoints();
+export const NECK_CUT = (() => {
+  const d = norm(sub(J0.occiput, J0.neckMid));
+  const c = lerp(J0.neckMid, J0.occiput, 0.95);
+  return { c, d, band: 0.018 };
+})();
+export const neckS = (x, y, z) => (x - NECK_CUT.c[0]) * NECK_CUT.d[0] + (y - NECK_CUT.c[1]) * NECK_CUT.d[1] + (z - NECK_CUT.c[2]) * NECK_CUT.d[2];
+
+// A maned head: the head surface is the part in front of the neck cut AND inside a flattened ellipsoid
+// round the face, or round an ear: the outer mane ruff stays on the (coarser) body surface, so the cut
+// between the two surfaces never runs through the long hair far from the neck axis, where a bent neck
+// opened it. The ellipsoid term is a pseudo-distance (the scaled radius divided by its gradient), so the
+// cross-fade band is as wide in metres all round it (its gradient was up to 1.5: the band shrank to 12 mm
+// on the sides, less than a coarse cell, and the cut came out on the visible side of the fade).
+// A maneless head (lioness, cub) is cut at the neck alone: the ellipsoid crossed the nape at a grazing
+// angle (a 28 cm crack at the crowd tier) and cut the ears off the head surface.
+const HC = [HEAD_O[0], HEAD_O[1] + 0.01, HEAD_O[2] + 0.03], HR = 0.29;
+function faceEll(x, y, z) {
+  const sx = 1.5, sy = y < HC[1] ? 1.45 : 1, sz = z < HC[2] ? 1.3 : 1;
+  const dx = (x - HC[0]) * sx, dy = (y - HC[1]) * sy, dz = (z - HC[2]) * sz;
+  const r = Math.hypot(dx, dy, dz) || 1e-9;
+  return ((HR - r) * r) / (Math.hypot(dx * sx, dy * sy, dz * sz) || 1e-9);
+}
+// the ears (a capsule round the pinna standing out of the mane, from above its buried base to beyond the
+// tip) are head surface in a mane too; kept tight so the fine head mesh does not spread over the mane skin
+// round the ears, which folds when the neck bends
+const EAR_R = 0.05, EAR_T0 = 0.3;
+const EARS = [1, -1].map((s) => {
+  const a = [J0.earBaseL[0] * s, J0.earBaseL[1], J0.earBaseL[2]], t = [J0.earTipL[0] * s, J0.earTipL[1], J0.earTipL[2]];
+  return { a, d: sub(t, a) };
+});
+function earS(x, y, z) {
+  let best = -1e9;
+  for (const { a, d } of EARS) {
+    const px = x - a[0], py = y - a[1], pz = z - a[2];
+    const t = Math.max(EAR_T0, Math.min(1.15, (px * d[0] + py * d[1] + pz * d[2]) / (d[0] * d[0] + d[1] * d[1] + d[2] * d[2])));
+    best = Math.max(best, EAR_R - Math.hypot(px - d[0] * t, py - d[1] * t, pz - d[2] * t));
+  }
+  return best;
+}
+const splitMane = (x, y, z) => Math.min(neckS(x, y, z), Math.max(faceEll(x, y, z), earS(x, y, z)));
+// the split for an individual (> 0 head surface, < 0 body)
+export const splitFor = (params) => ((params && params.mane > 0) ? splitMane : neckS);
+
+export const EYE_CENTRES = [1, -1].map((s) => eyeFrameOf(EYE, HEAD_O, s).c);
+const PATCH = { R: 0.039, B: 0.006, h: 0.0015 }; // (R - B holds the aperture rim at the skin, 31.6 mm)
+// the nose leather (its edge, the comma nostrils) meshed finer as well: at the medium tier's 8.4 mm face
+// cells its lower edge and the nostrils were jagged dark notches
+// (the whole leather, its outline and the short fur round it inside the patch's core, R - B: with the leather's top corners in
+// the cross-fade band the coarse face mesh's colours showed through there as ragged dark-red patches)
+export const NOSE_PATCH = { c: fe(0, -0.98, 1.03), R: 0.072, B: 0.008, h: 0.0022 };
+export function eyePatchWeight(x, y, z) {
+  let w = 0;
+  for (const c of EYE_CENTRES) w = Math.max(w, 1 - smoothstep(PATCH.R - PATCH.B, PATCH.R + PATCH.B, Math.hypot(x - c[0], y - c[1], z - c[2])));
+  const n = NOSE_PATCH;
+  return Math.max(w, 1 - smoothstep(n.R - n.B, n.R + n.B, Math.hypot(x - n.c[0], y - n.c[1], z - n.c[2])));
+}
+
+export function lionRegions(rig, params, Q) {
+  // (the medium tier's body 5 % coarser: its eyelid and nose patches take ~2k of its 32k vertices)
+  // (a maned body 5 % coarser at a full mane: the mane's locks add surface; a lioness's cells unchanged)
+  const r = Q.res, hBody = 0.0081 * r * (Math.abs(r - 2) < 0.01 ? 1.05 : 1) * (1 + 0.05 * (params.mane || 0));
+  const splitS = splitFor(params);
+  // The mesher keeps whole cells by their centre, so a cut's boundary vertices lie up to ~0.85 of a
+  // cell either side of it: the band must be over a body cell wide (1.2 cells), or at the medium and low tiers
+  // the body's cut came out where its fade still shows (open edges on the visible side).
+  const B = Math.max(NECK_CUT.band, 1.2 * hBody);
+  // Without fur shells (crowd tier) the coarse body surface and the head surface do not coincide in
+  // the overlap band: each surface stays visible past the cut by D there (see the cheetah).
+  const D = Q.shells > 0 ? 0 : 0.6 * 0.0076 * r;
+  // (patches at medium too: Safari on a Mac and phones show medium; the eyes' lid margins and the nose)
+  const patches = r <= 2.01 ? [...EYE_CENTRES.map((c) => ({ c, R: PATCH.R, B: PATCH.B, h: PATCH.h * Math.max(1, r) })), { ...NOSE_PATCH, h: NOSE_PATCH.h * Math.max(1, r) }] : [];
+  const zN = rig.J.nose[2] + 0.04;
+  return {
+    jobs: [
+      [{ name: 'body', part: 'body', bmin: [-0.36, -0.03, -1.5], bmax: [0.36, 1.3, 0.95], h: hBody, F: 4, clip: (x, y, z) => splitS(x, y, z) < B + D }],
+      [
+        { name: 'head', part: 'body', bmin: [-0.3, 0.6, 0.45], bmax: [0.3, 1.27, zN], h: 0.0042 * r, F: 6, clip: (x, y, z) => splitS(x, y, z) > -B - D, patches },
+        // (the jaw is small and sits under the overhanging upper lip, where its dark lip band meets the white
+        // chin: at 8 mm cells that edge was a black-and-white saw-tooth, a grimace)
+        { name: 'jaw', part: 'jaw', bmin: [-0.12, 0.77, 0.69], bmax: [0.12, 0.94, zN], h: 0.004 * (r <= 2.01 ? Math.min(r, 1.5) : 0.75 * r), F: 6, rigidBone: 'jaw' },
+        // the upper canines (up to the medium tier: at low and crowd nobody sees into a mouth)
+        ...(r <= 2.01 ? [{ name: 'canine', part: 'canine', bmin: [-0.07, 0.785, 0.9], bmax: [0.07, 0.875, 0.98], h: 0.0019 * Math.pow(r, 0.8), F: 6, rigidBone: 'head' }] : []),
+      ],
+    ],
+    fade(x, y, z, name, patch) {
+      const sN = splitS(x, y, z);
+      if (name === 'body') return 1 - smoothstep(-B, B, sN - D);
+      if (name === 'head') {
+        let f = smoothstep(-B, B, sN + D);
+        if (patches.length) { const ew = eyePatchWeight(x, y, z); f *= patch ? ew : 1 - ew; }
+        return f;
+      }
+      return 1;
+    },
+  };
+}

package/vendor/procedural-animals/src/species/lion/rig.js

@@ -0,0 +1,110 @@
+// Lion skeleton in bind pose (metres). Forward = +Z, up = +Y, the animal's left = +X.
+//
+// Reference individual: an average adult between the sexes: withers ~1.07 m over the
+// coat, head-body ~1.8 m along the curve, tail ~0.85 m (plus the tuft), skull ~0.32 m.
+// Limb segments (museum long bones, x ~0.95 for the reference individual):
+// scapula 0.29, humerus 0.32, radius 0.28, metacarpus 0.10, fore digits 0.075; femur 0.37,
+// tibia 0.32, tarsus + metatarsus 0.17, hind digits 0.075. Standing angles from side photos
+// (side_walk_male3, side_male1): scapula ~60 deg, elbow close under the front of the chest, radius
+// near vertical, hock ~0.2 x withers height, metatarsus nearly vertical. Compared with the cheetah the
+// lion is shorter in the leg (elbow ~0.39 x withers height vs 0.46), deeper in the chest (brisket at
+// ~0.42 x withers height), shorter in the back relative to its height and much heavier in the head.
+// The head is modelled level in its own frame (HEAD_O); its carriage comes from the motion data.
+import { buildRig } from '../../core/rig/rig.js';
+import { quadrupedBones, quadrupedLimbs, tailChain } from '../../core/rig/quadruped.js';
+import { WHISKER_BASE_F, WHISKER_TIP_F } from './whiskers.js';
+
+export const TAIL_SEGS = 10;
+export const SH = 1.07; // reference withers height (top of the coat)
+export const HEAD_O = [0, 0.95, 0.8]; // head-local origin (mid cranium, between eyes and ears)
+export const HS = 1.15; // head-local scale: landmarks below are for a 0.3 m head (x1.15: ~0.35 m over the skin)
+export const hl = (v) => [HEAD_O[0] + v[0] * HS, HEAD_O[1] + v[1] * HS, HEAD_O[2] + v[2] * HS];
+// Face units (sculpt, rig and coat share them): landmarks measured on the photos are given in units of
+// the eye separation E (0.112 head units = 0.129 m on the reference head) from the eye midpoint, in the
+// head frame (gaze +Z); X is in units of 0.1 head units times the head width hw (1.12 for a lioness:
+// X = 0.5 is the eye), so a male's broader face widens with hw.
+export const FACE = { E: 0.112, X: 0.1, EY: 0.047, EZ: 0.05 };
+export const fe = (X, Y, Z, hw = 1.12) => hl([X * FACE.X * hw, FACE.EY + Y * FACE.E, FACE.EZ + Z * FACE.E]);
+// head-local (x already divided by hw) -> face units
+export const toFace = (h) => [h[0] / FACE.X, (h[1] - FACE.EY) / FACE.E, (h[2] - FACE.EZ) / FACE.E];
+
+export function lionJoints() {
+  const J = {
+    nose: fe(0, -1.0, 1.2),
+    occiput: hl([0, 0.02, -0.135]),
+    neckMid: [0, 0.949, 0.575],
+    neckBase: [0, 0.915, 0.4],
+    chestMid: [0, 0.895, 0.22],
+    thoraxRear: [0, 0.915, -0.03],
+    lumbarMid: [0, 0.925, -0.28],
+    lumbosacral: [0, 0.915, -0.52],
+    tailBase: [0, 0.915, -0.765], // (high on the croup: the croup curves into the tail, side_walk_male3)
+    scapTopL: [0.065, 0.93, 0.29],
+    // (elbow ~0.43 x withers, brisket ~0.44: the legs read short for the chest with the elbow at 0.39;
+    // the humerus keeps its length, the forearm is longer)
+    shoulderL: [0.105, 0.7, 0.43],
+    elbowL: [0.1, 0.46, 0.225],
+    wristL: [0.08, 0.14, 0.27],
+    mcpL: [0.078, 0.05, 0.315],
+    ftoeL: [0.078, 0.024, 0.39],
+    hipL: [0.09, 0.8, -0.6],
+    kneeL: [0.11, 0.46, -0.45],
+    hockL: [0.09, 0.215, -0.66],
+    mtpL: [0.086, 0.05, -0.62],
+    htoeL: [0.086, 0.024, -0.548],
+    jawHinge: hl([0, -0.062, -0.04]),
+    jawTip: fe(0, -1.42, 0.78),
+    // (set out on the side of the crown, so the pinna's outer edge carries on the head's outline down to ~0.3 E above the
+    // eye line (face_female1); further in, the ears stood on top of the dome with a notch below them)
+    // (the tip ~1.05-1.15 E out and ~1.2 E above the eye line, face_female1 / face_male1: at 1.3-1.4 E out the ears stood on
+    // the corners of the head like a mouse's)
+    earBaseL: hl([0.106, 0.1, -0.068]),
+    // (lower, ~0.25 E: the pinnae stood 1.4 E above the eye line against the photos' 1.1-1.15 with their fur
+    // (ffront_*, fprof_*, f34_*), tall round ears on a dome, a plush toy's)
+    earTipL: hl([0.152, 0.192, -0.095]), // (the pinna ~9 cm above the skull's side, a little lower than wide at the base)
+    // the whisker fan's bone (whiskers.js): from the middle of the pad out to the side
+    whiskerBaseL: fe(...WHISKER_BASE_F),
+    whiskerTipL: fe(...WHISKER_TIP_F),
+    // the upper lip's lower edge from the canine back to the corner of the mouth: drawn back and up with the gape
+    // (behaviour.js pose hook), so a roaring or yawning lion bares its upper canines
+    lipBaseL: fe(0.42, -1.4, 0.3),
+    lipTipL: fe(0.52, -1.4, -0.1),
+  };
+  // bind tail held out behind and down (clear of the thighs and buttocks so the SDF does not merge
+  // them); the relaxed J-hang with the tuft curled up comes from the motion data
+  tailChain(J, 'tailBase', [-22, -34, -44, -51, -56, -58, -58, -55, -48, -38], [0.088, 0.088, 0.087, 0.086, 0.085, 0.084, 0.083, 0.082, 0.081, 0.08]);
+  return J;
+}
+
+export function lionRig() {
+  const J = lionJoints();
+  return buildRig({
+    joints: J,
+    unit: SH / 0.76,
+    headOrigin: HEAD_O,
+    // (+ a whisker bone per side: the whisker fans ride on it, whiskers.js)
+    bones: quadrupedBones({ tailSegs: TAIL_SEGS, ears: true, jaw: true, extra: [['whisker{S}', 'whiskerBase{S}', 'whiskerTip{S}', 'head', { region: 'head', group: 'whisk{S}' }], ['lip{S}', 'lipBase{S}', 'lipTip{S}', 'head', { region: 'head', group: 'lip{S}' }]] }),
+    axial: {
+      points: ['nose', 'occiput', 'neckMid', 'neckBase', 'chestMid', 'thoraxRear', 'lumbarMid', 'lumbosacral', 'tailBase', ...Array.from({ length: TAIL_SEGS }, (_, i) => 'tail' + (i + 1))],
+      bones: ['head', 'neck2', 'neck1', 'chest', 'spine3', 'spine2', 'spine1', 'pelvis', ...Array.from({ length: TAIL_SEGS }, (_, i) => 'tail' + i)],
+      // the skull's influence reaches back into the nape, the mane and the throat (3rd value: wider
+      // with the skin's distance from the axis under the throat)
+      blend: { 1: [-0.09, 0.2, 2.6] },
+      bodyTail: 0, // the tail hangs behind the buttocks: their skin blends into it only at the root
+    },
+    limbs: quadrupedLimbs({
+      front: { tCore: 0.55, aCore: 0.05, aBody: -0.12, midX: 0.0 },
+      hind: { tCore: 0.52, aCore: 0.035, aBody: -0.11, midX: 0.008 },
+    }),
+    appendages: [
+      // (a wide hand-over from the pinna to the skull: the broad ear base stretched > 3x round its rim
+      // when the ear flattened or swivelled)
+      { group: 'earL', bone: 'earL', blend: [-0.008, 0.022] },
+      { group: 'earR', bone: 'earR', blend: [-0.008, 0.022] },
+      // the upper lip's edge (sculpt.js 'lipedge', inside the lip): full weight within ~6 mm of it, none beyond ~3 cm
+      { group: 'lipL', bone: 'lipL', blend: [-0.0213, -0.0043] },
+      { group: 'lipR', bone: 'lipR', blend: [-0.0213, -0.0043] },
+    ],
+    webTags: ['flankfold', 'thighfront', 'scapmuscle', 'elbowtuft'],
+  });
+}