@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

package/vendor/procedural-animals/src/species/crow/coat.js

@@ -0,0 +1,145 @@
+// The crow's plumage and bare parts, baked per vertex: contour-feather shingles (material 9) with a
+// blue-violet structural gloss on the back, wings and tail and a matter head and underside, a short
+// down haze (shells), forward-pointing nasal bristles, a black keratin bill and claws, scaled black
+// tarsi and toes, and a dark eye ring. Colours sampled from the reference photos. Seeded
+// variation shifts gloss and wear (brownish worn feathers) and the morph (American / carrion / hooded).
+import { SDFModel } from '../../core/sdf/sdf.js';
+import { norm, sub, dot, cross, add, mul, clamp, smoothstep, mix, fbm3 } from '../../core/math/vec.js';
+import { srgb, mix3, MAT } from '../../core/build/coatKit.js';
+import { HEAD_O } from './rig.js';
+
+export function crowColours(p = {}) {
+  const wear = p.wear || 0, morph = p.morph || 'american';
+  const black = srgb(0x131316), matte = srgb(0x19191d), worn = srgb(0x2a2420);
+  const tint = (c) => mix3(c, worn, wear * 0.35);
+  return {
+    body: tint(black), under: tint(matte), head: tint(srgb(0x151518)),
+    grey: srgb(0x8c8c8a), greyUnder: srgb(0x9a9a98),
+    bill: srgb(0x141414), leg: srgb(0x17171a), claw: srgb(0x0e0e10), ring: srgb(0x1c1b1d),
+    // adult mouth lining dark grey (research); juveniles show a pink gape
+    gape: p.age === 'juvenile' ? srgb(0xb87c78) : srgb(0x2a2a2e), juvGape: p.age === 'juvenile', hooded: morph === 'hooded',
+    irid: (morph === 'carrion' ? 0.45 : 0.55) * (p.gloss ?? 1) * (1 - 0.5 * wear),
+  };
+}
+
+export function crowCoat(ctx) {
+  const { model, rig, pos, nrm, regionOf, regionNames, weights, nV, params } = ctx;
+  const { BONES, J } = rig;
+  const C = crowColours(params);
+  const comb = new Float32Array(nV * 3), tint = new Float32Array(nV * 4), surf = new Float32Array(nV * 4);
+  const furLen = new Float32Array(nV), mark = new Float32Array(nV).fill(1), pattern = new Float32Array(nV).fill(1);
+  const boneName = BONES.map((b) => b.name);
+  const tagged = (t) => model.prims.filter((p) => p.tag === t);
+  const billP = tagged('bill'), bristleP = tagged('bristles'), mandP = model.forPart('jaw');
+  const eyeP = tagged('eyesocket'), clawP = tagged('claw'), tarsusP = [...tagged('tarsus'), ...tagged('toe'), ...tagged('pad'), ...tagged('shank')];
+  const minD = (list, p) => { let d = 1e9; for (const q of list) d = Math.min(d, SDFModel.dist(q, p[0], p[1], p[2])); return d; };
+  const H = HEAD_O;
+  const axialPts = rig.AXIAL.points;
+  // flow along the body axis (bill -> tail) at the nearest axial segment
+  const axialDir = (p) => {
+    let best = 1e9, dir = [0, 0, -1];
+    for (let i = 0; i < axialPts.length - 1; i++) {
+      const a = axialPts[i], b = axialPts[i + 1], ab = sub(b, a), l2 = dot(ab, ab);
+      const t = clamp(dot(sub(p, a), ab) / l2, 0, 1);
+      const q = add(a, mul(ab, t)), d = Math.hypot(p[0] - q[0], p[1] - q[1], p[2] - q[2]);
+      if (d < best) { best = d; dir = norm(ab); }
+    }
+    return dir;
+  };
+  for (let v = 0; v < nV; v++) {
+    const p = [pos[v * 3], pos[v * 3 + 1], pos[v * 3 + 2]], n = [nrm[v * 3], nrm[v * 3 + 1], nrm[v * 3 + 2]];
+    const bn = boneName[weights.dominant[v]] || '';
+    const region = regionNames[regionOf[v]];
+    let col = C.body, mat = MAT.FEATHER, fl = 0.0035, gloss = 0.55, size = 0.012, irid = C.irid;
+    let flow = axialDir(p);
+    const h = [p[0] - H[0], p[1] - H[1], p[2] - H[2]];
+    const up = n[1];
+    if (region === 'jaw' || bn === 'jaw') {
+      mat = MAT.KERATIN; col = C.bill; fl = 0; gloss = 0.5; size = 0; irid = 0;
+      flow = [0, 0, 1];
+      const dh = minD(billP, p);
+      if (dh < 0.0006 && h[2] < 0.06) { mat = C.juvGape ? MAT.DARK_SKIN : MAT.KERATIN; col = C.gape; gloss = 0.2; }
+    } else if (bn === 'head' || region === 'head') {
+      col = C.head; size = 0.006; irid = C.irid * 0.35; gloss = 0.45; fl = 0.0022;
+      flow = norm([0, -0.25, -1]);
+      if (Math.abs(h[0]) > 0.006) flow = norm([h[0] * 8, -0.3, -1]);
+      const db = minD(billP, p), dbr = minD(bristleP, p), dm = minD(mandP, p);
+      if (db < 0.0004 && h[2] > 0.028) { mat = MAT.KERATIN; col = C.bill; fl = 0; gloss = 0.55; irid = 0; flow = [0, 0, 1]; }
+      else if (dbr < 0.0012 && h[2] > 0.02) {
+        // nasal bristles: stiff forward-pointing feathers over the nostrils
+        mat = MAT.FUR; col = C.head; fl = 0.0035; flow = norm([h[0] * 2, -0.05, 1]); irid = 0;
+      } else if (dm < 0.001 && h[2] > 0.02) { mat = C.juvGape ? MAT.DARK_SKIN : MAT.KERATIN; col = C.gape; fl = 0; gloss = 0.2; irid = 0; }
+      // eye ring (bare dark skin right at the lid margin)
+      for (const e of eyeP) {
+        const de = SDFModel.dist(e, p[0], p[1], p[2]);
+        if (Math.abs(de) < 0.0009) { mat = MAT.DARK_SKIN; col = C.ring; fl = 0; }
+        else if (Math.abs(de) < 0.0025) { fl = Math.min(fl, 0.0008); size = 0.003; }
+      }
+      if (h[2] > 0.018) size = 0.0035;
+    } else if (/^(tarsus|toe)/.test(bn) || (bn.startsWith('tibia') && minD(tarsusP, p) < 0.0008)) {
+      mat = MAT.SCALES; col = C.leg; fl = 0; gloss = 0.35; size = 0.0022; irid = 0;
+      flow = [0, -1, 0];
+      if (minD(clawP, p) < 0.0004) { mat = MAT.KERATIN; col = C.claw; gloss = 0.65; size = 0; }
+      if (/^toe/.test(bn)) { const b = BONES[weights.dominant[v]]; flow = norm(sub(b.tail, b.head)); }
+    } else if (bn.startsWith('tibia') || bn.startsWith('femur')) {
+      // feathered "trousers": soft, matte, pointing down the leg
+      col = C.under; fl = 0.004; size = 0.008; irid = C.irid * 0.2; gloss = 0.4;
+      flow = [0, -1, -0.2];
+    } else if (/^(humerus|ulna|hand)/.test(bn)) {
+      // wing coverts: lie toward the trailing edge, glossy on top
+      const b = BONES[weights.dominant[v]];
+      const d = norm(sub(b.tail, b.head));
+      let wn = norm(cross(sub(J[b.side === 'R' ? 'elbowR' : 'elbowL'], J[b.side === 'R' ? 'shoulderR' : 'shoulderL']), sub(J[b.side === 'R' ? 'wristR' : 'wristL'], J[b.side === 'R' ? 'elbowR' : 'elbowL'])));
+      if (wn[1] < 0) wn = mul(wn, -1);
+      const s = b.side === 'R' ? -1 : 1;
+      flow = mul(norm(cross(wn, d)), s);
+      size = 0.009; fl = 0.0025;
+      const top = dot(n, wn);
+      if (top < 0) { col = C.under; irid = C.irid * 0.25; }
+    } else {
+      // body: glossy back and mantle, matte breast and belly
+      const dorsal = smoothstep(-0.2, 0.5, up);
+      col = mix3(C.under, C.body, dorsal);
+      irid = C.irid * mix(0.2, 0.7, dorsal) * mix(0.45, 1, dorsal); // underparts ~0.3x the back
+      gloss = mix(0.22, 0.6, dorsal); // matte underparts
+      size = p[1] > 0.2 && p[2] > 0.03 ? 0.008 : 0.012;
+      fl = mix(0.004, 0.003, dorsal);
+      if (C.hooded) {
+        // hooded crow: grey mantle, back, breast and belly; black head, bib, wings and tail
+        // (soft edges: the black bib ends in a rounded line on the upper breast, the grey fades into
+        // the black rump and undertail)
+        const bib = smoothstep(0.17, 0.2, p[1] + 0.25 * Math.max(0, p[2] - 0.03)) * smoothstep(0.03, 0.06, p[2]);
+        const gw = (1 - bib) * smoothstep(-0.105, -0.08, p[2]);
+        if (gw > 0) { col = mix3(col, mix3(C.greyUnder, C.grey, dorsal), gw); irid = mix(irid, 0.05, gw); }
+      }
+      // flow: along the body, bending around the flanks and down the breast
+      if (bn === 'chest' && p[2] > 0.04 && up < 0.2) flow = norm(add(flow, [0, -0.8, 0]));
+    }
+    // low-frequency variation (wear, sheen patches)
+    const cv = fbm3(p[0] * 40, p[1] * 40, p[2] * 40, 3) - 0.5;
+    col = [col[0] * (1 + 0.1 * cv), col[1] * (1 + 0.1 * cv), col[2] * (1 + 0.08 * cv)];
+    // comb: tangent to the surface
+    const f = sub(flow, mul(n, dot(flow, n)));
+    const fN = norm(Math.hypot(...f) > 1e-6 ? f : cross(n, [1, 0, 0]));
+    comb.set(fN, v * 3);
+    tint[v * 4] = col[0]; tint[v * 4 + 1] = col[1]; tint[v * 4 + 2] = col[2]; tint[v * 4 + 3] = mat;
+    furLen[v] = fl;
+    surf[v * 4] = gloss; surf[v * 4 + 1] = size; surf[v * 4 + 2] = 0; surf[v * 4 + 3] = mat === MAT.FEATHER ? irid : 0;
+  }
+  return { comb, tint, pattern, mark, furLen, surf, patternColor: new Float32Array(nV * 4) };
+}
+
+// flight-feather card colours: glossy black, iridescent on top, greyer and matte beneath
+export function crowFeatherColour(params) {
+  const C = crowColours(params);
+  return (kind, i, side, t, c, layer) => {
+    const top = layer > 0;
+    const covert = kind.endsWith('Covert');
+    let rgb = top ? C.body : mix3(C.under, srgb(0x2a2a30), 0.35);
+    // primaries: the inner vane is a little duller (hidden under the next feather at rest)
+    if (kind === 'primary' && c > 0.3) rgb = mix3(rgb, C.under, 0.3);
+    if (C.hooded && covert && kind !== 'tailCovert') rgb = top ? C.body : C.under;
+    const k = 1 + 0.06 * Math.sin(i * 12.9898 + side * 3.1 + t * 2.1);
+    return { rgb: [rgb[0] * k, rgb[1] * k, rgb[2] * k], gloss: top ? 0.5 : 0.1, irid: top ? C.irid * (covert ? 0.7 : 0.5) : 0 };
+  };
+}

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

@@ -0,0 +1,70 @@
+// Crow (American crow Corvus brachyrhynchos; carrion crow C. corone and hooded crow C. cornix as
+// variants). The proving species of the bird body plan (core/motion/bird.js).
+import { crowRig, HEAD_O } from './rig.js';
+import { sculptCrow, EYE } from './sculpt.js';
+import { crowRegions } from './regions.js';
+import { crowCoat, crowFeatherColour } from './coat.js';
+import { motion, WING, FEATHERS } from './motion.js';
+import { featherCards } from '../../core/build/featherCards.js';
+import { srgb } from '../../core/build/coatKit.js';
+
+export default {
+  id: 'crow',
+  name: 'Crow',
+  latin: 'Corvus brachyrhynchos',
+  group: 'birds',
+  plan: 'bird',
+  covering: 'feathers',
+  variants: [
+    { id: 'american', name: 'American crow', latin: 'Corvus brachyrhynchos' },
+    { id: 'carrion', name: 'Carrion crow', latin: 'Corvus corone' },
+    { id: 'hooded', name: 'Hooded crow', latin: 'Corvus cornix' },
+  ],
+
+  // Seeded individual. No plumage dimorphism; males ~5 % larger (wing, bill). Juveniles are adult-sized
+  // at fledging but duller, fluffier and blue-grey eyed with a shorter tail. Individuals differ in size,
+  // bill length and depth, leg length, head size, gloss and feather wear (brownish in summer).
+  // Variants: 'american' (default), 'carrion' (greener gloss, heavier bill), 'hooded' (grey body).
+  variation(R, o) {
+    const sex = o.sex || (R() < 0.5 ? 'male' : 'female');
+    const age = o.age || 'adult';
+    const juv = age === 'juvenile';
+    const g = () => (R() + R() + R() - 1.5) / 1.5;
+    const morph = o.variant || (R() < 0.75 ? 'american' : 'carrion');
+    const size = (sex === 'male' ? 1.03 : 0.97) * (1 + 0.045 * g()) * (juv ? 0.95 : 1) * (morph === 'american' ? 1 : 1.06);
+    const bill = (morph === 'carrion' ? 1.06 : 1) * (1 + 0.06 * g()) * (sex === 'male' ? 1.03 : 1);
+    return {
+      sex, age, size, morph, variant: morph,
+      warps: [
+        { type: 'legs', k: 1 + 0.04 * g(), top: 0.12 },
+        // bill length / depth about the bill base
+        { type: 'scaleAbout', c: [0, 0.292, 0.135], k: bill, r0: 0.03, r1: 0.06 },
+        { type: 'scaleAbout', c: HEAD_O, k: (1 + 0.03 * g()) * (juv ? 1.06 : 1), r0: 0.03, r1: 0.06 },
+        { type: 'girth', k: 1 + 0.05 * g() + (juv ? 0.05 : 0), cy: 0.16, z0: -0.08, z1: 0.1, fade: 0.04 },
+      ],
+      wear: Math.max(0, 0.25 * g() + (juv ? 0.4 : 0.1)),
+      gloss: 1 + 0.12 * g() - (juv ? 0.4 : 0),
+      tailK: juv ? 0.88 : 1 + 0.03 * g(),
+    };
+  },
+  rig: () => crowRig(),
+  sculpt: (m, rig) => sculptCrow(m, rig),
+  regions: crowRegions,
+  coat: crowCoat,
+  surfaces: (ctx) => featherCards({ ...ctx, wing: WING, feathers: FEATHERS, tail: { bindFan: 0.2 }, colour: crowFeatherColour(ctx.params) }),
+  eyeSpecs: (params) => [1, -1].map((side) => ({ side, spec: EYE, headOrigin: HEAD_O, bone: 'head', look: params.age === 'juvenile' ? EYE_JUV : EYE_LOOK })),
+  motion,
+  // featherEdge: faint shingle outlines (photos show a smooth sheen, not scaled feathers)
+  render: { markColor: srgb(0x121214), strandDensity: 900, clumpDensity: 1.4, shellScale: 1, finWidth: 0.3, featherEdge: 0.4 },
+};
+
+// Round pupil, dark brown iris (reads black at distance), bird lids with a nictitating membrane.
+export const EYE_LOOK = {
+  pupil: 'round',
+  lids: 'bird',
+  iris: { inner: srgb(0x120c09), mid: srgb(0x2a1e18), hi: srgb(0x4a3526), outer: srgb(0x100b09) },
+  sclera: { visible: false, color: [0.02, 0.02, 0.02] },
+  lidColor: srgb(0x1c1b1d),
+  pupilSize: [0.36, 0.52],
+};
+export const EYE_JUV = { ...EYE_LOOK, iris: { inner: srgb(0x3a4450), mid: srgb(0x7d8ca0), hi: srgb(0xa6b3c2), outer: srgb(0x3c4552) } };

package/vendor/procedural-animals/src/species/crow/joints.js

@@ -0,0 +1,3 @@
+// Reference-pose joints of the crow (see rig.js), exported for modules that need fixed landmarks.
+import { crowJoints } from './rig.js';
+export const J = crowJoints();

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

@@ -0,0 +1,101 @@
+// Crow motion data for the bird engine (schema: src/core/motion/bird.js). Numbers are for the
+// reference individual (params.size = 1: ~450 g American crow, 44 cm bill to tail, span 0.92 m);
+// the engine scales them by dynamic similarity.
+//
+// Ground: crows WALK with alternating steps (stately gait, head bobbing each step, tail swinging) and
+// HOP (both feet together) when hurrying, before take-off and to turn round [research 4, 5].
+// Flight: steady rowing flight, 3.84 Hz at 10.5 m/s (hooded crow, Pennycuick 2001), amplitude
+// ~100 deg, flexed-wing upstroke; take-off beats faster (~6 Hz) and deeper (~140 deg); short glides
+// (<= 2-3 s); landing: swoop, pitch up 40-70 deg, braking beats with the wings raised high, tail
+// fanned and depressed, legs forward.
+const G = (name, v, f, D, off, o) => ({ name, v, f, D, off, ...o });
+
+export const WING = {
+  // humerus, ulna, hand (carpometacarpus + digit II) in metres
+  lengths: [0.067, 0.078, 0.058],
+  // degrees: elev (+ tip up), pitch (+ leading edge up), alpha (humerus, + back), elbow / wrist flexion
+  bind: { elev: -30, pitch: 0, alpha: 35, elbow: 95, wrist: 100, bend: 0, twist: 0 },
+  fold: { elev: -82, pitch: 4, alpha: 80, elbow: 175, wrist: 174, bend: 0, twist: 0 },
+  glide: { elev: 5, pitch: 3, alpha: 8, elbow: 24, wrist: 14, bend: 2, twist: 1 },
+  // flapping (cruise): stroke plane amplitude, frequency (Hz), downstroke share, wing flexion in the
+  // upstroke (crows fold the hand in the upstroke), sweep and twist
+  flap: { freq: 3.84, amp: 92, mid: 5, down: 0.55, upFlex: 34, upWrist: 40, sweep: 10, twist: 14 },
+  // take-off / climb / braking beats
+  power: { freq: 4.3, amp: 112, mid: 12, down: 0.52, upFlex: 50, upWrist: 62, sweep: 20, twist: 18 },
+  // intermittent flight: glide share at cruise (0 = always flapping, crows glide little)
+  glideShare: 0.15,
+};
+
+export const FEATHERS = {
+  // 10 primaries (p10 short, p5/p6-p9 emarginated "fingers", longest p6-p7); roots along the hand
+  primaries: [
+    { u: 0.06, len: 0.158, width: 0.030, spread: 80, fold: 9 },
+    { u: 0.16, len: 0.166, width: 0.030, spread: 71, fold: 8 },
+    { u: 0.27, len: 0.177, width: 0.029, spread: 62, fold: 7 },
+    { u: 0.38, len: 0.190, width: 0.028, spread: 53, fold: 6 },
+    { u: 0.49, len: 0.205, width: 0.027, spread: 44, fold: 5, emarg: 0.5 },
+    { u: 0.60, len: 0.222, width: 0.026, spread: 36, fold: 4, emarg: 0.9 },
+    { u: 0.71, len: 0.228, width: 0.025, spread: 28, fold: 3, emarg: 1 },
+    { u: 0.81, len: 0.222, width: 0.024, spread: 20, fold: 2, emarg: 1 },
+    { u: 0.91, len: 0.200, width: 0.022, spread: 12, fold: 1, emarg: 1 },
+    { u: 1.00, len: 0.122, width: 0.019, spread: 5, fold: 0.5, emarg: 0.6 },
+  ],
+  // 6 secondaries + 3 tertials, from the wrist to the elbow
+  secondaries: [
+    { u: 0.03, len: 0.150, width: 0.033, spread: 90, fold: 176 },
+    { u: 0.14, len: 0.150, width: 0.033, spread: 92, fold: 176 },
+    { u: 0.25, len: 0.148, width: 0.033, spread: 94, fold: 176 },
+    { u: 0.36, len: 0.146, width: 0.033, spread: 96, fold: 176 },
+    { u: 0.47, len: 0.144, width: 0.033, spread: 99, fold: 176 },
+    { u: 0.58, len: 0.140, width: 0.033, spread: 102, fold: 177 },
+    { u: 0.70, len: 0.132, width: 0.032, spread: 108, fold: 177 },
+    { u: 0.81, len: 0.122, width: 0.031, spread: 116, fold: 178 },
+    { u: 0.92, len: 0.108, width: 0.030, spread: 125, fold: 179 },
+  ],
+  // 12 rectrices (6 a side, central -> outer); tail slightly rounded; fan: fully spread angle
+  rectrices: [
+    { x: 0.002, len: 0.168, width: 0.034, fan: 4, fold: 0.5, bend: 0 },
+    { x: 0.004, len: 0.168, width: 0.033, fan: 14, fold: 1, bend: -1 },
+    { x: 0.006, len: 0.166, width: 0.032, fan: 25, fold: 1.5, bend: -2 },
+    { x: 0.008, len: 0.163, width: 0.031, fan: 36, fold: 2, bend: -3 },
+    { x: 0.010, len: 0.158, width: 0.030, fan: 47, fold: 2.5, bend: -4 },
+    { x: 0.012, len: 0.150, width: 0.029, fan: 58, fold: 3, bend: -5 },
+  ],
+  coverts: { primary: 0.34, secondary: 0.6, tail: 0.44 },
+};
+
+export const motion = {
+  gears: { walk: 0.5, hop: 1.2, fly: 10.5 },
+  maxSpeed: 13,
+  ground: { maxSpeed: 1.9, accel: [2.5, 4], decel: 5, turnRate: 4.5 },
+  gaits: [
+    G('walk', 0.0, 1.5, 0.72, [0, 0.5], { lift: 0.02, bob: 0.004, sway: 0.006, pitch: 0, headBob: 1, wings: 0, tail: 0.6 }),
+    G('walk', 0.45, 2.1, 0.66, [0, 0.5], { lift: 0.024, bob: 0.006, sway: 0.006, pitch: -2, headBob: 1, wings: 0, tail: 0.8 }),
+    G('walk', 0.75, 2.5, 0.6, [0, 0.5], { lift: 0.026, bob: 0.007, sway: 0.005, pitch: -5, headBob: 0.6, wings: 0.05, tail: 0.8 }),
+    G('hop', 1.0, 3.2, 0.42, [0, 0], { lift: 0.03, bob: 0.004, hop: 0.04, sway: 0, pitch: -10, headBob: 0.2, wings: 0.15, tail: 0.5 }),
+    G('hop', 1.8, 3.6, 0.36, [0, 0], { lift: 0.032, bob: 0.004, hop: 0.05, sway: 0, pitch: -14, headBob: 0.1, wings: 0.3, tail: 0.5 }),
+  ],
+  feet: { spread: [0, 22, 0, -22], curl: 70, grip: 1, pad: 0.0055 },
+  // standing body: axis tilt above horizontal (deg); belly section (bind, ref size): centre height,
+  // half height, half width
+  body: { tilt: 30, belly: { y: 0.15, hh: 0.058, hw: 0.045 } },
+  head: { bob: 1, yaw: 2.4, pitchUp: 0.6, pitchDown: 1.2, saccade: 1, cock: 0.35, jawRest: -4.6 },
+  tail: { pitch: -6, walkBob: 6, sway: 5, flick: 1, fanRest: 0.05 },
+  wing: WING,
+  feathers: FEATHERS,
+  flight: {
+    minSpeed: 5.5, cruise: 10.5, maxSpeed: 13, climb: [3.0, -5.0], bankMax: 60, turnRate: 2.4,
+    clearance: 1.6, glideRatio: 7, sustained: true,
+    // cruise: legs folded back along the body, feet under the undertail coverts (flight1 / flight2)
+    legTuck: { back: 0.86, down: 0.0, side: 0.5 },
+  },
+  takeoff: { crouch: 0.16, jump: 2.2, angle: 35, beats: 5 },
+  landing: { approach: 7, flare: 0.55, touch: 1.0 },
+  actions: {
+    attack: { style: 'peck' },
+    eat: { style: 'peck', rate: 2.4, reach: 1.3, billPitch: 0.62, bodyPitch: -0.5, drop: 0.32 },
+    drink: {},
+    jump: { height: 0.2, distance: 0.45 },
+    sleep: { style: 'sink' }, // roosting: head drawn into the shoulders, bill tucked into the breast feathers
+  },
+};

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

@@ -0,0 +1,50 @@
+// Meshing plan: body (incl. wing arms and legs) at 1.7 mm, head + the top of the neck at 0.86 mm
+// (overlapping the body at the cut and cross-faded), eyelid patches at 0.35 mm, and the lower mandible
+// as its own rigid surface so the bill can open. Cells scale with the quality tier (Q.res).
+import { J } from './joints.js';
+import { EYE } from './sculpt.js';
+import { HEAD_O, NECK_SEGS } from './rig.js';
+import { eyeFrameOf } from '../../core/sdf/eyeSocket.js';
+import { lerp, norm, sub, smoothstep } from '../../core/math/vec.js';
+
+export const NECK_CUT = (() => {
+  const d = norm(sub(J.occiput, J['neck' + (NECK_SEGS - 1)]));
+  const c = lerp(J['neck' + (NECK_SEGS - 1)], J.occiput, 0.55);
+  return { c, d, band: 0.004 };
+})();
+export const neckS = (x, y, z) => (x - NECK_CUT.c[0]) * NECK_CUT.d[0] + (y - NECK_CUT.c[1]) * NECK_CUT.d[1] + (z - NECK_CUT.c[2]) * NECK_CUT.d[2];
+
+export const EYE_PATCH = { R: 0.0085, B: 0.0018, h: 0.00035, 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);
+}
+
+export function crowRegions(rig, params, Q) {
+  const B = NECK_CUT.band, r = Q.res;
+  const patches = Q.eyePatches ? EYE_PATCH.centres.map((c) => ({ c, R: EYE_PATCH.R, B: EYE_PATCH.B, h: EYE_PATCH.h * Math.max(1, r) })) : [];
+  return {
+    jobs: [
+      [
+        { name: 'body', part: 'body', bmin: [-0.19, -0.004, -0.15], bmax: [0.19, 0.3, 0.14], h: 0.0017 * r, F: 4, clip: (x, y, z) => neckS(x, y, z) < B },
+      ],
+      [
+        { name: 'head', part: 'body', bmin: [-0.035, 0.225, 0.015], bmax: [0.035, 0.335, 0.192], h: 0.00086 * r, F: 6, clip: (x, y, z) => neckS(x, y, z) > -B, patches },
+        { name: 'jaw', part: 'jaw', bmin: [-0.014, 0.262, 0.1], bmax: [0.014, 0.296, 0.19], h: 0.00068 * r, F: 6, rigidBone: 'jaw' },
+      ],
+    ],
+    fade(x, y, z, name, patch) {
+      const sN = neckS(x, y, z);
+      if (name === 'body') return 1 - smoothstep(-B, B, sN);
+      if (name === 'head') {
+        // (the head surface reaches 1.5 mm past the body's cut: the two overlap instead of leaving a
+        // see-through crack where the meshes do not coincide exactly)
+        let f = smoothstep(-B - 0.0015, B - 0.0015, sN);
+        if (patches.length) { const ew = eyePatchWeight(x, y, z); f *= patch ? ew : 1 - ew; }
+        return f;
+      }
+      return 1;
+    },
+  };
+}

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

@@ -0,0 +1,83 @@
+// Crow skeleton in bind pose (metres). Forward = +Z, up = +Y, the bird's left = +X; ground at y = 0,
+// the feet under the centre of mass at z ~ 0. Proportions from the side reference photo (side1: tarsus
+// 60 mm -> 1.3 mm/px; bill tip to tail tip 0.44 m, crown 0.33 m above the feet with the head up) and
+// corvid osteometry (femur 47, tibiotarsus 84, tarsometatarsus 57 mm; humerus 67, ulna 78, hand 58 mm).
+// Wings are bound half open (drooped out to the side) so the arm skin deforms evenly toward both the
+// folded and the spread wing; the flight feathers are separate bones (see core/rig/bird.js).
+import { buildRig } from '../../core/rig/rig.js';
+import { birdBones, birdLimbs, neckChain, wingJoints, featherJoints } from '../../core/rig/bird.js';
+import { WING, FEATHERS } from './motion.js';
+
+export const NECK_SEGS = 4;
+// the head sits low and close on the body (the neck's S is hidden in the feathers): HEAD_DROP moves
+// the skull and bill down / back from the base layout (otherwise the neck reads thick and upright)
+export const HEAD_DROP = [0, -0.005, -0.003];
+const hd = (v) => [v[0] + HEAD_DROP[0], v[1] + HEAD_DROP[1], v[2] + HEAD_DROP[2]];
+export const HEAD_O = hd([0, 0.3, 0.106]); // head-local origin: between the eyes
+
+const n2 = (y, z) => { const l = Math.hypot(y, z); return [0, y / l, z / l]; };
+
+export function crowJoints() {
+  const J = {
+    synsacrum: [0, 0.166, -0.034],
+    tailBase: [0, 0.168, -0.074],
+    tailTip: [0, 0.166, -0.097],
+    neckBase: [0, 0.205, 0.046],
+    occiput: hd([0, 0.281, 0.064]),
+    bill: hd([0, 0.305, 0.187]),
+    jawHinge: hd([0, 0.29, 0.1]),
+    jawTip: hd([0, 0.296, 0.181]),
+    shoulderL: [0.03, 0.213, 0.03],
+    hipL: [0.026, 0.15, -0.03],
+    kneeL: [0.033, 0.122, 0.008],
+    ankleL: [0.03, 0.058, -0.044],
+    mtpL: [0.024, 0.0062, -0.02],
+  };
+  // toes: III (middle) forward, II inner, IV outer, I (hallux) back; two segments each (phalanges +
+  // claw in the distal one), lying on the ground
+  const toe = (j, yawDeg, a, b, back = false) => {
+    const y = (yawDeg * Math.PI) / 180, m = J.mtpL;
+    const dir = back ? [Math.sin(y), 0, -Math.cos(y)] : [Math.sin(y), 0, Math.cos(y)];
+    J[`t${j}mL`] = [m[0] + dir[0] * a, 0.0034, m[2] + dir[2] * a];
+    J[`t${j}tL`] = [m[0] + dir[0] * (a + b), 0.0022, m[2] + dir[2] * (a + b)];
+  };
+  toe(3, 2, 0.02, 0.021);
+  toe(2, -22, 0.014, 0.016);
+  toe(4, 24, 0.015, 0.017);
+  toe(1, -6, 0.014, 0.015, true);
+  neckChain(J, NECK_SEGS, n2(0.45, 1), n2(1, -0.35), 0.42);
+  wingJoints(J, WING);
+  featherJoints(J, WING, FEATHERS, { bindFan: 0.2 });
+  return J;
+}
+
+export function crowRig() {
+  const J = crowJoints();
+  const neck = Array.from({ length: NECK_SEGS - 1 }, (_, i) => 'neck' + (NECK_SEGS - 1 - i));
+  const neckBones = Array.from({ length: NECK_SEGS }, (_, i) => 'neck' + (NECK_SEGS - 1 - i));
+  return buildRig({
+    joints: J,
+    unit: 0.25,
+    headOrigin: HEAD_O,
+    bones: birdBones({ neckSegs: NECK_SEGS, jaw: true, primaries: FEATHERS.primaries.length, secondaries: FEATHERS.secondaries.length, rectrices: FEATHERS.rectrices.length }),
+    axial: {
+      points: ['bill', 'occiput', ...neck, 'neckBase', 'synsacrum', 'tailBase', 'tailTip'],
+      bones: ['head', ...neckBones, 'chest', 'pelvis', 'tail'],
+      // wide blends along the neck: a thick, feathered neck on few segments bends over its whole
+      // length instead of creasing at the joints. The skull's influence runs well down the neck and
+      // the neck base blends far into the breast (the breast feathers follow the neck), which keeps
+      // skin distortion low in head-down / head-back poses (metrics: distort3)
+      blend: Object.fromEntries([
+        [1, [-0.5, 0.2]],
+        ...Array.from({ length: NECK_SEGS - 1 }, (_, k) => [2 + k, [-0.1, 0.1]]),
+        [1 + NECK_SEGS, [-0.45, 0.03]],
+      ]),
+    },
+    limbs: birdLimbs({
+      leg: { tCore: 0.95, aCore: 0.07, aBody: -0.05, midX: 0.012 },
+      wing: { tCore: 0.3, aCore: 0.16, aBody: -0.16, midX: 0.02 },
+    }),
+    appendages: [],
+    webTags: ['flankfold', 'scapular'],
+  });
+}

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

@@ -0,0 +1,118 @@
+// The crow sculpted as a signed distance field (the feathered silhouette: contour feathers are part
+// of the body shape; flight feathers are cards, see core/build/featherCards.js).
+// Every primitive is attached to a bone and a group (axial / legL / wingL / jaw).
+import { HEAD_O, NECK_SEGS } from './rig.js';
+import { add, sub, mul, lerp, norm, cross, dot } from '../../core/math/vec.js';
+import { sculptEyeSocket } from '../../core/sdf/eyeSocket.js';
+
+// Eye (head-local, left): lateral-frontal (yaw 62 deg), visible iris ~7.5 mm, round aperture.
+export const EYE = { c: [0.0185, 0.0005, 0.003], r: 0.0056, back: 0.0016, yaw: 1.08, pitch: 0.05, lid: 0.00045, R: 0.0047, d: 0.0006, off: 0.0, tilt: 0, irisZ: 0.0036, irisR: 0.0044 };
+
+const hl = (v) => [v[0] + HEAD_O[0], v[1] + HEAD_O[1], v[2] + HEAD_O[2]];
+
+export function sculptCrow(m, rig) {
+  const J = rig.J;
+  // ellipsoid whose local Y follows ydir and local X follows (roughly) xdir; r = [x, y, z]
+  const ellY = (o) => {
+    const y = norm(o.ydir);
+    let x = o.xdir || [1, 0, 0];
+    x = norm(sub(x, mul(y, dot(x, y))));
+    const z = cross(x, y);
+    return m.ell({ ...o, axis: z, up: y });
+  };
+  const A = { bone: 'chest' }, Pv = { bone: 'pelvis' };
+
+  // ---------------------------------------------------------------- TORSO (feathered)
+  const tilt = norm([0, 0.5, 0.866]);
+  m.ell({ ...A, tag: 'breast', c: [0, 0.182, 0.048], r: [0.044, 0.053, 0.07], axis: tilt, k: 0 });
+  m.ell({ ...A, tag: 'mantle', c: [0, 0.2, 0.0], r: [0.043, 0.038, 0.07], axis: tilt, k: 0.02 });
+  // straight underside from breast to vent (no sagging belly)
+  m.ell({ ...Pv, tag: 'belly', c: [0, 0.14, -0.012], r: [0.041, 0.036, 0.07], axis: norm([0, 0.35, 1]), k: 0.022 });
+  m.ell({ ...Pv, tag: 'rump', c: [0, 0.163, -0.07], r: [0.03, 0.03, 0.045], axis: norm([0, 0.3, 1]), k: 0.02 });
+  m.ell({ bone: 'tail', tag: 'undertail', c: [0, 0.147, -0.108], r: [0.019, 0.015, 0.055], axis: norm([0, 0.18, 1]), k: 0.016 });
+  m.ell({ bone: 'tail', tag: 'uppertail', c: [0, 0.172, -0.096], r: [0.019, 0.011, 0.032], axis: norm([0, 0.1, 1]), k: 0.012 });
+  for (const s of [1, -1]) {
+    m.ell({ ...Pv, tag: 'flankfold', c: [0.026 * s, 0.145, -0.02], r: [0.02, 0.03, 0.06], k: 0.02 });
+    // sides under the folded wing: the wing's lower edge is the silhouette
+    m.ell({ ...Pv, tag: 'sides', c: [0.03 * s, 0.162, -0.012], r: [0.017, 0.026, 0.066], axis: norm([0, 0.2, 1]), k: 0.02 });
+    m.ell({ ...A, tag: 'scapular', c: [0.026 * s, 0.211, 0.004], r: [0.02, 0.014, 0.05], axis: tilt, k: 0.018 });
+  }
+
+  // ---------------------------------------------------------------- NECK
+  const nj = ['neckBase', ...Array.from({ length: NECK_SEGS - 1 }, (_, i) => 'neck' + (i + 1)), 'occiput'];
+  // radius tapers from the base (30 mm) to the skull (19 mm)
+  const nr = nj.map((_, i) => { const u = i / NECK_SEGS; return 0.03 - 0.011 * Math.pow(u, 0.8); });
+  for (let i = 0; i < NECK_SEGS; i++) m.cone({ bone: 'neck' + i, tag: 'neck', a: J[nj[i]], b: J[nj[i + 1]], ra: nr[i], rb: nr[i + 1], k: 0.02 });
+  // throat filled out: bill, chin, throat and breast in one convex line
+  m.ell({ bone: 'neck' + Math.round(NECK_SEGS * 0.3), tag: 'throat', c: [0, 0.232, 0.087], r: [0.021, 0.028, 0.027], axis: norm([0, 0.6, 1]), k: 0.021 });
+  m.ell({ bone: 'neck' + Math.round(NECK_SEGS * 0.55), tag: 'nape', c: [0, 0.248, 0.04], r: [0.0166, 0.02, 0.0204], k: 0.022 });
+
+  // ---------------------------------------------------------------- HEAD (head-local, see HEAD_O)
+  // landmarks from side1 / face1: bill tip (0, 0.005, 0.081), bill base at z 0.031 (19 mm deep),
+  // eyes (+-0.0185, 0, 0.003), crown 0.029 above the eyes, occiput (0, -0.019, -0.042)
+  const H = { bone: 'head' };
+  // one smooth dome from the forehead over the crown to the nape (no double hump)
+  m.ell({ ...H, tag: 'cranium', c: hl([0, 0.004, -0.01]), r: [0.0185, 0.021, 0.031], k: 0.014 });
+  m.ell({ ...H, tag: 'crown', c: hl([0, 0.012, 0.006]), r: [0.0145, 0.0105, 0.022], axis: norm([0, -0.25, 1]), k: 0.016 });
+  m.ell({ ...H, tag: 'forehead', c: hl([0, 0.0115, 0.022]), r: [0.0115, 0.0115, 0.016], axis: norm([0, -0.45, 1]), k: 0.012 });
+  m.ell({ ...H, tag: 'chin', c: hl([0, -0.02, 0.006]), r: [0.012, 0.012, 0.026], axis: norm([0, 0.25, 1]), k: 0.012 });
+  for (const s of [1, -1]) {
+    m.ell({ ...H, tag: 'cheek', c: hl([0.011 * s, -0.009, 0.01]), r: [0.009, 0.012, 0.02], k: 0.008 });
+    m.ell({ ...H, tag: 'brow', c: hl([0.013 * s, 0.009, 0.004]), r: [0.007, 0.006, 0.014], k: 0.006 });
+    sculptEyeSocket(m, EYE, HEAD_O, s, { bone: 'head' });
+  }
+  // upper mandible: deep at the base, culmen curving down to a sharp tip; nasal bristles cover the
+  // basal third
+  // massive bill: ~18 mm deep at the base (about as deep as the forehead), strongly curved culmen
+  m.ell({ ...H, tag: 'bill', c: hl([0, 0.001, 0.042]), r: [0.0085, 0.0105, 0.022], axis: norm([0, -0.08, 1]), k: 0.007 });
+  m.cone({ ...H, tag: 'bill', a: hl([0, 0.004, 0.054]), b: hl([0, 0.0028, 0.0808]), ra: 0.0068, rb: 0.001, k: 0.007 });
+  m.cone({ ...H, tag: 'bill', a: hl([0, -0.004, 0.05]), b: hl([0, 0.0018, 0.0802]), ra: 0.0052, rb: 0.001, k: 0.006 });
+  // nasal bristles lie flat along the top of the bill base
+  m.ell({ ...H, tag: 'bristles', c: hl([0, 0.0098, 0.035]), r: [0.0078, 0.004, 0.013], axis: norm([0, -0.2, 1]), k: 0.005 });
+  // lower mandible (own surface so the bill can open)
+  const Jw = { bone: 'jaw', part: 'jaw' };
+  m.ell({ ...Jw, tag: 'mandible', c: hl([0, -0.0098, 0.038]), r: [0.0075, 0.0052, 0.028], axis: norm([0, 0.08, 1]), k: 0.004 });
+  m.cone({ ...Jw, tag: 'mandible', a: hl([0, -0.0082, 0.05]), b: hl([0, -0.0006, 0.0772]), ra: 0.0052, rb: 0.0009, k: 0.004 });
+  m.ell({ ...Jw, tag: 'gonys', c: hl([0, -0.0135, 0.02]), r: [0.0095, 0.0068, 0.02], k: 0.006 });
+
+  // ---------------------------------------------------------------- LEGS
+  for (const s of [1, -1]) {
+    const S = s > 0 ? 'L' : 'R', g = 'leg' + S;
+    const j = (n) => J[n + S];
+    // drumstick: feathered "trousers" down to ~1 cm above the ankle, then the bare lower tibiotarsus
+    const kn = j('knee'), an = j('ankle');
+    ellY({ bone: 'tibia' + S, group: g, tag: 'thigh', c: lerp(kn, an, 0.22), ydir: sub(an, kn), r: [0.017, 0.03, 0.02], k: 0.02 });
+    m.cone({ bone: 'tibia' + S, group: g, tag: 'trousers', a: lerp(kn, an, 0.3), b: lerp(kn, an, 0.8), ra: 0.014, rb: 0.0075, k: 0.01 });
+    m.cone({ bone: 'tibia' + S, group: g, tag: 'shank', a: lerp(kn, an, 0.7), b: an, ra: 0.0055, rb: 0.0045, k: 0.004 });
+    m.cone({ bone: 'tarsus' + S, group: g, tag: 'tarsus', a: an, b: j('mtp'), ra: 0.0044, rb: 0.0036, k: 0.003 });
+    m.sphere({ bone: 'tarsus' + S, group: g, tag: 'pad', c: add(j('mtp'), [0, -0.0015, 0.001]), rad: 0.0045, k: 0.003 });
+    for (const t of [1, 2, 3, 4]) {
+      const a = j('mtp'), b = J[`t${t}m${S}`], c = J[`t${t}t${S}`];
+      const r0 = t === 1 ? 0.0032 : 0.0028;
+      m.cone({ bone: `toe${t}a${S}`, group: g, tag: 'toe', a, b, ra: r0, rb: 0.0024, k: 0.0025 });
+      m.cone({ bone: `toe${t}b${S}`, group: g, tag: 'toe', a: b, b: lerp(b, c, 0.72), ra: 0.0024, rb: 0.0017, k: 0.002 });
+      m.cone({ bone: `toe${t}b${S}`, group: g, tag: 'claw', a: lerp(b, c, 0.65), b: c, ra: 0.0015, rb: 0.0003, k: 0.001 });
+    }
+  }
+
+  // ---------------------------------------------------------------- WINGS (arm; flight feathers are cards)
+  for (const s of [1, -1]) {
+    const S = s > 0 ? 'L' : 'R', g = 'wing' + S;
+    const sh = J['shoulder' + S], el = J['elbow' + S], wr = J['wrist' + S], tp = J['handTip' + S];
+    let n = norm(cross(sub(el, sh), sub(wr, el)));
+    if (n[1] < 0) n = mul(n, -1);
+    const seg = (a, b, bone, thick, chord, back, tag, k = 0.008) => {
+      const d = norm(sub(b, a));
+      const t = mul(norm(cross(n, d)), s); // trailing side
+      const c = add(lerp(a, b, 0.5), mul(t, back));
+      return ellY({ bone, group: g, tag, c, ydir: d, xdir: n, r: [thick, Math.hypot(...sub(b, a)) * 0.58, chord], k });
+    };
+    seg(sh, el, 'humerus' + S, 0.01, 0.026, 0.009, 'arm', 0.012);
+    seg(el, wr, 'ulna' + S, 0.0085, 0.026, 0.011, 'arm');
+    seg(wr, tp, 'hand' + S, 0.0055, 0.012, 0.004, 'hand', 0.006);
+    // leading-edge roll (propatagium, marginal coverts) on the forearm only: it stays on the arm when
+    // the elbow opens (a web spanning shoulder -> wrist swings forward as a loop)
+    seg(lerp(el, wr, 0.08), wr, 'ulna' + S, 0.0065, 0.009, -0.009, 'patagium', 0.009);
+    m.sphere({ bone: 'hand' + S, group: g, tag: 'wrist', c: wr, rad: 0.0065, k: 0.006 });
+  }
+}