@bitefoundry/retrieviewer 0.0.2 → 0.0.4

package/vendor/procedural-animals/src/species/pig/ears.js

@@ -1,242 +0,0 @@
-// Pig ear leaves: the geometry shared by the rig (the ear bone runs from the root to the leaf's tip), the
-// sculpt (tiles), the meshing plan (the region box) and the coat (the hollow side, how far out along the ear).
-//
-// A leaf is one smooth curved sheet with a mid-surface P(s, a) (s 0 root .. 1 tip, a -1 .. 1 across):
-// - the spine leaves the head along the root direction `root` (WORLD, standing pig, left ear), runs straight
-//   for the first s0 of its length and then bends toward the hollow side by `bend` degrees in all (bendPow
-//   > 1: the bend comes late, toward the tip);
-// - its cross-section is a circular arc that rolls both edges toward the hollow by `cup` (rad, root -> tip:
-//   the root rolled into the funnel of the ear canal, flatter toward the tip), half width W earW(s);
-// - it is thick at the root and thins toward the rim (`thick`: [root, rim] full thickness, m): cartilage and
-//   skin ~1.2-1.5 cm where the pinna leaves the head, 3-4 mm at its free edge, with a round rim.
-// The sheet is tiled with small exact slabs (m.fin with a thickness gradient, core sdf.js), each its quad
-// projected on its own plane and run one rim radius past every edge it shares with a neighbour, so the
-// rounded ends of neighbours make one cylinder there and the sheet runs on smoothly.
-//
-// Forms (from photos):
-// - erect (Large White, Hampshire, Berkshire; face1, face2, front1): a broad leaf up and forward, the hollow
-//   facing forward and out, a rounded tip curling a little forward;
-// - semi (Duroc; face3): up and out from the top corners of the poll with the hollow facing forward, curving
-//   out and down as it goes (sweep) and the outer part folding forward and down (bend), a thick, soft leaf
-//   hanging beside the eyes;
-// - lop (Landrace, Gloucester Old Spot): the leaf leaves the poll corner forward along the head and a little out
-//   and up, then droops forward and down over the eye toward the snout, a soft visor with air under it (its
-//   convex back out and up, the hollow facing the face below it), the forehead showing between the two.
-const PI = Math.PI;
-const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-const mul = (a, k) => [a[0] * k, a[1] * k, a[2] * k];
-const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-const norm = (a) => { const l = Math.hypot(a[0], a[1], a[2]) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
-const clamp01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);
-const sstep = (a, b, x) => { const t = clamp01((x - a) / (b - a)); return t * t * (3 - 2 * t); };
-
-// ear root on the head (head-local, rig.js hl()): the top corners of the broad poll (face2 / front1: the
-// ear bases well out from the midline)
-export const EAR_BASE = [0.07, 0.056, -0.074];
-// the ears' meshing cell at the hero tier (regions.js: x the tier's res)
-export const EAR_CELL = 0.003;
-
-// leaf outlines: half width (x W) along the leaf
-const OUTLINE = {
-  // (broad, the widest a third of the way up, a rounded tip: face2, front1)
-  // (a pointed tip, lw_show, head_hausschwein5, face2; the rounded tip read as a mouse's ear)
-  erect: [[0, 0.5], [0.08, 0.68], [0.22, 0.94], [0.4, 1.0], [0.6, 0.9], [0.78, 0.66], [0.9, 0.38], [1.0, 0.06]],
-  // (broad and blunt: face3)
-  semi: [[0, 0.5], [0.08, 0.7], [0.24, 0.95], [0.45, 1.0], [0.66, 0.9], [0.84, 0.64], [0.95, 0.36], [1.0, 0.12]],
-  // (long, widest past the middle, a rounded point toward the snout)
-  lop: [[0, 0.46], [0.08, 0.64], [0.24, 0.9], [0.46, 1.0], [0.66, 0.92], [0.84, 0.66], [0.95, 0.36], [1.0, 0.1]],
-};
-// root / facing: WORLD directions of the standing pig (left ear); rootH / facingH: the same in head-local
-// coordinates (x out, y dorsal, z along the head toward the disc; the head is carried HEAD_PITCH nose-down)
-export const EAR_FORM = {
-  // (splayed out ~36 deg from upright and a broader leaf, as in lw_show, face2, head_hausschwein5: at 29 deg
-  // and 0.38 wide they stood up like a rabbit's)
-  erect: { root: [0.58, 0.8, 0.2], len: 0.2, facing: [0.45, -0.4, 0.9], bend: 12, s0: 0.1, bendPow: 2, cup: [0.95, 0.28], width: 0.41, thick: [0.012, 0.0055], wave: 0, ns: 12, na: 10 },
-  // (up and out from the poll corner with the hollow forward, the outer part folding forward and down to hang
-  // beside the eye, the tips about level with the eyes: face3, Duroc photos; held out flat as brims)
-  semi: { root: [0.9, 0.0, 0.45], len: 0.235, facing: [0.1, -0.45, 1], bend: 45, s0: 0.4, bendPow: 1.2, sweep: 75, sweepS0: 0.2, sweepPow: 1.3, cup: [0.7, 0.35], width: 0.29, thick: [0.014, 0.0055], wave: 0, ns: 22, na: 10 },
-  // (forward from the poll corners along the head and angled out, then drooping over the eyes like a soft visor
-  // with air under it, the forehead showing between the two: Landrace photos; 0.68 as wide as long and
-  // rolled round the head, the two leaves covered the whole upper face like a helmet)
-  // (the root rising ~8 deg above level before the leaf droops (it left the poll 12 deg nose-down
-  // and lay along the forehead like a decal from the front 3/4; lr_heads: forward and level from the
-  // poll, then down over the eye))
-  lop: { rootH: [0.3, 0.55, 0.78], len: 0.22, facingH: [-0.5, -0.85, 0.15], bend: 95, s0: 0.3, bendPow: 1.5, cup: [0.45, 0.2], width: 0.28, thick: [0.015, 0.0055], wave: 0.015, ns: 14, na: 10 },
-};
-// (rig.js HEAD_PITCH: kept here as a number, rig.js imports this module)
-const HP = (35 * PI) / 180;
-const fromHead = (v) => [v[0], v[1] * Math.cos(HP) - v[2] * Math.sin(HP), v[1] * Math.sin(HP) + v[2] * Math.cos(HP)];
-const rootOf = (F) => (F.rootH ? fromHead(F.rootH) : F.root);
-const facingOf = (F) => (F.facingH ? fromHead(F.facingH) : F.facing);
-export const earType = (params) => (params.ear === 'lop' || params.ear === 'semi' ? params.ear : 'erect');
-export const earW = (type, t) => {
-  const W = OUTLINE[type];
-  for (let i = 1; i < W.length; i++) if (t <= W[i][0]) { const [t0, w0] = W[i - 1], [t1, w1] = W[i]; return w0 + ((w1 - w0) * (t - t0)) / (t1 - t0); }
-  return W[W.length - 1][1];
-};
-
-// the root direction of the left ear (world, standing) and the leaf length for this individual (the pinnae
-// carried more forward / more out, params.earFwd / earOut; params.earSize)
-// (params.earForm: overrides of the form's numbers, for tools)
-const formOf = (params) => (params.earForm ? { ...EAR_FORM[earType(params)], ...params.earForm } : EAR_FORM[earType(params)]);
-export function earRoot(params) {
-  const F = formOf(params);
-  const d = norm(rootOf(F));
-  return { dir: norm([d[0] + 0.25 * (params.earOut || 0), d[1], d[2] + 0.35 * (params.earFwd || 0)]), len: F.len * (params.earSize ?? 1) };
-}
-
-// the spine of one leaf: stations 0..steps from the root; per station the point and the leaf's frame: d along
-// the spine, h the hollow side, l across the leaf (l = d x h). The frame folds toward the hollow (`bend`
-// degrees in all from s0 on, bendPow > 1: late) and sweeps within the leaf's plane toward +l (`sweep`
-// degrees from sweepS0 on, sweepPow): a leaf held out sideways with its hollow forward that curves down as
-// it goes (face3) sweeps; one that tips over toward its hollow folds. (Left ear; mirrored for the right.)
-export function earSpine(base, S, params, steps = 96) {
-  const s = S === 'L' || S === 1 ? 1 : -1;
-  const type = earType(params);
-  const F = formOf(params);
-  const { dir, len } = earRoot(params);
-  const d0 = [dir[0] * s, dir[1], dir[2]];
-  const fc = facingOf(F);
-  const fw = [fc[0] * s, fc[1], fc[2]];
-  const f0 = norm(sub(fw, mul(d0, dot(fw, d0))));
-  const lat = norm(cross(d0, f0));
-  const B = (F.bend * PI) / 180, Bs = ((F.sweep || 0) * PI) / 180 * s, Bt = ((F.twist || 0) * PI) / 180 * s;
-  const ramp = (u, u0, p) => Math.pow(clamp01((u - u0) / (1 - u0)), p);
-  const foldAt = (u) => B * ramp(u, F.s0, F.bendPow);
-  const sweepAt = (u) => Bs * ramp(u, F.sweepS0 ?? F.s0, F.sweepPow ?? 1);
-  const twistAt = (u) => Bt * ramp(u, F.twistS0 ?? F.s0, F.twistPow ?? 1);
-  const pts = [base], fr = [{ d: d0, h: f0, l: lat }];
-  let o = base, d = d0, h = f0, l = lat;
-  for (let k = 1; k <= steps; k++) {
-    const u0 = (k - 1) / steps, u1 = k / steps;
-    const da = foldAt(u1) - foldAt(u0), db = sweepAt(u1) - sweepAt(u0), dt = twistAt(u1) - twistAt(u0);
-    const dPrev = d;
-    // fold: d toward h about l
-    { const c = Math.cos(da), sn = Math.sin(da); const d2 = add(mul(d, c), mul(h, sn)); h = sub(mul(h, c), mul(d, sn)); d = d2; }
-    // sweep: d toward l about h (the right ear sweeps the mirrored way: its l is the mirror's -l)
-    { const c = Math.cos(db), sn = Math.sin(db); const d2 = add(mul(d, c), mul(l, sn)); l = sub(mul(l, c), mul(d, sn)); d = d2; }
-    // twist: the leaf turns about its spine, h toward l (a lop ear's leaf turns from a visor over the eye to a
-    // flap hanging down the side of the face)
-    { const c = Math.cos(dt), sn = Math.sin(dt); const h2 = add(mul(h, c), mul(l, sn)); l = sub(mul(l, c), mul(h, sn)); h = h2; }
-    d = norm(d); h = norm(sub(h, mul(d, dot(h, d)))); l = cross(d, h);
-    o = add(o, mul(norm(add(dPrev, d)), len / steps));
-    pts.push(o);
-    fr.push({ d, h, l });
-  }
-  return { type, F, s, d0, f0, lat, pts, fr, L: len, W: F.width * len * (params.earWide ?? 1), steps, tip: o };
-}
-
-// the leaf: tiles for the sculpt, the mid-surface for tools, the outline points for the region box.
-// res: the quality tier's cell scale (params.tierRes): the leaf is at least 1.8 ear cells thick at every tier
-// (EAR_CELL x res, regions.js; a sheet thinner than that has both faces in one cell and meshes with rows of
-// pinholes: a 3.6 mm rim at the 3 mm hero cells did).
-// Each tile is a curved, tapered slab (core fin({ grad, curve })): its mid-surface a quadric fitted to 9
-// points of the leaf's mid-surface, its half thickness a plane fitted to its corners, so neighbouring tiles
-// meet with the same tangent plane and thickness (a smooth sheet: planar tiles showed a grid of facets).
-export function earLeaf(base, S, params) {
-  const sp = earSpine(base, S, params);
-  const { F, type, pts: spine, fr, steps: STEPS, W, L } = sp;
-  const res = params.tierRes ?? 1;
-  const tMin = (res >= 1.9 ? 2.3 : 1.8) * EAR_CELL * res; // (medium and below 2.3 cells: at 1.8 the round rim, thinner than a 6 mm cell, meshed scalloped like torn paper)
-  // (fractional stations: linear between the spine's 96 steps)
-  const at = (kf) => {
-    const k = Math.min(STEPS - 1, Math.max(0, Math.floor(kf))), f = kf - k, A = fr[k], Bf = fr[k + 1];
-    const h = norm(add(mul(A.h, 1 - f), mul(Bf.h, f))), l = norm(add(mul(A.l, 1 - f), mul(Bf.l, f)));
-    return { p: add(mul(spine[k], 1 - f), mul(spine[k + 1], f)), h, l };
-  };
-  // (a soft, slightly uneven rim: the half width wanders by F.wave along the leaf, three to four times, face3;
-  // the phase differs per side and individual)
-  const wph = ((params.coatSeed || 0) % 628) / 100 + (S === 'L' || S === 1 ? 0 : 2.1);
-  const half = (kf) => { const t = kf / STEPS; return Math.max(1e-4, earW(type, t) * W * (1 + (F.wave || 0) * Math.sin(2 * PI * 3.4 * t + wph) * sstep(0.1, 0.35, t))); };
-  const cupAt = (kf) => F.cup[0] + (F.cup[1] - F.cup[0]) * (kf / STEPS);
-  // mid-surface point and hollow-side normal at station kf (0..STEPS), across a (-1..1)
-  const P = (kf, a) => {
-    const { p, h, l } = at(kf), w = half(kf), kap = cupAt(kf) / w, x = a * w;
-    return add(add(p, mul(l, Math.sin(kap * x) / kap)), mul(h, (1 - Math.cos(kap * x)) / kap));
-  };
-  const Nrm = (kf, a) => {
-    const { h, l } = at(kf), w = half(kf), kap = cupAt(kf) / w, x = a * w;
-    return norm(add(mul(h, Math.cos(kap * x)), mul(l, -Math.sin(kap * x))));
-  };
-  // thickness (full, m): thick where the pinna leaves the head, thinning toward the tip and the edges
-  const thick = (u, a) => {
-    const tr = F.thick[0], te = F.thick[1];
-    const t = te + (tr - te) * (1 - sstep(0, 0.55, u)) * (1 - sstep(0.25, 1, Math.abs(a)));
-    return Math.max(t, tMin);
-  };
-  const NS = F.ns, NA = F.na;
-  const st = (i) => (i * STEPS) / NS;
-  const segs = [], outline = [base];
-  for (let i = 0; i < NS; i++) {
-    for (let j = 0; j < NA; j++) {
-      const a0 = -1 + (2 * j) / NA, a1 = -1 + (2 * (j + 1)) / NA, k0 = st(i), k1 = st(i + 1);
-      const Q = [P(k0, a0), P(k1, a0), P(k1, a1), P(k0, a1)];
-      const C = mul(add(add(Q[0], Q[1]), add(Q[2], Q[3])), 0.25);
-      const v = norm(sub(add(Q[1], Q[2]), add(Q[0], Q[3])));
-      let u = sub(add(Q[3], Q[2]), add(Q[0], Q[1]));
-      u = norm(sub(u, mul(v, dot(u, v))));
-      // (the fin's normal u x v points into the hollow: the coat reads the hollow side from it)
-      if (dot(cross(u, v), Nrm((k0 + k1) / 2, (a0 + a1) / 2)) < 0) u = mul(u, -1);
-      const n = cross(u, v);
-      const q2 = Q.map((q) => [dot(sub(q, C), u), dot(sub(q, C), v)]);
-      // the mid-surface over the tile: z = m0 + mu x + mv y + (muu x^2 + 2 muv x y + mvv y^2) / 2 (least squares, 9 points)
-      const rows = [], zs = [];
-      for (const kf of [k0, (k0 + k1) / 2, k1]) for (const a of [a0, (a0 + a1) / 2, a1]) {
-        const d = sub(P(kf, a), C), x = dot(d, u), y = dot(d, v);
-        rows.push([1, x, y, 0.5 * x * x, x * y, 0.5 * y * y]); zs.push(dot(d, n));
-      }
-      const curve = lsq(rows, zs);
-      // half thickness at the corners, fitted by a plane h0 + gu x + gv y
-      const hc = [thick(k0 / STEPS, a0), thick(k1 / STEPS, a0), thick(k1 / STEPS, a1), thick(k0 / STEPS, a1)].map((t) => t / 2);
-      const [h0, gu, gv] = lsq(q2.map(([x, y]) => [1, x, y]), hc);
-      // edges: Q0-Q1 the a0 side (the rim if j = 0), Q1-Q2 the tip side (the rim if last), Q2-Q3 the a1
-      // side (the rim if j = NA - 1), Q3-Q0 the root side (the first row runs into the head)
-      const hEdge = (c0, c1) => (hc[c0] + hc[c1]) / 2;
-      const ext = [j === 0 ? 0 : hEdge(0, 1), i === NS - 1 ? 0 : hEdge(1, 2), j === NA - 1 ? 0 : hEdge(2, 3), hEdge(3, 0)];
-      const poly = offsetPoly(q2, ext);
-      segs.push({ o: C, u, v, poly, t: 2 * h0, grad: [gu, gv], curve });
-      for (const [x, y] of poly) {
-        const z = curve[0] + curve[1] * x + curve[2] * y + 0.5 * (curve[3] * x * x + 2 * curve[4] * x * y + curve[5] * y * y);
-        outline.push(add(add(add(C, mul(u, x)), mul(v, y)), mul(n, z)));
-      }
-    }
-  }
-  // (mid-surface for tools: s 0..1, a -1..1)
-  const mid = (s, a) => ({ p: P(clamp01(s) * STEPS, a), n: Nrm(clamp01(s) * STEPS, a) });
-  return { base, along: norm(sub(sp.tip, base)), L, W, segs, pts: outline, mid, tip: sp.tip, type };
-}
-
-// least squares: argmin |A m - z| (normal equations, Gaussian elimination with partial pivoting)
-function lsq(A, z) {
-  const n = A[0].length;
-  const M = Array.from({ length: n }, () => new Array(n + 1).fill(0));
-  for (let r = 0; r < A.length; r++) for (let i = 0; i < n; i++) { for (let j = 0; j < n; j++) M[i][j] += A[r][i] * A[r][j]; M[i][n] += A[r][i] * z[r]; }
-  for (let c = 0; c < n; c++) {
-    let pr = c;
-    for (let r = c + 1; r < n; r++) if (Math.abs(M[r][c]) > Math.abs(M[pr][c])) pr = r;
-    [M[c], M[pr]] = [M[pr], M[c]];
-    const d = M[c][c] || 1e-30;
-    for (let r = 0; r < n; r++) if (r !== c) { const f = M[r][c] / d; for (let j = c; j <= n; j++) M[r][j] -= f * M[c][j]; }
-  }
-  return M.map((row, i) => row[n] / (row[i] || 1e-30));
-}
-
-// a convex polygon (2D) with each edge k pushed out by ext[k]
-function offsetPoly(q, ext) {
-  const n = q.length;
-  let area = 0;
-  for (let k = 0; k < n; k++) { const [x0, y0] = q[k], [x1, y1] = q[(k + 1) % n]; area += x0 * y1 - x1 * y0; }
-  const sg = area > 0 ? 1 : -1;
-  const lines = q.map((p, k) => {
-    const p1 = q[(k + 1) % n], dx = p1[0] - p[0], dy = p1[1] - p[1], l = Math.hypot(dx, dy) || 1;
-    return { px: p[0] + ((sg * dy) / l) * ext[k], py: p[1] - ((sg * dx) / l) * ext[k], dx: dx / l, dy: dy / l };
-  });
-  return q.map((_, k) => {
-    const A = lines[(k + n - 1) % n], B = lines[k], den = A.dx * B.dy - A.dy * B.dx;
-    if (Math.abs(den) < 1e-9) return [B.px, B.py];
-    const t = ((B.px - A.px) * B.dy - (B.py - A.py) * B.dx) / den;
-    return [A.px + A.dx * t, A.py + A.dy * t];
-  });
-}

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

@@ -1,161 +0,0 @@
-// Domestic pig (Sus scrofa domesticus). Cloven-hoofed (two main claws and two dew claws per foot,
-// on the cow's hoof-bone rig), a long fat barrel on short legs, the wedge head with the flat rostral
-// disc on its own bone, small deep-set eyes with round pupils and pale lashes, erect / semi / lop
-// ears per breed, and the corkscrew tail. Bare skin (material 4, subsurface-lit) under sparse
-// bristles. Seeded breeds (variants): Large White / Yorkshire (default), Landrace, Duroc, Hampshire,
-// Berkshire, spotted (Gloucester Old Spot / Pietrain).
-// Behaviours: rooting, sniffing with the disc, grunting, tail curling and wagging, flopping onto the
-// side to lie, the waddling trot, bouncing piglets; attack: a shoulder shove and bite, the boar's
-// upward tusk slash.
-import { pigRig, HEAD_O } from './rig.js';
-import { sculptPig, EYE } from './sculpt.js';
-import { pigRegions } from './regions.js';
-import { pigCoat } from './coat.js';
-import { srgb } from '../../core/build/coatKit.js';
-import { QUALITY } from '../../core/build/pipeline.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: withers height of an adult sow (boars ~5-10 % taller), ears, face, build
-// (a finisher of 0.72 m is the reference individual)
-const BREED = {
-  largewhite: { name: 'Large White / Yorkshire', h: [0.7, 0.9], ear: 'erect', dish: 0.35, snout: 1.0, length: 1.0, legs: 1.0, girth: 1.0, ham: 1.0, earSize: 1.0 },
-  landrace: { name: 'Landrace', h: [0.68, 0.88], ear: 'lop', dish: 0.0, snout: 1.1, length: 1.08, legs: 0.98, girth: 0.97, ham: 0.95, earSize: 1.05 },
-  duroc: { name: 'Duroc', h: [0.72, 0.92], ear: 'semi', dish: 0.25, snout: 1.0, length: 0.98, legs: 1.02, girth: 1.04, ham: 1.1, earSize: 0.95 },
-  hampshire: { name: 'Hampshire', h: [0.7, 0.88], ear: 'erect', dish: 0.15, snout: 1.02, length: 0.98, legs: 1.0, girth: 1.02, ham: 1.08, earSize: 0.9 },
-  berkshire: { name: 'Berkshire', h: [0.64, 0.82], ear: 'erect', dish: 0.9, snout: 0.86, length: 0.96, legs: 0.96, girth: 1.03, ham: 1.02, earSize: 0.9 },
-  spotted: { name: 'Spotted (Gloucester Old Spot)', h: [0.7, 0.88], ear: 'lop', dish: 0.2, snout: 1.0, length: 1.0, legs: 0.98, girth: 1.05, ham: 1.0, earSize: 1.0 },
-};
-const VARIANT_KEYS = Object.keys(BREED);
-
-export default {
-  id: 'pig',
-  name: 'Pig',
-  latin: 'Sus scrofa domesticus',
-  group: 'hooves',
-  plan: 'quadruped',
-  covering: 'skin',
-  variants: VARIANT_KEYS.map((id) => ({ id, name: BREED[id].name, latin: 'Sus scrofa domesticus' })),
-
-  // Seeded individual. opts.variant picks the breed (default Large White); sex: sow (teat row, a
-  // sagging belly with age) or boar (heavier shoulders and neck shield, visible small tusks, sheath
-  // and testes); age: adult (finisher to mature breeding stock) or juvenile (a piglet: big head and
-  // ears, short snout and body, fine hair, bouncy); size, build, ears, face, tail curl side, coat
-  // shade, mud, spots / belt / points.
-  variation(R0, o) {
-    const R = rng(Math.floor(R0() * 4294967296) ^ Math.imul(o.seed ?? 1, 0x9e3779b1) ^ 0x5bd1e995);
-    const variant = BREED[o.variant] ? o.variant : 'largewhite';
-    const B = BREED[variant];
-    const sex = o.sex || (R() < 0.6 ? 'female' : 'male');
-    const age = o.age || 'adult';
-    const piglet = age === 'juvenile';
-    const male = sex === 'male';
-    const g = () => (R() + R() + R() - 1.5) / 1.5; // ~[-1, 1], peaked
-    // maturity: 0 finisher (6 months) .. 1 mature breeding sow / boar
-    const mature = piglet ? 0 : Math.pow(R(), 1.4);
-    const boar = male && !piglet ? 0.5 + 0.5 * mature : 0;
-    const hRef = B.h[0] + (B.h[1] - B.h[0]) * mature;
-    // (piglet: a weaner of 4-10 weeks, 0.30-0.45 m at the withers, built like side1 / threequarter3: a long, rounded
-    // body with its underline tucked up, on thick straight legs, the head and ears still big; a newborn's
-    // shape at a weaner's size, 1.42-1.49 withers heights long on thin stilts)
-    const size = piglet ? (0.36 + 0.14 * R()) : (hRef / 0.74) * (male ? 1.06 : 1) * (1 + 0.03 * g()); // (0.74: the withers after the legs warp)
-    const belly = male || piglet ? 0.1 : 0.2 + 0.45 * mature * (0.6 + 0.4 * R());
-    // (a piglet's erect ears big and broad and held out to the sides, front1 / front2; its lop and semi-lop leaves
-    // only a little bigger for its size. The head warp enlarges the ears too, at no cost in vertices: the mesh is
-    // made in reference space, and 1.25 x 1.3 bigger leaves put a piglet over the vertex budgets)
-    const erect = B.ear === 'erect';
-    const earSize = B.earSize * (1 + 0.06 * g()) * (piglet ? (erect ? 1.12 : 1.02) : 1);
-    return {
-      variant, sex, age, size,
-      boar, mature,
-      belly,
-      fat: 1 + 0.04 * g() + 0.03 * mature,
-      ham: B.ham * (1 + 0.05 * g()) * (piglet ? 1.06 : 1),
-      ear: B.ear, earSize, earWide: piglet && erect ? 1.18 : 1, earFwd: 0.5 * g(), earOut: 0.6 * g() + (piglet && erect ? 0.6 : 0),
-      dish: B.dish * (0.8 + 0.4 * R()) + (piglet ? 0.1 : 0),
-      snoutLen: B.snout * (1 + 0.04 * g()) * (piglet ? 0.85 : 1),
-      tusks: male && !piglet ? 0.35 + 0.65 * mature * (0.7 + 0.3 * R()) : 0,
-      teats: R() < 0.5 ? 7 : R() < 0.7 ? 6 : 8,
-      tailSide: R() < 0.5 ? 1 : -1,
-      docked: false,
-      wrinkles: 0.3 + 0.5 * mature + (variant === 'berkshire' ? 0.2 : 0),
-      bristle: (1 + 0.15 * g()) * (male ? 1.2 : 1),
-      mud: R() < 0.35 ? 0.35 + 0.6 * R() : 0,
-      // Hampshire belt edges: the front one across the head behind the eyes (head-local z), the back one
-      // at mid-ribcage (bind z); coat.js says why
-      belt: [-0.055 + 0.012 * g(), 0.02 + 0.04 * g()],
-      blaze: 0.6 + 0.6 * R(), socks: 0.8 + 0.5 * R(),
-      spotCount: 5 + Math.floor(R() * 7), spotSize: 0.8 + 0.5 * R(),
-      coatShade: g(), coatLightness: 0.05 * g(),
-      coatSeed: Math.floor(R() * 1e6),
-      // thin parts (ears, the tail tip) at the coarse tiers: at least sqrt(3) cells thick (a slab
-      // thinner than that slips between the samples: rows of pinholes in the ears at medium)
-      minThick: 0.0027,
-      // (the quality tier's cell scale: the ear leaf's tiles overlap by the rim radius the core inflates them to)
-      tierRes: QUALITY[o.quality]?.res ?? 1,
-      warps: [
-        // (the head scale first: its centre is the unwarped head origin)
-        // (piglet, with its tucked-up underline, sculpt.js: snout -> buttock 1.72-1.82 withers heights, belly 0.45-0.47
-        // above the ground, head (disc -> ear base) 0.41-0.42, elbow 0.47, width 0.53: side1 1.73-1.76 / 0.47-0.49 /
-        // 0.43 / 0.48, a weaner 1.8-1.9 long, research 2; an earlier piglet measured 1.42-1.49 long, 0.46 wide, elbow 0.50)
-        { type: 'scaleAbout', c: HEAD_O, k: 1.13 * (1 + 0.03 * g()) * (piglet ? 1.24 : 1) * (male && !piglet ? 1.05 : 1), r0: 0.12, r1: 0.24 },
-        { type: 'legs', k: 1.06 * B.legs * (1 + 0.045 * g()) * (piglet ? 1.19 : 1), top: 0.36 },
-        { type: 'length', k: 0.95 * B.length * (1 + 0.045 * g()) * (piglet ? 1.16 : 1) * (1 + 0.03 * mature), z0: -0.42, z1: 0.3 },
-        { type: 'girth', k: B.girth * (1 + 0.06 * g()) * (piglet ? 0.95 : 1) * (1 + 0.04 * mature), cy: 0.52, z0: -0.55, z1: 0.36 },
-        ...(boar > 0 ? [{ type: 'girth', k: 1 + 0.07 * boar, cy: 0.55, z0: 0.12, z1: 0.5 }] : []),
-      ],
-    };
-  },
-  rig: (params) => pigRig(params),
-  sculpt: (m, rig, params) => sculptPig(m, rig, params),
-  regions: pigRegions,
-  coat: pigCoat,
-  eyeSpecs: (params) => [1, -1].map((side) => ({ side, spec: EYE, headOrigin: HEAD_O, bone: 'head', look: eyeLook(params) })),
-  motion,
-  // (a piglet's hair is finer and denser than a finisher's bristles: side1, threequarter3, front2 show a pale
-  // velvet over the skin, no single hairs. On the adult grid, 1.85 mm cells, a piglet's short hairs stacked
-  // every shell into one crisp speck: 6.6-9.5 % bright specks on a lit cheek; on a finer grid each
-  // hair is below a pixel from half a metre on and the shells draw their expected coverage, a haze)
-  // (and the Duroc's longer red-gold hair sparser, face3: individual hairs, not a fine speckle)
-  render: (params) => ({ ...RENDER, strandDensity: params && params.age === 'juvenile' ? PIGLET_STRANDS : params && params.variant === 'duroc' ? 3400 : RENDER.strandDensity }),
-};
-// (strands on a 12000 /m grid (piglets 13000): the shells draw a bristle 0.3 of its cell wide, and the hair
-// shader lights it darker than the wrapped skin near the terminator, so the 6000 grid's 0.25 mm hairs drew a dark
-// hatching over the face from half a metre; on the finer grid they fall below a pixel there and blend to a faint
-// haze, single pale hairs showing only up close and in the silhouette fins. skinScatter less red: the wrap past the
-// terminator tinted the pale skin brick; it is also the colour of the light through the ears, coat.js)
-const RENDER = { markColor: srgb(0x3a2a28), strandDensity: 12000, skinScatter: [0.86, 0.58, 0.52, 0.42], skinTrans: [0, 1], clumpDensity: 1, shellScale: 1, finWidth: 0.35, raiseLen: [0.02, 0.04] };
-const PIGLET_STRANDS = 13000;
-
-// Round pupil (slightly horizontally oval), brown iris (light amber to deep chocolate; a few blue),
-// sclera hidden, pink or dark lids.
-// (the amber iris read olive-green in the showcase's daylight; the photos show warm mid to dark brown)
-const IRISES = [
-  { inner: 0x3a2214, mid: 0x6a4026, hi: 0x8c5a36, outer: 0x24140c }, // brown
-  { inner: 0x4a2c16, mid: 0x7c4c2a, hi: 0x9c6a3e, outer: 0x2e1a0c }, // light brown
-  { inner: 0x1e120a, mid: 0x321e12, hi: 0x4c2e1c, outer: 0x120a06 }, // dark chocolate
-  { inner: 0x4a5a66, mid: 0x7a8c98, hi: 0x9aacb6, outer: 0x2e3840 }, // blue-grey
-];
-function eyeLook(params) {
-  const s = ((params.coatSeed || 0) % 100) / 100;
-  // (blue-grey only in the white breeds; a Duroc's blue-grey iris read milky in daylight)
-  const pinkBreed = !params.variant || params.variant === 'largewhite' || params.variant === 'landrace' || params.variant === 'spotted';
-  const ir = IRISES[s < 0.5 ? 0 : s < 0.75 ? 1 : s < 0.95 || !pinkBreed ? 2 : 3];
-  const dark = params.variant === 'berkshire' || params.variant === 'hampshire';
-  return {
-    pupil: 'round',
-    lids: 'mammal',
-    iris: { inner: srgb(ir.inner), mid: srgb(ir.mid), hi: srgb(ir.hi), outer: srgb(ir.outer) },
-    sclera: { color: [0.6, 0.55, 0.52], visible: false },
-    // (the Duroc's lids its red skin, coat.js COATS.red body #8A5846 in linear: the pink of the white
-    // breeds drew a pale lilac disc over the eye in a blink, in the shade under the ear)
-    lidColor: dark ? [0.06, 0.05, 0.05] : params.variant === 'duroc' ? [0.25, 0.1, 0.065] : [0.42, 0.22, 0.2],
-    pupilSize: [0.2, 0.42],
-  };
-}

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

@@ -1,105 +0,0 @@
-// Pig motion data for the quadruped engine (schema: src/core/motion/quadruped.js).
-// Numbers are for the reference individual (params.size = 1, a 0.72 m Large White finisher); the
-// engine scales them by dynamic similarity for piglets and big sows / boars.
-//
-// Gaits: lateral-sequence walk (Yucatan minipig and 100-113 kg
-// finishers: 1.0-1.7 Hz, duty 0.65 -> 0.55, the hind -> fore interval 0.25 -> 0.3 of the stride),
-// a diagonal trot (duty 0.45 -> 0.40, 2.0-2.4 Hz), walk -> trot at Froude ~0.45 (~1.6 m/s), and a
-// short transverse gallop (LH, RH, LF, RF) from ~3.5 m/s up to the domestic top speed of ~5 m/s
-// (Heglund et al. 1974: trot -> gallop 4.7 m/s at 2.3 Hz for 110 kg). Heavy pigs roll their trunk
-// from side to side when walking and trotting (the waddle: behaviour hook).
-import { behaviour } from './behaviour.js';
-
-const G = (name, v, f, D, off, o) => ({ name, v, f, D, off, ...o });
-// torso sections for a breed's leg length (legs warp k, top 0.36 m) and width factor w
-const bodyFor = (legs, w) => {
-  const dy = 0.36 * 1.06 * (legs - 1);
-  return {
-    chest: { y: 0.535 + dy, hh: 0.245, hw: 0.275 * w },
-    // (mid and rump measured on the body: barrel 0.199-0.209, rump 0.225-0.24 m; the barrel
-    // later widened to 0.21-0.22 over the ribs)
-    mid: { y: 0.53 + dy, hh: 0.26, hw: 0.215 * w },
-    pelvis: { y: 0.54 + dy, hh: 0.24, hw: 0.255 * w },
-    rump: { z: -0.47, y: 0.57 + dy, hh: 0.21, hw: 0.24 * w },
-    back: 0.05,
-  };
-};
-
-export const motion = {
-  maxSpeed: 5.2,
-  accel: [2.5, 4.5],
-  decel: 6,
-  // a heavy, stiff-backed animal: a walking turn of 0.7 body lengths radius (research 4: 0.5-1), a
-  // cornering limit of 0.3 g (2.2 / 6 were a dog's: 0.61 g, the gallop leaned 23 deg like a motorbike)
-  turnRate: 1.6,
-  latAccelMax: 3,
-  gears: { walk: 1.0, trot: 2.4, gallop: 4.4 },
-  gallopBlend: [3.4, 5.2],
-  //    name      v     f     D     [FL,   FR,   HL,  HR]
-  gaits: [
-    G('walk', 0.0, 0.95, 0.66, [0.25, 0.75, 0.0, 0.5], { liftF: 0.04, liftH: 0.035, bobF: 0.01, bobH: 0.01, flex: 0, lat: 0.03, fold: 0.7, heel: 26, tail: 0, drop: 0 }),
-    G('walk', 1.3, 1.55, 0.56, [0.3, 0.8, 0.0, 0.5], { liftF: 0.05, liftH: 0.045, bobF: 0.018, bobH: 0.018, flex: 0, lat: 0.04, fold: 0.85, heel: 36, tail: 0.1, drop: 0 }),
-    G('trot', 1.7, 1.95, 0.46, [0.52, 0.02, 0.0, 0.5], { liftF: 0.065, liftH: 0.055, bobF: 0.022, bobH: 0.022, flex: 0.008, lat: 0.0, fold: 1.0, heel: 45, tail: 0.3, drop: 0.004 }),
-    G('trot', 3.2, 2.35, 0.4, [0.52, 0.02, 0.0, 0.5], { liftF: 0.08, liftH: 0.07, bobF: 0.028, bobH: 0.028, flex: 0.012, lat: 0.0, fold: 1.1, heel: 50, tail: 0.4, drop: 0.008 }),
-    G('gallop', 3.6, 2.45, 0.34, [0.55, 0.65, 0.0, 0.12], { liftF: 0.09, liftH: 0.08, bobF: 0.02, bobH: 0.028, flex: 0.06, lat: 0, fold: 1.2, heel: 45, tail: 0.6, drop: 0.012 }),
-    G('gallop', 5.2, 2.75, 0.29, [0.56, 0.66, 0.0, 0.12], { liftF: 0.1, liftH: 0.09, bobF: 0.022, bobH: 0.032, flex: 0.08, lat: 0, fold: 1.3, heel: 40, tail: 0.8, drop: 0.02 }),
-  ],
-  feet: {
-    // on the tips of the two main claws, fairly upright pasterns: the fetlock sinks a little under
-    // load, the claws flip in swing
-    front: { type: 'unguligrade', contact: 0.9, curl: 62, flex: 4, sink: 10, hoofFlex: 16, swingBack: 0.04 },
-    hind: { type: 'unguligrade', contact: 0.9, curl: 62, flex: 4, sink: 9, hoofFlex: 16, swingBack: 0.015 },
-  },
-  stance: { width: 1, gallopWidth: 0.85, sprawl: 0, crouch: 0, scuff: [10, 20, 0] },
-  // torso cross-sections (bind pose, reference size): centre height, half height, half width
-  // (measured on the bind mesh at the girdles, shoulder and thigh muscles included: tools sec.mjs)
-  body: bodyFor(1, 1),
-
-
-  head: {
-    // [speed, raise (m), reach (m), pitch (rad, + = nose down)]: low and forward, the snout near the
-    // ground at the walk (side3, side4_walk, research 3), a little higher at the trot, stretched forward
-    // when galloping
-    carriage: [[0, 0, 0, 0], [1.0, -0.08, 0.03, 0.25], [2.4, -0.02, 0.03, 0.04], [4.4, -0.02, 0.05, 0.0]],
-    stab: [[0, 0], [1.0, 0.15], [2.4, 0.35], [4.4, 0.3]],
-    neckBend: 22, neckPivot: 0.5, yaw: 0.7, pitchUp: 0.5, pitchDown: 0.7, mouth: 'jawTip',
-  },
-  tail: {
-    // [speed, pitch per segment from horizontal (deg), root -> tip]: the curled carriage (rig.js);
-    // the behaviour hook adds the helix yaw and uncurls it when the pig rests or is afraid
-    carriage: [
-      [0.0, [14, -6, -24, -30, -32, -32, -32, -32, -32, -32]],
-      [2.4, [18, -2, -20, -27, -30, -30, -30, -30, -30, -30]],
-      [4.4, [24, 6, -12, -22, -26, -28, -28, -28, -28, -28]],
-    ],
-    stiffness: 1.6, sway: 3, flick: 0, wag: 0, swish: 0, curl: 0, balance: 0,
-    radius: [0.012, 0.006],
-  },
-  ears: { rest: [0, 0], mobility: 0.8, speedFlatten: 0.15, twitch: 1.0, prick: 0.35 },
-  breath: { rate: 0.35, amp: 0.008, pant: false, pantRate: 2.2, pantAmp: 0.015, heatSpeed: 5 },
-  actions: {
-    // rooting: the snout goes down to the ground in front of the forefeet (behaviour: nudges)
-    eat: { style: 'graze', dropF: 0.06, dropH: 0, pitch: 0.95, ahead: 0.55 },
-    drink: { dropF: 0.06, dropH: 0, pitch: 0.95, ahead: 0.55 },
-    // poor jumpers: a low scrambling hop (research 4: they step or scramble over 0.3-0.5 m at most; the
-    // body rises ~0.2 m, 0.4 s in the air; 0.42 m floated a 120 kg pig over its own withers height)
-    jump: { height: 0.16, distance: 0.8, land: [0.24, 0.2] },
-    sit: { dropH: 0.85 },
-    // kneels on both carpi first, then drops the hindquarters, then flops onto the side
-    lie: { style: 'lateral', down: 'front', up: 'front' },
-    wallow: { style: 'lateral', down: 'front', up: 'front' },
-    sleep: { style: 'lateral', down: 'front', up: 'front' },
-    fold: { front: { z: -0.18, k: 1.45, beta: 0.9 } },
-    idle: { shift: 0.7 },
-  },
-  // per breed: the torso sits lower on shorter legs (the legs warp, index.js BREED) and the
-  // heavier-hammed breeds rest on wider sections (a body lying on its side)
-  variants: {
-    landrace: { body: bodyFor(0.98, 1) },
-    duroc: { body: bodyFor(1.02, 1.07) },
-    hampshire: { body: bodyFor(1, 1.05) },
-    berkshire: { body: bodyFor(0.96, 1.03) },
-    spotted: { body: bodyFor(0.98, 1.04) },
-  },
-  hooks: behaviour,
-};

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

@@ -1,100 +0,0 @@
-// Meshing plan: body at 7.8 mm (1.1 % of the withers height: the barrel's skin area is ~1.6x the
-// cheetah's), the face at 4.1 mm overlapping the body just behind the eyes and cross-faded, the feet
-// below mid-cannon at 3.5 mm (the cleft and the dew claws read), eyelid patches at 0.9 mm, and
-// separate surfaces: the lower jaw (lower lip, chin; rigid), the boar's tusks (1.2 mm, rigid on the jaw), the ears (rigid on the
-// ear bones, their thick roots buried in the head) and the corkscrew tail (its own skinned surface at
-// 2 mm, the root buried in the rump).
-//
-// Seams. The skinning relaxes the axial coordinate and solves the limb fields over each surface
-// separately, so two overlapping surfaces agree only where the weights do not depend on the
-// surface: the face cut lies in front of the jowls (the jowls touch the shoulders, and the body's
-// limb field reached into them while the head surface had no limb at all: the neck cracked open
-// when the head went down), the foot cut on the rigid cannon; the overlaps run on well past the
-// fade line (M), since the relaxation is one-sided next to a surface's open edge.
-import { EYE, earShape, tuskCones } from './sculpt.js';
-import { EAR_CELL } from './ears.js';
-import { HEAD_O, HZ, hl } from './rig.js';
-import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
-import { smoothstep, norm } from '../../core/math/vec.js';
-
-// The face is cut off across the head behind the eyes: below the eye line by a plane slanting forward
-// to the throat (in front of the jowls, see above), above it by a plane across the head axis 5 cm behind
-// the eyes. The upper plane keeps the switch line in front of the poll: behind it (the slanted plane
-// alone reached 16 cm back there, behind the occiput) both surfaces carry ~25 % neck2 weight, relaxed
-// differently on each, and they parted by up to 6 mm when the head lay on its side (lie, sleep, death).
-// Here both carry the head bone alone. (smooth minimum of the two signed distances, k 2 cm)
-export const NECK_CUT = { c: hl([0, 0, -0.035]), d: norm([0, 0.4, 1]), top: hl([0, 0, -0.05]), band: 0.012 };
-export const neckS = (x, y, z) => {
-  const a = (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];
-  const b = (y - NECK_CUT.top[1]) * HZ[1] + (z - NECK_CUT.top[2]) * HZ[2];
-  const k = 0.02, h = Math.min(1, Math.max(0, 0.5 + (0.5 * (b - a)) / k));
-  return b + (a - b) * h - k * h * (1 - h);
-};
-// feet: below mid-cannon
-export const FOOT_CUT = { y: 0.105, band: 0.007 };
-
-export const EYE_PATCH = { R: 0.023, B: 0.003, h: 0.0009, centres: [1, -1].map((s) => eyeFrameOf(EYE, HEAD_O, s).c) };
-export function eyePatchWeight(x, y, z) {
-  let dmin = 1e9;
-  for (const c of EYE_PATCH.centres) dmin = Math.min(dmin, Math.hypot(x - c[0], y - c[1], z - c[2]));
-  return 1 - smoothstep(EYE_PATCH.R - EYE_PATCH.B, EYE_PATCH.R + EYE_PATCH.B, dmin);
-}
-
-function boxOf(pts, pad) {
-  const mn = [1e9, 1e9, 1e9], mx = [-1e9, -1e9, -1e9];
-  for (const p of pts) for (let i = 0; i < 3; i++) { mn[i] = Math.min(mn[i], p[i] - pad); mx[i] = Math.max(mx[i], p[i] + pad); }
-  return [mn, mx];
-}
-
-export function pigRegions(rig, params, Q) {
-  // (the cross-fade bands are wider than the coarser surface's cells at every tier)
-  const r = Q.res, B = NECK_CUT.band * (0.6 + 0.4 * r), FB = FOOT_CUT.band * (0.3 + 0.7 * r), FY = FOOT_CUT.y;
-  const J = rig.J;
-  // eyelid patches at hero / high (0.9 / 1.2 mm) and, the pig's own, at medium (1.8 mm): the lids of the
-  // 22 x 12 mm aperture meshed at the medium head cells (8.6 mm) came out as a jagged notch (Safari, phones)
-  const patches = Q.eyePatches || r <= 2 ? EYE_PATCH.centres.map((c) => ({ c, R: EYE_PATCH.R, B: EYE_PATCH.B * Math.max(1, r), h: r > 1.5 ? 0.0021 : EYE_PATCH.h * Math.max(1, r) })) : [];
-  const crowd = r >= 4;
-  const hBody = 0.0078 * r, hHead = 0.0041 * r * (1 + 0.05 * (r - 1)), hFeet = 0.0035 * (crowd ? 4.2 : Math.min(r, 2.4));
-  // overlapping surfaces sample the field on the same coarse spacing as the body (F x h ~ 4 body
-  // cells): the primitive lists a vertex is skinned from are then culled alike on both sides
-  const Fof = (h) => Math.max(3, Math.round((4 * hBody) / h));
-  const M = Math.min(3.5 * hBody, 0.04);
-  const tailPts = [J.tailBase];
-  for (let i = 1; i <= 10; i++) if (J['tail' + i]) tailPts.push(J['tail' + i]);
-  const [tmin, tmax] = boxOf(tailPts, 0.025);
-  const [hmin, hmax] = boxOf([J.nose, J.jawHinge, J.jawTip, hl([0, 0.1, -0.05]), hl([0.12, -0.15, -0.05]), hl([-0.12, -0.15, -0.05])], 0.06);
-  const ear = (S, h, F) => { const [bmin, bmax] = boxOf(earShape(J, params, S).pts, 0.05); return { name: 'ear' + S, part: 'ear' + S, bmin, bmax, h, F, rigidBone: 'ear' + S }; };
-  // the boar's tusks: a small rigid surface each at 1.2 mm (x res), their roots buried in the lower lip (in the jaw's
-  // 3 mm cells the 1.2-7 mm cone meshed as a crumpled blade)
-  const tusks = (params.tusks || 0) > 0.05 ? [1, -1].map((s) => {
-    const pts = []; for (const c of tuskCones(params, s)) pts.push(c.a, c.b);
-    const [bmin, bmax] = boxOf(pts, 0.012);
-    return { name: s > 0 ? 'tuskL' : 'tuskR', part: 'tusk', bmin, bmax, h: 0.0012 * r, F: 3, rigidBone: 'jaw' };
-  }) : [];
-  return {
-    jobs: [
-      [{ name: 'body', part: 'body', bmin: [-0.3, Math.max(-0.01, FY - FB - M - hBody), -0.72], bmax: [0.3, 0.84, 0.8], h: hBody, F: 4, clip: (x, y, z) => neckS(x, y, z) < B + M && y > FY - FB - M }],
-      [
-        { name: 'head', part: 'body', bmin: hmin, bmax: hmax, h: hHead, F: Fof(hHead), clip: (x, y, z) => neckS(x, y, z) > -B - M, patches },
-        { name: 'jaw', part: 'jaw', bmin: [-0.1, 0.3, 0.5], bmax: [0.1, 0.62, 0.84], h: 0.003 * r * (r > 2 ? 0.8 : 1), F: 6, rigidBone: 'jaw' },
-        // (the leaves are at least 1.8 of these cells thick at every tier, ears.js)
-        ear('L', EAR_CELL * r, 3), ear('R', EAR_CELL * r, 3),
-        ...tusks,
-      ],
-      [
-        { name: 'feet', part: 'body', bmin: [-0.16, -0.01, -0.45], bmax: [0.16, FY + FB + M + hFeet, 0.45], h: hFeet, F: Fof(hFeet), clip: (x, y, z) => y < FY + FB + M },
-        { name: 'tail', part: 'tail', bmin: tmin, bmax: tmax, h: 0.002 * Math.min(r, 3.6), F: 3 },
-      ],
-    ],
-    fade(x, y, z, name, patch) {
-      if (name === 'body') return (1 - smoothstep(-B, B, neckS(x, y, z))) * smoothstep(FY - FB, FY + FB, y);
-      if (name === 'feet') return 1 - smoothstep(FY - FB, FY + FB, y);
-      if (name === 'head') {
-        let f = smoothstep(-B, B, neckS(x, y, z));
-        if (patches.length) { const ew = eyePatchWeight(x, y, z); f *= patch ? ew : 1 - ew; }
-        return f;
-      }
-      return 1;
-    },
-  };
-}