@bitefoundry/retrieviewer 0.0.3 → 0.0.4

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

@@ -1,152 +0,0 @@
-// 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

@@ -1,86 +0,0 @@
-// 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

@@ -1,41 +0,0 @@
-// 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

@@ -1,62 +0,0 @@
-// 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

@@ -1,163 +0,0 @@
-// 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'],
-  });
-}