@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

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

@@ -0,0 +1,152 @@
+// Domestic sheep (Ovis aries). Cloven-hoofed grazer in wool: the fleece is a sculpted volume broken
+// into locks (sculpt.js) under short, tightly clumped, matte shells (the crimped staple tips), with a
+// clean short-haired face and legs; horizontal bar pupils in amber irises; spiral horns in Merino
+// rams; the flock animal's alarm, constant chewing while grazing, bleating, the ram's charge and the
+// ewe's foot stamp (behaviour.js).
+import { sheepRig, HEAD_O } from './rig.js';
+import { sculptSheep, EYE } from './sculpt.js';
+import { sheepRegions } from './regions.js';
+import { sheepCoat } from './coat.js';
+import { srgb } from '../../core/build/coatKit.js';
+import { rng } from '../../core/math/vec.js';
+import { motion } from './motion.js';
+
+const pick = (R, table) => {
+  let x = R() * table.reduce((s, [, w]) => s + w, 0);
+  for (const [k, w] of table) { x -= w; if (x <= 0) return k; }
+  return table[table.length - 1][0];
+};
+
+// Breeds / morphs (variants). fleece: [min, max] total fleece length (m, a year's growth);
+// horned: share of rams with horns; docked: share of docked tails; ear: carriage (rig.js EAR_SET)
+const BREEDS = {
+  whiteface: { coats: [['white', 1]], fleece: [0.05, 0.12], horned: 0, docked: 0.6, ear: 'lateral', roman: [0, 0.2], topknot: 0.25, size: 1, legs: 1, girth: 1 },
+  suffolk: { coats: [['suffolk', 1]], fleece: [0.04, 0.09], horned: 0, docked: 0.65, ear: 'droop', roman: [0.7, 1], topknot: 0, size: 1.08, legs: 1.03, girth: 1.03 },
+  merino: { coats: [['merino', 1]], fleece: [0.06, 0.1], horned: 0.95, docked: 0.85, ear: 'small', roman: [0.2, 0.5], topknot: 1, size: 0.94, legs: 0.97, girth: 1 },
+  black: { coats: [['black', 75], ['brown', 25]], fleece: [0.05, 0.12], horned: 0.3, docked: 0.4, ear: 'lateral', roman: [0, 0.3], topknot: 0.15, size: 0.98, legs: 1, girth: 1 },
+  shorn: { coats: [['white', 60], ['texel', 40]], fleece: [0.004, 0.015], horned: 0, docked: 0.7, ear: 'lateral', roman: [0, 0.2], topknot: 0, size: 1, legs: 1, girth: 1 },
+};
+
+export default {
+  id: 'sheep',
+  name: 'Sheep',
+  latin: 'Ovis aries',
+  group: 'hooves',
+  plan: 'quadruped',
+  covering: 'fur',
+  variants: [
+    { id: 'whiteface', name: 'White-faced sheep', latin: 'Ovis aries' },
+    { id: 'suffolk', name: 'Suffolk', latin: 'Ovis aries' },
+    { id: 'merino', name: 'Merino', latin: 'Ovis aries' },
+    { id: 'black', name: 'Black sheep', latin: 'Ovis aries' },
+    { id: 'shorn', name: 'Shorn sheep', latin: 'Ovis aries' },
+  ],
+
+  // Seeded individual. Breed / morph (o.variant: whiteface (default type), suffolk, merino, black,
+  // shorn) sets the colours, ears, Roman nose, horns and fleece; sex: ewe or ram (heavier, broader,
+  // thick neck, curled horns in horned breeds); age: adult or lamb (juvenile: long legs, short body,
+  // big head and ears, short tight curly fleece, long tail). The fleece length (params.fleece,
+  // 0 = shorn .. 0.15 m) is seeded within the breed's range (overrides: { fleece }).
+  variation(R0, o) {
+    // (the pipeline's stream is correlated between neighbouring seeds: re-mix it through an integer hash)
+    let h = (Math.floor(R0() * 4294967296) ^ Math.imul((o.seed ?? 1) + 0x632be5ab, 0x9e3779b1)) >>> 0;
+    h = Math.imul(h ^ (h >>> 16), 0x85ebca6b); h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35); h = (h ^ (h >>> 16)) >>> 0;
+    const R = rng(h);
+    for (let i = 0; i < 3; i++) R();
+    const variant = BREEDS[o.variant] ? o.variant : pick(R, [['whiteface', 40], ['suffolk', 24], ['merino', 16], ['black', 10], ['shorn', 10]]);
+    const Bd = BREEDS[variant];
+    const sex = o.sex || (R() < 0.4 ? 'male' : 'female');
+    const age = o.age || (R() < 0.18 ? 'juvenile' : 'adult');
+    const lamb = age === 'juvenile';
+    const ram = sex === 'male' && !lamb;
+    const g = () => (R() + R() + R() - 1.5) / 1.5; // ~[-1, 1], peaked
+    const coat = pick(R, Bd.coats);
+    // fleece length: a year's growth for adults, 10-20 mm tight curls for lambs
+    const u = 0.5 + 0.5 * g();
+    let fleece = lamb ? 0.012 + 0.01 * R() : Bd.fleece[0] + (Bd.fleece[1] - Bd.fleece[0]) * u;
+    if (o.overrides && o.overrides.fleece !== undefined) fleece = o.overrides.fleece;
+    fleece = Math.max(0, Math.min(0.15, fleece));
+    // the outer staple tips are shells; the rest of the fleece is sculpted volume
+    const staple = Math.max(0.005, Math.min(0.018, 0.25 * fleece + 0.004)) * (lamb ? 1.1 : 1);
+    const wool = fleece > 0.035 ? fleece - staple : 0; // (short fleeces: shells over the body skin only)
+    let horns = null;
+    if (ram && R() < Bd.horned) horns = { turns: (variant === 'merino' ? 1.0 : 0.75) + 0.35 * R(), base: 0.03 + 0.009 * R(), r0: 0.95 + 0.1 * R(), flare: 0.8 + 0.4 * R() };
+    else if (lamb && sex === 'male' && R() < Bd.horned) horns = { turns: 0.12 + 0.06 * R(), base: 0.012, r0: 0.75, flare: 0.5 };
+    const docked = !lamb ? R() < Bd.docked : R() < Bd.docked * 0.5;
+    const tailLen = docked ? 0.06 + 0.04 * R() : 0.3 + 0.08 * R();
+    const size = (ram ? 1.13 + 0.05 * R() : 1) * (1 + 0.045 * g()) * Bd.size * (lamb ? 0.62 : 1);
+    return {
+      sex, age, size, variant, coat,
+      fleece, staple, wool,
+      horns,
+      tailLen,
+      ear: Bd.ear,
+      earLift: R(),
+      roman: (Bd.roman[0] + (Bd.roman[1] - Bd.roman[0]) * R()) + (ram ? 0.2 : 0),
+      topknot: R() < Bd.topknot ? 0.4 + 0.6 * R() : 0,
+      folds: variant === 'merino' && !lamb ? (ram ? 0.7 : 0.4) + 0.3 * R() : 0,
+      muscle: coat === 'texel' ? 0.6 + 0.4 * R() : 0.3 * R(),
+      udder: sex === 'female' && !lamb ? 0.1 + 0.6 * R() : 0,
+      heavy: ram ? 0.6 + 0.4 * R() : 0,
+      hoofStripe: R(),
+      hornColor: variant === 'black' ? 0x6a5846 : 0xb09a78,
+      coatShade: g(), coatLightness: 0.05 * g(),
+      coatSeed: Math.floor(R() * 1e6),
+      minThick: 0.004,
+      warps: [
+        // (the head scale first: its centre is the unwarped head origin)
+        { type: 'scaleAbout', c: HEAD_O, k: (1 + 0.035 * g()) * (lamb ? 1.22 : 1) * (ram ? 1.06 : 1), r0: 0.1, r1: 0.2 },
+        { type: 'legs', k: (1 + 0.035 * g()) * Bd.legs * (lamb ? 1.24 : 1), top: 0.36 },
+        { type: 'length', k: (1 + 0.035 * g()) * (lamb ? 0.84 : 1), z0: -0.4, z1: 0.3 },
+        { type: 'girth', k: (1 + 0.04 * g()) * Bd.girth * (ram ? 1.05 : 1) * (lamb ? 0.9 : 1), cy: 0.47, z0: -0.5, z1: 0.36 },
+      ],
+    };
+  },
+  rig: (params) => sheepRig(params),
+  sculpt: (m, rig, params) => sculptSheep(m, rig, params),
+  regions: sheepRegions,
+  coat: sheepCoat,
+  eyeSpecs: (params) => [1, -1].map((side) => ({ side, spec: EYE, headOrigin: HEAD_O, bone: 'head', look: eyeLook(params) })),
+  motion,
+  // wool: fine, dense strands in small tight clumps (crimped staple tips); matte
+  render: (params) => ({
+    markColor: srgb(['suffolk', 'black'].includes(params.variant) ? 0x141212 : 0x5c4a46),
+    strandDensity: params.variant === 'merino' ? 1500 : 1150,
+    clumpDensity: (params.fleece || 0) > 0.02 ? 1.9 : 1.3,
+    shellScale: 1,
+    finWidth: 0.35,
+    // (the short face and leg hair forms small tufts too, each leaning its own way: the face reads as short
+    // hair rather than a smooth rubber skin, and the highlight on a black face breaks up instead of running
+    // in glossy streaks; the default [0.0055, 0.016] left 4-6 mm hair untufted)
+    clumpLen: [0.0015, 0.009],
+    // (no silhouette fins: over a sculpted fleece they drew the lock bumps' contours as dark seams across
+    // the back and the rump, and on short coats (shorn, lambs) they traced the head / body mesh hand-over
+    // down the neck as a dotted line; the shells alone give the short coat's soft edge)
+    fins: false,
+    // (core render hint: the wool's shells slide down the staple as they rise; where the neck creases (the
+    // throat when grazing, the side of the neck toward which the head turns) they dove under the skin of the
+    // fold and it showed as a jagged bald line. Taken ~5 mm nearer the camera they stay on top; face and leg
+    // hair shorter than 8 mm is untouched)
+    shellDepthBias: [0.6, 0.008],
+  }),
+};
+
+// The sheep's eye: a horizontal bar pupil (rectangular, 2.5-3 : 1 when constricted) in a golden to
+// amber-brown iris, sclera hardly visible, dark lids; lambs paler.
+const IRISES = [
+  { inner: 0x9c7a34, mid: 0xb8913f, hi: 0xd4b066, outer: 0x5e4418 }, // amber (default)
+  { inner: 0x6e5020, mid: 0x8a6a30, hi: 0xa8864a, outer: 0x3e2a10 }, // darker amber-brown
+  { inner: 0xa88a48, mid: 0xc8a85a, hi: 0xe0c888, outer: 0x6a5020 }, // pale golden
+];
+function eyeLook(params) {
+  const s = ((params.coatSeed || 0) % 100) / 100;
+  const ir = IRISES[params.age === 'juvenile' ? 2 : s < 0.6 ? 0 : s < 0.9 ? 1 : 2];
+  return {
+    pupil: 'bar',
+    lids: 'mammal',
+    iris: { inner: srgb(ir.inner), mid: srgb(ir.mid), hi: srgb(ir.hi), outer: srgb(ir.outer) },
+    sclera: { color: [0.45, 0.38, 0.32], visible: false },
+    lidColor: [0.03, 0.025, 0.022],
+    pupilSize: [0.1, 0.34],
+  };
+}

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

@@ -0,0 +1,86 @@
+// Sheep motion data for the quadruped engine (schema: src/core/motion/quadruped.js).
+// Numbers are for the reference individual (params.size = 1, a 0.70 m, 70 kg ewe); the engine
+// scales them by dynamic similarity for lambs and big rams.
+//
+// Gaits: lateral-sequence 4-beat walk (0.9-1.3 m/s: 0.96-1.25 Hz,
+// duty 0.66 -> 0.60, hoof swing height 49 mm fore / 55 mm hind, Kim & Breur 2008, treadmill studies),
+// 2-beat diagonal trot (1.8-2.4 Hz, duty 0.45 -> 0.37), a 3-beat canter (right lead) in flock flight
+// and the transverse gallop (2.5-3 Hz). Crossovers: walk -> trot at Froude ~0.45 (1.8 m/s for a
+// 0.72 m hip height), trot -> canter / gallop 4.3 m/s at ~2.5 Hz (Heglund et al. 1974: v = 1.535
+// M^0.24, f = 4.48 M^-0.14 for 70 kg).
+import { hooks } from './behaviour.js';
+
+const G = (name, v, f, D, off, o) => ({ name, v, f, D, off, ...o });
+
+export const motion = {
+  maxSpeed: 8.5,
+  accel: [3, 6.5],
+  decel: 7,
+  turnRate: 3.0,
+  latAccelMax: 8,
+  gears: { walk: 0.95, trot: 2.8, canter: 4.7, gallop: 6.8 },
+  gallopBlend: [4.0, 6.5],
+  //    name      v     f     D     [FL,   FR,   HL,  HR]
+  gaits: [
+    G('walk', 0.0, 0.75, 0.7, [0.25, 0.75, 0.0, 0.5], { liftF: 0.042, liftH: 0.046, bobF: 0.01, bobH: 0.01, flex: 0, lat: 0.02, fold: 0.65, heel: 18, tail: 0, drop: 0 }),
+    G('walk', 1.5, 1.28, 0.6, [0.27, 0.77, 0.0, 0.5], { liftF: 0.05, liftH: 0.055, bobF: 0.022, bobH: 0.022, flex: 0, lat: 0.025, fold: 0.85, heel: 26, tail: 0.1, drop: 0 }),
+    G('trot', 2.05, 1.9, 0.45, [0.52, 0.02, 0.0, 0.5], { liftF: 0.075, liftH: 0.062, bobF: 0.026, bobH: 0.026, flex: 0.01, lat: 0.0, fold: 1.05, heel: 36, tail: 0.12, drop: 0.006 }),
+    G('trot', 3.8, 2.3, 0.36, [0.52, 0.02, 0.0, 0.5], { liftF: 0.09, liftH: 0.075, bobF: 0.03, bobH: 0.03, flex: 0.015, lat: 0.0, fold: 1.15, heel: 52, tail: 0.16, drop: 0.01 }),
+    G('canter', 4.4, 2.35, 0.35, [0.3, 0.55, 0.0, 0.27], { liftF: 0.1, liftH: 0.085, bobF: 0.024, bobH: 0.032, flex: 0.06, lat: 0, fold: 1.2, heel: 38, tail: 0.20, drop: 0.015 }),
+    G('canter', 5.1, 2.45, 0.32, [0.3, 0.55, 0.0, 0.26], { liftF: 0.105, liftH: 0.09, bobF: 0.025, bobH: 0.034, flex: 0.08, lat: 0, fold: 1.25, heel: 48, tail: 0.24, drop: 0.02 }),
+    G('gallop', 6.0, 2.6, 0.28, [0.55, 0.65, 0.0, 0.1], { liftF: 0.11, liftH: 0.1, bobF: 0.022, bobH: 0.03, flex: 0.1, lat: 0, fold: 1.3, heel: 45, tail: 0.28, drop: 0.022 }),
+    G('gallop', 8.5, 2.85, 0.24, [0.56, 0.66, 0.0, 0.1], { liftF: 0.115, liftH: 0.11, bobF: 0.024, bobH: 0.034, flex: 0.12, lat: 0, fold: 1.25, heel: 40, tail: 0.40, drop: 0.035 }),
+  ],
+  feet: {
+    // cloven hooves on fairly upright pasterns: the fetlock sinks a little under load, the claws flip
+    // in swing, breakover about the claw tips
+    front: { type: 'unguligrade', contact: 1.0, curl: 62, flex: 4, sink: 6, hoofFlex: 15, swingBack: 0.06, liftBehind: 0.95 },
+    hind: { type: 'unguligrade', contact: 0.92, curl: 60, flex: 4, sink: 8, hoofFlex: 15, swingBack: 0.02 },
+  },
+  stance: { width: 1, gallopWidth: 0.8, sprawl: 0, crouch: 0, scuff: [10, 20, 0] },
+  // torso cross-sections of the shorn body (bind pose, reference size): centre height, half height,
+  // half width (half heights include the legs folded under the chest and thighs when lying down);
+  // behaviour.js adds the fleece of the individual
+  body: {
+    chest: { y: 0.47, hh: 0.25, hw: 0.165 },
+    mid: { y: 0.47, hh: 0.24, hw: 0.18 },
+    pelvis: { y: 0.53, hh: 0.3, hw: 0.17 },
+    rump: { z: -0.43, y: 0.53, hh: 0.3, hw: 0.14 },
+    back: 0.06,
+  },
+  head: {
+    // [speed, raise (m), reach (m), pitch (rad, + = nose down)]: head up and alert at rest, lower and
+    // forward at the walk (following the flock), stretched forward in flight
+    carriage: [[0, 0.02, -0.01, -0.04], [0.95, -0.02, 0.01, 0.03], [2.5, -0.02, 0.03, 0.03], [4.2, -0.05, 0.05, 0.08], [8, -0.08, 0.08, 0.12]],
+    stab: [[0, 0], [0.95, 0.15], [2.5, 0.45], [4.2, 0.35], [8, 0.4]],
+    neckBend: 34, neckPivot: 0.75, yaw: 0.85, pitchUp: 0.65, pitchDown: 0.9, mouth: 'jawTip',
+  },
+  tail: {
+    // [speed, pitch per segment from horizontal (deg), base -> tip]: hangs straight down (the docked
+    // stump too), lifts a little when running
+    carriage: [
+      [0.0, [-38, -64, -76, -82, -86, -88]],
+      [1.4, [-34, -60, -74, -80, -84, -86]],
+      [3.5, [-32, -58, -72, -79, -83, -85]],
+      [7, [-28, -52, -66, -74, -78, -80]],
+    ],
+    stiffness: 0.9, sway: 5, flick: 0.4, wag: 0, swish: 0, curl: 0, balance: 0,
+    radius: [0.035, 0.025],
+  },
+  ears: { rest: [0, 0], mobility: 0.9, speedFlatten: 0.25, twitch: 1.5, prick: 0.25 },
+  breath: { rate: 0.3, amp: 0.006, pant: false, pantRate: 2.2, pantAmp: 0.014, heatSpeed: 6 },
+  actions: {
+    // grazing: muzzle on the sward, the forefeet a little spread
+    eat: { style: 'graze', dropF: 0.1, dropH: 0, pitch: 0.9, ahead: 0.6 },
+    drink: { dropF: 0.1, dropH: 0, pitch: 0.9, ahead: 0.6 },
+    // a low jump with the forelegs tucked (0.5-1 m obstacles)
+    jump: { height: 0.6, distance: 1.4, land: [0.16, 0.14] },
+    sit: { dropH: 0.8 },
+    // kneels on both carpi first, then drops the hindquarters; rises hind end first (ruminant)
+    lie: { down: 'front', up: 'hind' },
+    sleep: { down: 'front', up: 'hind' },
+    // lying sternal: forelegs folded under the chest (carpus flexed, cannons back along the ground)
+    fold: { front: { z: -0.2, k: 1.45, beta: 0.9 } },
+  },
+  hooks,
+};

package/vendor/procedural-animals/src/species/sheep/neck.js

@@ -0,0 +1,41 @@
+// The head / body meshing boundary across the upper neck (regions.js), also used by the sculpt and
+// the coat.
+import { HZ, hl, EAR_BASE, EAR_SET, earTip } from './rig.js';
+import { norm } from '../../core/math/vec.js';
+
+// cut across the neck just behind the ears, perpendicular to the head's axis (the dense head mesh
+// stops where the neck wool starts: the head emerges from the fleece)
+// (two planes: one across the head's axis behind the ears, one tilted through the throat behind the
+// jaw so the lower neck and the breast stay in the body)
+const C1 = hl([0, 0, -0.078]), C2 = [0, 0.76, 0.5], D2 = norm([0, 0.45, 1]);
+export const NECK_CUT = { c: C1, d: HZ, band: 0.012 };
+// ... and the ears, swept back past that plane, stay in the head mesh: a zone round every ear any
+// individual can carry (each carriage, ear lift and the horned ram's base), left side; mirrored by |x|
+const EAR_SEGS = [];
+for (const ear of Object.keys(EAR_SET)) {
+  for (const earLift of [0, 0.5, 1]) {
+    for (const horns of [null, { turns: 1 }]) {
+      const base = horns ? [0.05, 0.002, -0.066] : EAR_BASE;
+      EAR_SEGS.push([hl(base), hl(earTip({ ear, earLift, horns }, base))]);
+    }
+  }
+}
+const EAR_R = 0.038;
+function earDist(x, y, z) {
+  let dm = 1e9;
+  for (const [a, b] of EAR_SEGS) {
+    const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+    const px = Math.abs(x) - a[0], py = y - a[1], pz = z - a[2];
+    const t = Math.max(0, Math.min(1, (px * dx + py * dy + pz * dz) / (dx * dx + dy * dy + dz * dz)));
+    const d = Math.hypot(px - dx * t, py - dy * t, pz - dz * t);
+    if (d < dm) dm = d;
+  }
+  return dm;
+}
+export const neckS = (x, y, z) => {
+  const s = Math.min(
+    (x - C1[0]) * HZ[0] + (y - C1[1]) * HZ[1] + (z - C1[2]) * HZ[2],
+    (y - C2[1]) * D2[1] + (z - C2[2]) * D2[2],
+  );
+  return s > EAR_R ? s : Math.max(s, EAR_R - earDist(x, y, z));
+};

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

@@ -0,0 +1,62 @@
+// Meshing plan: body at 5.6 mm (0.8 % of the withers height; the fleece makes a large surface),
+// head at 2.6 mm overlapping the body across the upper neck and cross-faded, eyelid patches at
+// 0.9 mm, the lower lip / chin as its own rigid surface (the mouth opens) and the horns as a rigid
+// keratin surface on the skull.
+import { EYE } from './sculpt.js';
+import { HEAD_O, hl } from './rig.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+import { smoothstep } from '../../core/math/vec.js';
+
+export { NECK_CUT, neckS } from './neck.js';
+import { NECK_CUT, neckS } from './neck.js';
+
+export const EYE_PATCH = { R: 0.024, B: 0.004, h: 0.0011, centres: [1, -1].map((s) => eyeFrameOf(EYE, HEAD_O, s).c) };
+// the front of the nose re-meshed finer too: the nostril slits (7 x 20 mm carves) and the philtrum came out of
+// the 4-5 mm face cells as ragged dark blotches; ~1.2 mm cells (2.4 at medium) give clean slits
+export const NOSE_PATCH = { R: 0.024, B: 0.004, h: 0.0012, centres: [hl([0, -0.022, 0.195])] };
+const ballWeight = (P, x, y, z) => {
+  let dmin = 1e9;
+  for (const c of P.centres) dmin = Math.min(dmin, Math.hypot(x - c[0], y - c[1], z - c[2]));
+  return 1 - smoothstep(P.R - P.B, P.R + P.B, dmin);
+};
+export const eyePatchWeight = (x, y, z) => ballWeight(EYE_PATCH, x, y, z);
+// (the patches lie far apart: a point is in one at most)
+export const patchWeight = (x, y, z) => Math.max(ballWeight(EYE_PATCH, x, y, z), ballWeight(NOSE_PATCH, x, y, z));
+
+export function sheepRegions(rig, params, Q) {
+  const r = Q.res;
+  const W = 0.2 + (params.wool || 0) * 1.3;
+  const hBody = 0.0065 * (1 + 1.6 * (params.wool || 0)) * r;
+  // (the band is wider than a body cell, so the body's cut edge, which lies up to a cell into the band,
+  // stays in its hidden half: at the low and crowd tiers a 12 mm band left it on show, an open seam
+  // across the top of the neck)
+  const B = Math.max(NECK_CUT.band, hBody * 1.2);
+  // (eyelid patches at medium too: Safari and phones show medium, and the coarse face cut the almond into a
+  // ragged notch)
+  const patches = (Q.eyePatches || r <= 2) ? [EYE_PATCH, NOSE_PATCH].flatMap((P) => P.centres.map((c) => ({ c, R: P.R, B: P.B, h: P.h * Math.max(1, r) }))) : [];
+  // (the face a little finer at medium: the nostril slits and the lip line came out ragged)
+  const hm = r === 2 ? 0.78 : 1;
+  const head = [
+    { name: 'head', part: 'body', bmin: [-0.3, 0.5, 0.3], bmax: [0.3, 1.05, 0.8], h: 0.0031 * r * hm, F: 6, clip: (x, y, z) => neckS(x, y, z) > -B, patches },
+    { name: 'jaw', part: 'jaw', bmin: [-0.05, 0.5, 0.45], bmax: [0.05, 0.8, 0.8], h: 0.0027 * r * hm, F: 6, rigidBone: 'jaw' },
+  ];
+  if (params.horns && params.horns.turns > 0) {
+    head.push({ name: 'horn', part: 'horn', bmin: [-0.36, 0.5, 0.2], bmax: [0.36, 1.12, 0.8], h: (params.horns.base > 0.025 ? 0.0042 : 0.003) * r, F: 6, rigidBone: 'head' });
+  }
+  return {
+    jobs: [
+      [{ name: 'body', part: 'body', bmin: [-W - 0.02, -0.01, -0.62 - W], bmax: [W + 0.02, 1.02, 0.72], h: hBody, F: 4, clip: (x, y, z) => neckS(x, y, z) < B }],
+      head,
+    ],
+    fade(x, y, z, name, patch) {
+      const sN = neckS(x, y, z);
+      if (name === 'body') return 1 - smoothstep(-B, B, sN);
+      if (name === 'head') {
+        let f = smoothstep(-B, B, sN);
+        if (patches.length) { const ew = patchWeight(x, y, z); f *= patch ? ew : 1 - ew; }
+        return f;
+      }
+      return 1;
+    },
+  };
+}

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

@@ -0,0 +1,163 @@
+// Sheep skeleton in bind pose (metres). Forward = +Z, up = +Y, the animal's left = +X.
+// Reference individual: a white-faced medium-wool ewe (Dorset / Cheviot / Texel type), 0.70 m at the
+// withers (skeleton, without the fleece), ~70 kg. Landmarks measured on
+// side2.jpg (1 px = 1.67 mm), side3_texel.jpg (shorn: nose -> buttock 1.73 SH, belly 0.39 SH, head
+// 0.37 SH) and the research limb table (sheep have long cannons, short forearms).
+//
+// Hooves: the standard quadruped bones plus a hoof bone per leg, exactly like the horse and the goat:
+// fpaw / hpaw = pastern (fetlock -> coffin joint), fhoof / hhoof = the cloven hoof (coffin joint ->
+// toe), so the engine keeps the claws flat while the fetlock sinks under load.
+//
+// The rig depends on the individual through the ears (lateral and horizontal; long and drooping in
+// the Suffolk: params.ear) and the tail (long, hanging to the hocks, or docked: params.tail).
+import { buildRig } from '../../core/rig/rig.js';
+import { quadrupedBones, quadrupedLimbs, tailChain } from '../../core/rig/quadruped.js';
+
+export const TAIL_SEGS = 6;
+
+// Head frame: modelled along its own axis (poll -> muzzle), pitched 37 degrees nose-down in the
+// bind pose; the dorsal line falls a further 11 degrees from the axis toward the nose (sculpt.js topY),
+// so the nasal line stands 48 degrees to the ground (side2: 46 deg). (At 48 degrees for the axis, the
+// nasal line stood at 59: a face hanging straight down from a high dome, the "boot".) Head-local
+// coordinates: x lateral, y dorsal (forehead side), z along the axis toward the muzzle; origin on the
+// axis 0.07 m in front of the poll, level with the eyes.
+export const HEAD_PITCH = (33 * Math.PI) / 180;
+export const HZ = [0, -Math.sin(HEAD_PITCH), Math.cos(HEAD_PITCH)];
+export const HY = [0, Math.cos(HEAD_PITCH), Math.sin(HEAD_PITCH)];
+const POLL = [0, 0.895, 0.54]; // top of the poll (skin), bind
+export const HEAD_O = [0, POLL[1] + 0.07 * HZ[1], POLL[2] + 0.07 * HZ[2]];
+export const hl = (v) => [HEAD_O[0] + v[0], HEAD_O[1] + v[1] * HY[1] + v[2] * HZ[1], HEAD_O[2] + v[1] * HY[2] + v[2] * HZ[2]];
+// head-local direction -> world
+export const hdir = (v) => [v[0], v[1] * HY[1] + v[2] * HZ[1], v[1] * HY[2] + v[2] * HZ[2]];
+
+// ears (head-local, left): carried out to the sides and swept back, so the leaf reads from the side as well
+// as from the front (front1, face1, side4_suffolk, extra/Suffolk_sheep_20790901685, Tete_de_brebie_Suffolk:
+// "aeroplane" ears seen from the front, a long blade reaching back past the poll seen from the side). Given
+// as a world direction in the bind pose (back = degrees swept back from straight out, down = degrees below
+// level) and a length; the Suffolk's are longer and hang a little; the Merino's smaller. (Straight out to
+// the sides, an ear seen from the side was only its foreshortened stalk: a stub against the poll.)
+// (At 40-46 deg back with the blade on edge, the ear read as a pink cup standing up from the side and a
+// paddle behind the poll. At 32-36 deg back the near ear, seen from the side, was still a short
+// pink cup over the poll (its length foreshortened) and the far ear a paddle; now 46-48 deg back (Suffolk 40)
+// and 20 deg below level (side2: the ear a leaf held level, pointing back, its inside showing), the blade's
+// turn in sculpt.js.)
+export const EAR_BASE = [0.056, 0.006, -0.058]; // (at the top corners of the head, behind the eyes)
+export const EAR_SET = {
+  lateral: { back: 46, down: 20, len: 0.135 },
+  droop: { back: 40, down: 28, len: 0.152 },
+  small: { back: 48, down: 14, len: 0.112 },
+};
+// world direction (bind) -> head-local
+const toLocal = (d) => [d[0], d[1] * HY[1] + d[2] * HY[2], d[1] * HZ[1] + d[2] * HZ[2]];
+export function earTip(params = {}, base = EAR_BASE) {
+  const E = EAR_SET[params.ear] || EAR_SET.lateral;
+  // (a horned ram's ear comes out under the horn's sweep: less swept back, or it runs into the coil)
+  const back = (params.horns && params.horns.turns > 0.3 ? 0.35 : 1) * E.back * Math.PI / 180;
+  const down = (E.down + 14 * ((params.earLift ?? 0.5) - 0.5)) * Math.PI / 180;
+  const d = toLocal([Math.cos(down) * Math.cos(back), -Math.sin(down), -Math.cos(down) * Math.sin(back)]);
+  const L = E.len;
+  return [base[0] + d[0] * L, base[1] + d[1] * L, base[2] + d[2] * L];
+}
+
+// tail: long (undocked, to the hocks) or docked (a short stump)
+export function tailSpec(params = {}) {
+  const L = params.tailLen ?? 0.34;
+  const w = [0.2, 0.19, 0.17, 0.16, 0.14, 0.14];
+  const long = L > 0.15;
+  return {
+    len: L,
+    lens: w.map((f) => f * L),
+    pitch: long ? [-38, -64, -76, -82, -86, -88] : [-28, -45, -55, -60, -62, -64],
+  };
+}
+
+export function sheepJoints(params = {}) {
+  const earB = params.horns && params.horns.turns > 0.3 ? [0.05, 0.002, -0.066] : EAR_BASE;
+  const J = {
+    nose: hl([0, -0.014, 0.195]), // (the front of the nose pad and upper lip: the engine keeps it off the ground)
+    occiput: hl([0, -0.045, -0.1]), // (behind the poll and horn bases: the skull top is all 'head')
+    neckMid: [0, 0.715, 0.425],
+    neckBase: [0, 0.555, 0.285],
+    chestMid: [0, 0.585, 0.13],
+    thoraxRear: [0, 0.61, -0.03],
+    lumbarMid: [0, 0.622, -0.17],
+    lumbosacral: [0, 0.625, -0.3],
+    tailBase: [0, 0.612, -0.47],
+    // fore: scapula sloping ~60 deg, humerus down and back, forearm and cannon vertical, pastern ~50
+    // deg (research: humerus 0.17, radius 0.18, cannon 0.13)
+    scapTopL: [0.056, 0.668, 0.21],
+    shoulderL: [0.086, 0.49, 0.305],
+    elbowL: [0.08, 0.345, 0.215],
+    wristL: [0.068, 0.185, 0.232],
+    mcpL: [0.062, 0.064, 0.238],
+    fcoffinL: [0.062, 0.028, 0.258],
+    ftoeL: [0.062, 0.002, 0.3],
+    // hind: hip joint, stifle, hock, fetlock, coffin joint, toe (femur 0.20, tibia 0.23, cannon 0.15)
+    hipL: [0.076, 0.555, -0.33],
+    kneeL: [0.09, 0.385, -0.215],
+    hockL: [0.064, 0.215, -0.385],
+    mtpL: [0.058, 0.066, -0.365],
+    hcoffinL: [0.058, 0.029, -0.343],
+    htoeL: [0.058, 0.002, -0.3],
+    jawHinge: hl([0, -0.045, -0.02]),
+    jawTip: hl([0, -0.064, 0.189]), // (the front of the lower lip: the mouth the engine puts on the ground)
+    // (horned rams: the ears come out below and behind the horn bases)
+    earBaseL: hl(earB),
+    earTipL: hl(earTip(params, earB)),
+    // udder (ewes) / scrotum (rams): its own rigid bone below the pelvis, so it can fold up out of the
+    // ground when the sheep lies down (hooks.pose)
+    udderTop: [0, 0.4, -0.3],
+    udderBot: [0, 0.27, -0.29],
+  };
+  const T = tailSpec(params);
+  tailChain(J, 'tailBase', T.pitch, T.lens);
+  return J;
+}
+
+export function sheepBones() {
+  const b = quadrupedBones({ tailSegs: TAIL_SEGS, ears: true, jaw: true });
+  for (const d of b) {
+    if (d[0] === 'fpaw{S}') { d[2] = 'fcoffin{S}'; d[4] = { region: 'limb', group: 'F{S}' }; }
+    if (d[0] === 'hpaw{S}') { d[2] = 'hcoffin{S}'; d[4] = { region: 'limb', group: 'H{S}' }; }
+  }
+  b.push(['udder', 'udderTop', 'udderBot', 'pelvis', { region: 'torso', group: 'udder' }]);
+  b.push(
+    ['fhoof{S}', 'fcoffin{S}', 'ftoe{S}', 'fpaw{S}', { region: 'foot', group: 'F{S}' }],
+    ['hhoof{S}', 'hcoffin{S}', 'htoe{S}', 'hpaw{S}', { region: 'foot', group: 'H{S}' }],
+  );
+  return b;
+}
+
+export function sheepRig(params = {}, J = sheepJoints(params)) {
+  const limbs = quadrupedLimbs({
+    front: { tCore: 0.5, aCore: 0.05, aBody: -0.15, midX: 0.0 },
+    hind: { tCore: 0.45, aCore: 0.022, aBody: -0.2, midX: 0.008 },
+  });
+  for (const L of Object.values(limbs)) { L.bones.push((L.front ? 'fhoof' : 'hhoof') + L.S); L.distal.push((L.front ? 'fhoof' : 'hhoof') + L.S); }
+  return buildRig({
+    joints: J,
+    unit: 0.92,
+    headOrigin: HEAD_O,
+    bones: sheepBones(),
+    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 throat (widening with the depth below the axis)
+      blend: { 1: [-0.01, 0.17, 7], 2: [-0.19, 0.22, 0], 3: [-0.22, 0.17, 0] },
+      bodyTail: 0, // (the britch wool does not blend into the tail: it tore when the thighs folded to lie down)
+      // (core weights.js `cascade`: the occiput's throat lever reaches past the mid-neck joint, where the default
+      // chain weighting cut the skull's share from 0.2-0.4 to 0 within 2 cm of coarse neck: the neck wool creased
+      // along that line, a jagged crack, whenever the head dropped or turned. It now fades out over the 7 cm past
+      // the joint. Not in the Merino: the fade stretches the neck wool a little more when grazing and sleeping
+      // (pattern edges > 1.5x 29.8 -> 31.0 % of 30), and its crease is left to the shells' depth bias, index.js)
+      cascade: params.variant === 'merino' ? false : { 1: 0.07 },
+    },
+    limbs,
+    appendages: [
+      { group: 'earL', bone: 'earL', blend: [-0.002, 0.004] },
+      { group: 'earR', bone: 'earR', blend: [-0.002, 0.004] },
+      { group: 'udder', bone: 'udder', blend: [-0.004, 0.02] },
+    ],
+    webTags: ['flankfold', 'thighfront', 'scapmuscle', 'pectoral', 'forearmweb', 'woolarm', 'woolthigh', 'woolweb'],
+  });
+}