@bitefoundry/retrieviewer 0.0.0-stage → 0.0.1

package/vendor/procedural-animals/src/species/chicken/coverts.js

@@ -0,0 +1,320 @@
+// The folded wing's coverts (photos side1 / side2 / three-quarter1 / rear_three-quarter: the coverts are
+// a layered surface of shingles continuous with the body, lying ON the secondaries; the flight
+// feathers show below and behind them). From the top:
+//   - the shield (sculpt.js coverts()): skin on the forearm's dorsal side, shaded with the body's
+//     contour-feather shingles (lesser and median coverts); its top is a plane fitted just above the
+//     flight-feather stack under it (wingStack.js: the highest card over the wing's motion), so it is
+//     no thicker than the stack it covers, and it reaches down below the wing plane (the feathers'
+//     roots are inside skin); the lid continues it over its upper rear corner and the back (the inner
+//     vanes and the primaries leave its rim there);
+//   - the greater coverts: rounded feather cards rigid on the forearm (this file), with the body's down,
+//     reaching into the shield and lying on its top, draped over its rim down onto the secondaries
+//     (above the stack in every wing pose), so the rim is a row of soft shingle ends rather than a skin
+//     edge over a dark gap, and the flight feathers come out from under them;
+//   - the flight feathers (core/build/featherCards.js), their greater covert cards dropped (motion.js
+//     feathersFor: cov.skip); the tertials restyled as contour feathers (wingLook.js).
+// Plan coordinates: the ulna's (x from the wrist toward the elbow, y toward the trailing edge, mm at
+// wingK 1); heights above the wing plane in mm (absolute: the feather stack's lift steps do not scale).
+import { wingStack, insidePoly } from './wingStack.js';
+import { MAT } from '../../core/build/coatKit.js';
+import { add, sub, mul, norm, cross, dot } from '../../core/math/vec.js';
+
+export const SHIELD = {
+  // the shield's outline (lesser / median coverts): front round the wrist, top edge along the leading
+  // edge, lower rim along the secondaries' bases, rear end at the elbow
+  core: [[-7, -6], [-4, -15], [4, -22], [18, -25], [36, -24], [52, -19], [64, -15], [71, -10], [74, -4], [72, 1], [67, 4], [60, 6], [50, 7], [38, 7.5], [26, 7], [15, 6], [6, 4], [-3, 1]],
+  // greater coverts: root (x, y), direction (deg from +x toward +y), length factor, depth inside the rim
+  // (mm, default inRoot); side by side along the lower rim and up the rear end, so their rounded ends make
+  // the scalloped rim (fitted alternately: every other card first, the ones between them on top)
+  cards: [[15, 3.6, 50, 0.8, 3], [21, 3.8, 48, 0.95], [30, 4.4, 45, 1.08], [39, 4.6, 43, 0.97], [48, 4.4, 41, 1.06], [57, 3.6, 37, 0.98], [65, 1.8, 29, 1.04], [71, -4, 14, 1.0]],
+  len: 21, halfW: 6.8, // card length (x the card's factor), half width (mm)
+  gap: 0.3, step: 0.3, coreGap: 0.45, coreRound: 3.5, coreDown: 2, // mm
+  // the lid over the upper rear corner and the back (plan mm), its gap above the stack, thickness, rim
+  // radius, blend (its lower edge stays above y -12 near x 68: card #7 lies under it)
+  lid: { poly: [[44, -22], [58, -31], [74, -31], [84, -19], [82, -12], [68, -14], [56, -16], [44, -18]], gap: 0.4, t: 5.2, round: 2.4, k: 0.008 },
+  // cards along the rim (fitted alternately), the cards' reach into the shield, their height on its top
+  // (+ a step per card they overlap there), the drape from its rim down to their planes, the width at
+  // the root (neighbours' roots side by side, their free ends overlapping)
+  rim: 8, inRoot: 8, onTop: 0.3, ordStep: 0.6, drape: 7, rootTaper: 0.55,
+};
+
+const cache = new Map();
+/** Fitted layout: { core: { poly, plane [h0, hx, hy] (top), t }, cards: [{ x, y, a, len, w, plane }] } (plan mm, this individual) */
+export function shieldLayout(form = {}) {
+  const key = JSON.stringify([form.wingK, form.priK, form.fwK, form.chick, form.up]);
+  if (cache.has(key)) return cache.get(key);
+  const C = SHIELD, wk = form.wingK ?? 1, S = wingStack(form);
+  const core = C.core.map(([x, y]) => [x * wk, y * wk]);
+  const cards = C.cards.map(([x, y, a, lk = 1, inR = C.inRoot], i) => {
+    const r = a * Math.PI / 180, d = [Math.cos(r), Math.sin(r)], s = [-d[1], d[0]];
+    const c = { i, x: x * wk, y: y * wk, d, s, len: C.len * lk * wk, w: C.halfW * wk, plane: null };
+    c.tipL = Math.min(c.len * 0.55, c.w * 1.5); c.body = c.len - c.tipL;
+    // (x, y): where the card's shaft leaves the shield; each side of the card starts inR mm inside the
+    // shield's outline (its root edge runs along the rim, on the shield's top)
+    const U0 = [];
+    for (let k = 0; k <= 20; k++) {
+      const v = (-1 + k / 10) * c.w;
+      let ue = -20 * wk;
+      for (let u = 20 * wk; u >= -20 * wk; u -= 0.2) if (insidePoly(core, c.x + d[0] * u + s[0] * v, c.y + d[1] * u + s[1] * v)) { ue = u + 0.2; break; }
+      U0.push(Math.min(ue - inR * wk, c.body));
+    }
+    c.u0 = (cc) => { const f = (cc + 1) * 10, k = Math.min(19, Math.floor(f)); return U0[k] + (U0[k + 1] - U0[k]) * (f - k); };
+    const poly = [];
+    for (let k = 0; k <= 10; k++) poly.push(cardPoint(c, 0, -1 + k / 5));
+    for (let k = 1; k <= 12; k++) poly.push(cardPoint(c, k / 12, 1));
+    for (let k = 11; k >= 1; k--) poly.push(cardPoint(c, k / 12, -1));
+    c.poly = poly;
+    return c;
+  });
+  // sample points of each card's footprint outside the shield (1 mm grid)
+  for (const c of cards) {
+    const xs = c.poly.map((p) => p[0]), ys = c.poly.map((p) => p[1]);
+    c.pts = [];
+    for (let y = Math.floor(Math.min(...ys)); y <= Math.ceil(Math.max(...ys)); y += 1) for (let x = Math.floor(Math.min(...xs)); x <= Math.ceil(Math.max(...xs)); x += 1) {
+      if (!insidePoly(c.poly, x, y) || insidePoly(core, x, y)) continue;
+      c.pts.push([x, y, S.near(x, y, 1.2)]);
+    }
+  }
+  // fit in stacking order: above the stack (+ gap + half the card's thickness) and above every earlier
+  // card where they overlap (+ the card's thickness + step); planar, tilted to follow the stack (least
+  // mean clearance)
+  const hOf = (pl, x, y) => pl[0] + pl[1] * x + pl[2] * y;
+  // fitting order: alternate cards along the rim first, then the ones between them (each lies on its two
+  // neighbours: no chain of overlaps piling up toward the elbow), the extra cards last
+  const nR = C.rim ?? cards.length;
+  const order = [...cards.slice(0, nR).filter((c) => c.i % 2 === 0), ...cards.slice(0, nR).filter((c) => c.i % 2 === 1), ...cards.slice(nR)];
+  const done = [];
+  for (const c of order) {
+    const need = c.pts.map(([x, y, h]) => {
+      let L = Number.isFinite(h) ? h + C.gap + 0.25 : -Infinity;
+      for (const cj of done) if (insidePoly(cj.poly, x, y)) L = Math.max(L, hOf(cj.plane, x, y) + 0.5 + C.step);
+      return [x, y, L];
+    }).filter((q) => Number.isFinite(q[2]));
+    let best = null;
+    for (let bx = -0.1; bx <= 0.3001; bx += 0.01) for (let by = -0.2; by <= 0.2001; by += 0.01) {
+      let a = -Infinity; for (const [x, y, L] of need) a = Math.max(a, L - bx * x - by * y);
+      if (!Number.isFinite(a)) a = 0;
+      let m = 0; for (const [x, y, L] of need) m += a + bx * x + by * y - L;
+      m /= Math.max(1, need.length);
+      if (!best || m < best.m - 1e-9) best = { m, plane: [a, bx, by] };
+    }
+    c.plane = best.plane;
+    c.fitGap = best.m;
+    if (!need.length) c.plane = [S.near(c.x, c.y, 3) + C.gap + 0.25, 0, 0];
+    done.push(c);
+  }
+  // each card's step above the shield's top where it lies on it: one above the highest earlier card it overlaps there
+  for (let q = 0; q < order.length; q++) {
+    const c = order[q];
+    let o = 0;
+    const xs = c.poly.map((p) => p[0]), ys = c.poly.map((p) => p[1]);
+    for (let y = Math.floor(Math.min(...ys)); y <= Math.ceil(Math.max(...ys)); y += 0.5) for (let x = Math.floor(Math.min(...xs)); x <= Math.ceil(Math.max(...xs)); x += 0.5) {
+      if (!insidePoly(c.poly, x, y) || distPoly(core, x, y) > (insidePoly(core, x, y) ? 1e9 : C.drape * wk)) continue;
+      for (let j = 0; j < q; j++) if (order[j].ord + 1 > o && insidePoly(order[j].poly, x, y)) o = order[j].ord + 1;
+    }
+    c.ord = o;
+  }
+  // the shield's top: above the stack inside it (+ coreGap) and above the covert cards' roots
+  const cxs = core.map((p) => p[0]), cys = core.map((p) => p[1]);
+  const need = [];
+  for (let y = Math.floor(Math.min(...cys)); y <= Math.ceil(Math.max(...cys)); y += 1) for (let x = Math.floor(Math.min(...cxs)); x <= Math.ceil(Math.max(...cxs)); x += 1) {
+    if (!insidePoly(core, x, y)) continue;
+    let L = S.near(x, y, 1.2) + C.coreGap;
+    if (Number.isFinite(L)) need.push([x, y, L]);
+  }
+  let best = null;
+  for (let bx = 0; bx <= 0.3001; bx += 0.005) for (let by = -0.2; by <= 0.2001; by += 0.005) {
+    let a = -Infinity; for (const [x, y, L] of need) a = Math.max(a, L - bx * x - by * y);
+    let m = 0; for (const [x, y, L] of need) m += a + bx * x + by * y - L;
+    if (!best || m < best.m) best = { m, plane: [a, bx, by] };
+  }
+  // thick enough to reach C.coreDown mm below the wing plane everywhere under it
+  let tMax = 0; for (const [x, y] of core) tMax = Math.max(tMax, hOf(best.plane, x, y) + C.coreDown);
+  const out = { core: { poly: core, plane: best.plane, t: tMax, round: C.coreRound }, cards, stack: S };
+  // the lid over the shield's upper rear corner: a plate above the stack (the inner vanes come out of the
+  // shield's rim there, beside the back, with nothing over them), its underside fitted just above the
+  // stack's highest card over the wing's motion
+  if (C.lid) {
+    const lp = C.lid.poly.map(([x, y]) => [x * wk, y * wk]);
+    const lneed = [];
+    const lx = lp.map((p) => p[0]), ly = lp.map((p) => p[1]);
+    for (let y = Math.floor(Math.min(...ly)); y <= Math.ceil(Math.max(...ly)); y += 1) for (let x = Math.floor(Math.min(...lx)); x <= Math.ceil(Math.max(...lx)); x += 1) {
+      if (!insidePoly(lp, x, y)) continue;
+      const h = S.near(x, y, 1.5);
+      if (Number.isFinite(h)) lneed.push([x, y, h + C.lid.gap]);
+    }
+    // (tilted so its top runs on from the shield's top as closely as it can: no tab standing up)
+    const lt = C.lid.t * wk, lpts = [];
+    for (let y = Math.floor(Math.min(...ly)); y <= Math.ceil(Math.max(...ly)); y += 1) for (let x = Math.floor(Math.min(...lx)); x <= Math.ceil(Math.max(...lx)); x += 1) if (insidePoly(lp, x, y)) lpts.push([x, y]);
+    let lb = null;
+    for (let bx = -0.3; bx <= 0.3001; bx += 0.01) for (let by = -0.4; by <= 0.4001; by += 0.01) {
+      let a = -Infinity; for (const [x, y, L] of lneed) a = Math.max(a, L - bx * x - by * y);
+      let m = 0; for (const [x, y] of lpts) { const d = a + bx * x + by * y + lt - hOf(best.plane, x, y); m += d * d; }
+      if (!lb || m < lb.m) lb = { m, plane: [a, bx, by] };
+    }
+    out.lid = { poly: lp, plane: lb.plane, t: lt, round: C.lid.round * wk, k: (C.lid.k ?? 0.003) * wk };
+  }
+  // a card's height (mm above the wing plane) at plan (x, y), s mm from its root edge: on the shield's top inside its
+  // outline (each card a step above the ones before it), draped over the rim down to its fitted plane outside
+  const top = best.plane;
+  out.cardH = (c, x, y, s) => {
+    const hTop = hOf(top, x, y) + C.onTop + C.ordStep * c.ord;
+    const hOut = hOf(c.plane, x, y);
+    const dOut = insidePoly(core, x, y) ? 0 : distPoly(core, x, y);
+    const f = 1 - smooth01(dOut / (C.drape * wk));
+    let h = hOut + (hTop - hOut) * f;
+    // (the root edge lies on the shield, in its down; a root sunk into the skin crossed the card before it)
+    void s;
+    return h;
+  };
+  cache.set(key, out);
+  return out;
+}
+
+const smooth01 = (t) => { const c = Math.min(1, Math.max(0, t)); return c * c * (3 - 2 * c); };
+// distance from (x, y) to a polygon's outline
+export function distPoly(poly, x, y) {
+  let m = Infinity;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const [ax, ay] = poly[j], [bx, by] = poly[i], dx = bx - ax, dy = by - ay;
+    const t = Math.max(0, Math.min(1, ((x - ax) * dx + (y - ay) * dy) / (dx * dx + dy * dy || 1)));
+    m = Math.min(m, Math.hypot(x - ax - dx * t, y - ay - dy * t));
+  }
+  return m;
+}
+
+// a point of a covert card in the plan (mm): tau 0 (its root edge, along the shield's rim) .. 1 (the tip of
+// its rounded end), cc -1 .. 1 across it
+export function cardPoint(c, tau, cc) {
+  const u0 = c.u0(cc), u = u0 + tau * (c.len - u0);
+  let hw = u <= c.body ? c.w : c.w * Math.sqrt(Math.max(0, 1 - ((u - c.body) / c.tipL) ** 2));
+  // (narrower toward the root: neighbours' roots side by side, their free ends overlapping)
+  if (SHIELD.rootTaper) { const a = Math.min(1, Math.max(0, (u - u0) / Math.max(1e-6, c.body - u0))); hw *= SHIELD.rootTaper + (1 - SHIELD.rootTaper) * Math.min(1, a / 0.6); }
+  const v = cc * Math.max(hw, 0.05);
+  return [c.x + c.d[0] * u + c.s[0] * v, c.y + c.d[1] * u + c.s[1] * v, hw];
+}
+
+// plan (mm) -> bind space, in the ulna's frame from the bind joints (as sculpt.js coverts())
+export function planFrame(J, s) {
+  const S = s > 0 ? 'L' : 'R';
+  const sh = J['shoulder' + S], el = J['elbow' + S], wr = J['wrist' + S];
+  let n = norm(cross(sub(el, sh), sub(wr, el)));
+  if (n[1] < 0) n = mul(n, -1);
+  const d = norm(sub(wr, el));
+  const t = mul(norm(cross(n, d)), s);
+  const X = mul(d, -1), Y = t;
+  return { wr, X, Y, n, Q: (x, y, h) => add(add(add(wr, mul(X, x * 0.001)), mul(Y, y * 0.001)), mul(n, h * 0.001)) };
+}
+
+/**
+ * The greater covert cards (surfaces block, rigid on the forearm bones), laid out as
+ * core/build/featherCards.js cards (two layers, rachis + two vane columns, material VANE).
+ * colour(kind, i, side, t, c, layer) as featherCards (kind 'wingCovert').
+ */
+export function covertCards(ctx, colour, look = null) {
+  const { rig, params, Q } = ctx;
+  const form = params.form || {};
+  if (form.chick) return null;
+  const Lyt = shieldLayout(form);
+  const res = Q?.res ?? 1;
+  if (res >= 4) return null; // (the crowd tier drops coverts, as featherCards)
+  // (more rows than a flight feather: the card drapes over the shield's rim)
+  const nA = (res <= 1.35 ? 9 : res <= 2.1 ? 6 : res <= 3.1 ? 4 : 3) + 4;
+  const th = 0.0005;
+  const P = [], N = [], Cb = [], T = [], Sf = [], SI = [], I = [], X = [], PCL = [], FL = [];
+  for (const side of [1, -1]) {
+    const F = planFrame(rig.J, side), b = rig.BONE['ulna' + (side > 0 ? 'L' : 'R')];
+    for (const c of Lyt.cards) {
+      const [a0, ax, ay] = c.plane;
+      const h = (x, y) => a0 + ax * x + ay * y;
+      // card frame in bind space
+      const p0 = F.Q(c.x, c.y, h(c.x, c.y));
+      const A = norm(sub(F.Q(c.x + c.d[0], c.y + c.d[1], h(c.x + c.d[0], c.y + c.d[1])), p0));
+      const Sv = norm(sub(F.Q(c.x + c.s[0], c.y + c.s[1], h(c.x + c.s[0], c.y + c.s[1])), p0));
+      let Nn = norm(cross(A, Sv));
+      if (dot(Nn, F.n) < 0) Nn = mul(Nn, -1);
+      const v0 = P.length / 3;
+      const ts = []; for (let j = 0; j <= nA; j++) ts.push(0.5 - 0.5 * Math.cos(Math.PI * j / nA));
+      const COLS = [-1, -0.5, 0, 0.5, 1], nc = COLS.length;
+      const pt = (t, cc) => {
+        const [x, y] = cardPoint(c, t, cc);
+        const sR = t * (c.len - c.u0(cc));
+        return F.Q(x, y, Lyt.cardH ? Lyt.cardH(c, x, y, sR) : h(x, y));
+      };
+      const halfW = (t) => cardPoint(c, t, 0)[2];
+      for (const layer of [1, -1]) {
+        for (let j = 0; j <= nA; j++) {
+          const t = ts[j];
+          for (const cc of COLS) {
+            // local normal from the (draped) surface
+            const e = 0.02;
+            const dt = sub(pt(Math.min(1, t + e), cc), pt(Math.max(0, t - e), cc)), dc = sub(pt(t, Math.min(1, cc + e)), pt(t, Math.max(-1, cc - e)));
+            let nl = norm(cross(dt, dc));
+            if (!Number.isFinite(nl[0])) nl = Nn;
+            if (dot(nl, F.n) < 0) nl = mul(nl, -1);
+            const p = add(pt(t, cc), mul(nl, layer * th * 0.5 * (1 - 0.6 * t) - (layer > 0 ? 0 : 0)));
+            P.push(...p); N.push(...mul(nl, layer));
+            Cb.push(...norm(dt));
+            if (look) {
+              // shaded as the shield's contour feathers (material FEATHER, one big shingle per card)
+              const k = (1 + 0.06 * Math.sin(c.i * 12.9898 + side * 3.1)) * (layer > 0 ? 1 : 0.8);
+              T.push(look.rgb[0] * k, look.rgb[1] * k, look.rgb[2] * k, MAT.FEATHER);
+              Sf.push(look.gloss, look.size, look.mz, look.irid);
+              if (look.mcol) PCL.push([P.length / 3 - 1, look.mcol, 0]);
+              FL.push(layer > 0 ? look.fur ?? 0 : 0);
+            } else {
+              const col = colour('wingCovert', c.i, side, t, cc, layer);
+              T.push(col.rgb[0], col.rgb[1], col.rgb[2], MAT.VANE);
+              if (col.bar) PCL.push([P.length / 3 - 1, col.bar.rgb, -c.len * 0.001 / col.bar.period]);
+              // (across never reaches 0: no rachis line, a covert's shaft is hidden in its barbs)
+              Sf.push(col.gloss ?? 0.4, col.irid ?? 0, 0.3 + 0.7 * Math.abs(cc), t);
+            }
+            X.push(cc * halfW(t) * 0.001 * side);
+            SI.push(b.index, 0, 0, 0);
+          }
+        }
+        const base = v0 + (layer > 0 ? 0 : (nA + 1) * nc);
+        for (let j = 0; j < nA; j++) for (let k = 0; k < nc - 1; k++) {
+          const a = base + j * nc + k, bq = a + 1, c2 = a + nc, d = a + nc + 1;
+          I.push(a, c2, bq, bq, c2, d);
+        }
+      }
+      // winding: each triangle faces its layer's normal
+      for (let t = 0; t < I.length; t += 3) {
+        const a = I[t], bb = I[t + 1], c3 = I[t + 2];
+        if (a < v0) continue;
+        const e1 = [P[bb * 3] - P[a * 3], P[bb * 3 + 1] - P[a * 3 + 1], P[bb * 3 + 2] - P[a * 3 + 2]];
+        const e2 = [P[c3 * 3] - P[a * 3], P[c3 * 3 + 1] - P[a * 3 + 1], P[c3 * 3 + 2] - P[a * 3 + 2]];
+        const g = cross(e1, e2);
+        if (g[0] * N[a * 3] + g[1] * N[a * 3 + 1] + g[2] * N[a * 3 + 2] < 0) { I[t + 1] = c3; I[t + 2] = bb; }
+      }
+    }
+  }
+  const nV = P.length / 3;
+  const out = {
+    nV, pos: Float32Array.from(P), nrm: Float32Array.from(N), index: Uint32Array.from(I),
+    skinIndex: Uint16Array.from(SI), skinWeight: new Float32Array(nV * 4),
+    comb: Float32Array.from(Cb), tint: Float32Array.from(T), surf: Float32Array.from(Sf),
+    pattern: Float32Array.from(X), mark: new Float32Array(nV).fill(1), furLen: FL.length === nV ? Float32Array.from(FL) : new Float32Array(nV),
+    patternColor: new Float32Array(nV * 4),
+  };
+  for (const [v, rgb, n] of PCL) out.patternColor.set([rgb[0], rgb[1], rgb[2], n], v * 4);
+  for (let v = 0; v < nV; v++) out.skinWeight[v * 4] = 1;
+  return out;
+}
+
+// concatenate two surfaces blocks (indices of the second offset)
+export function joinSurfaces(a, b) {
+  if (!b || !b.nV) return a;
+  if (!a || !a.nV) return b;
+  const cat = (x, y, T) => { const r = new T(x.length + y.length); r.set(x); r.set(y, x.length); return r; };
+  const idx = new Uint32Array(a.index.length + b.index.length);
+  idx.set(a.index); for (let i = 0; i < b.index.length; i++) idx[a.index.length + i] = b.index[i] + a.nV;
+  return {
+    nV: a.nV + b.nV, pos: cat(a.pos, b.pos, Float32Array), nrm: cat(a.nrm, b.nrm, Float32Array), index: idx,
+    skinIndex: cat(a.skinIndex, b.skinIndex, Uint16Array), skinWeight: cat(a.skinWeight, b.skinWeight, Float32Array),
+    comb: cat(a.comb, b.comb, Float32Array), tint: cat(a.tint, b.tint, Float32Array), surf: cat(a.surf, b.surf, Float32Array),
+    pattern: cat(a.pattern, b.pattern, Float32Array), mark: cat(a.mark, b.mark, Float32Array), furLen: cat(a.furLen, b.furLen, Float32Array),
+    patternColor: cat(a.patternColor, b.patternColor, Float32Array),
+  };
+}

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

@@ -0,0 +1,110 @@
+// Domestic chicken (Gallus gallus domesticus): hen, rooster and chick; breeds as variants (brown/red
+// layer, white Leghorn, black Australorp, barred Plymouth Rock, buff Orpington, speckled Sussex).
+// Body plan 'bird' (core/motion/bird.js): a ground bird with burst flight only.
+import { chickenRig, chickenJoints } from './rig.js';
+import { sculptChicken, eyeFor } from './sculpt.js';
+import { chickenRegions } from './regions.js';
+import { chickenCoat, chickenFeatherColour, chickenWingCovertLook, chickenTertialLook, chickWingDownLook } from './coat.js';
+import { motion, wingFor, feathersFor } from './motion.js';
+import { featherCards } from '../../core/build/featherCards.js';
+import { covertCards, joinSurfaces } from './coverts.js';
+import { restyleWing, downyWing } from './wingLook.js';
+import { srgb } from '../../core/build/coatKit.js';
+
+const FEATHER_EDGE = { red: 0.55, leghorn: 0.35, australorp: 1, barred: 0.4, buff: 0.4, speckled: 0.6 };
+const BREEDS = ['red', 'leghorn', 'australorp', 'barred', 'buff', 'speckled'];
+// body mass (kg) hen / cock per breed (breed standards); lengths scale with mass^(1/3)
+const MASS = { red: [2.0, 3.0], leghorn: [1.8, 2.5], australorp: [2.6, 3.6], barred: [2.8, 3.6], buff: [3.0, 3.8], speckled: [3.0, 3.8] };
+// loose-feathered heavy breeds carry part of their bulk as fluff
+const FLUFF = { red: 1, leghorn: 0.95, australorp: 1.06, barred: 1.05, buff: 1.14, speckled: 1.05 };
+
+// individual form (read by rig, sculpt, regions, coat and motion.individual)
+function formOf(sex, age, breed, g) {
+  if (age === 'juvenile') {
+    // chick (~1-2 weeks, ~0.3 of the hen's size): big head, short neck, short legs, stubby wings with
+    // narrow pin feathers (wider ones swept through its round body opening and folding)
+    return {
+      chick: true, billK: 0.6, legK: 0.72, femurK: 0.7, tarK: 0.72, hipK: 0.74, neckK: 0.42, headK: 1.75, eyeK: 1.05, toeK: 0.85, toeR: 1.15,
+      wingK: 0.52, priK: 0.25, recK: 0.08, fwK: 0.45, fluff: 1.1,
+      headO: [0, 0.225, 0.085],
+    };
+  }
+  const f = { fluff: FLUFF[breed] * (1 + 0.03 * g()), headK: 1.12 };
+  if (sex === 'male') {
+    Object.assign(f, {
+      legK: 1.07, hipK: 1.06, neckK: 1.14, headK: 1.18, up: 13, tailUp: 30, spur: 0.8 + 0.4 * Math.abs(g()), sickles: (breed === 'leghorn' ? 1.08 : 1) * (1 + 0.06 * g()), recK: 1.25,
+      comb: 1.45 * (breed === 'leghorn' ? 1.12 : 1), combH: 2.2 * (breed === 'leghorn' ? 1.15 : 1) * (1 + 0.08 * g()), wattle: 2.1 * (1 + 0.1 * g()), earlobe: 1.4,
+    });
+  } else {
+    Object.assign(f, {
+      comb: breed === 'leghorn' ? 1.3 : 1, combH: (breed === 'leghorn' ? 1.9 : 1) * (1 + 0.12 * g()), combFlop: breed === 'leghorn' ? 0.9 : 0,
+      wattle: (breed === 'leghorn' ? 1.3 : 1) * (1 + 0.12 * g()), earlobe: breed === 'leghorn' ? 1.25 : 1, spur: 0,
+      up: breed === 'leghorn' ? 5 : 0,
+    });
+  }
+  return f;
+}
+
+export default {
+  id: 'chicken',
+  name: 'Chicken',
+  latin: 'Gallus gallus domesticus',
+  group: 'birds',
+  plan: 'bird',
+  covering: 'feathers',
+  variants: BREEDS,
+
+  // Seeded individual: breed (variant), sex (a flock is mostly hens), age (chick when asked, or now
+  // and then), size by breed and sex (mass^(1/3)), leg length, head and comb size, fluff and colour tone.
+  variation(R, o) {
+    const g = () => (R() + R() + R() - 1.5) / 1.5;
+    for (let i = 0; i < 5; i++) R(); // (decorrelates the first draws from the seed)
+    const r0 = R(), r1 = R(), r2 = R();
+    const breed = o.variant && BREEDS.includes(o.variant) ? o.variant : BREEDS[[0.3, 0.48, 0.63, 0.78, 0.9, 1].findIndex((x) => r0 < x)];
+    const sex = o.sex || (r1 < 0.34 ? 'male' : 'female');
+    const age = o.age || (r2 < 0.08 ? 'juvenile' : 'adult');
+    const juv = age === 'juvenile';
+    const m = MASS[breed][sex === 'male' ? 1 : 0] * (1 + 0.1 * g());
+    const size = juv ? 0.3 * (1 + 0.06 * g()) : Math.cbrt(m / 2.0);
+    const form = formOf(sex, age, breed, g);
+    const J = chickenJoints(form), HO = J._headO;
+    return {
+      sex, age, size, breed, variant: breed, form,
+      tone: 1 + 0.08 * g(),
+      warps: juv ? [] : [
+        { type: 'legs', k: 1 + 0.035 * g(), top: 0.09 },
+        { type: 'scaleAbout', c: HO, k: 1 + 0.03 * g(), r0: 0.03, r1: 0.06 },
+        { type: 'girth', k: 1 + 0.04 * g(), cy: 0.18, z0: -0.12, z1: 0.1, fade: 0.04 },
+      ],
+    };
+  },
+  rig: (params) => chickenRig(params.form),
+  sculpt: (m, rig, params) => sculptChicken(m, rig, params),
+  regions: chickenRegions,
+  coat: chickenCoat,
+  // flight-feather cards, and the folded wing's greater coverts along the covert shield's rim (coverts.js)
+  surfaces: (ctx) => {
+    const colour = chickenFeatherColour(ctx.params);
+    const fc = featherCards({ ...ctx, wing: wingFor(ctx.params.form), feathers: feathersFor(ctx.params.form), tail: { bindFan: 0.2 }, colour });
+    // (the folded wing's tertials read as contour feathers: shaded like the shield, with its down)
+    if (!ctx.params.form?.chick) restyleWing(fc, ctx.rig, chickenTertialLook(ctx.params));
+    // (a chick's wing is downy: its pin-feather cards wear the down around them)
+    else downyWing(fc, ctx.rig, chickWingDownLook(ctx.params));
+    return joinSurfaces(fc, covertCards(ctx, colour, chickenWingCovertLook(ctx.params)));
+  },
+  eyeSpecs: (params, rig) => [1, -1].map((side) => ({ side, spec: eyeFor(params.form), headOrigin: rig.headOrigin, bone: 'head', look: params.age === 'juvenile' ? EYE_JUV : EYE_LOOK })),
+  motion,
+  // pale plumage shows the shingle shading more than black: lower feather-edge contrast
+  render: (p) => ({ markColor: srgb(0x2a1a12), strandDensity: 700, clumpDensity: 1.2, shellScale: 1, finWidth: 0.3, featherEdge: FEATHER_EDGE[p.breed] ?? 0.6 }),
+};
+
+// Round pupil, orange (reddish-bay) iris, bird lids with a nictitating membrane.
+export const EYE_LOOK = {
+  pupil: 'round',
+  lids: 'bird',
+  iris: { inner: srgb(0xe07a22), mid: srgb(0xeb9a30), hi: srgb(0xf6c050), outer: srgb(0xc8641c) },
+  sclera: { visible: false, color: [0.02, 0.02, 0.02] },
+  lidColor: srgb(0x8a3a34),
+  pupilSize: [0.3, 0.44],
+};
+export const EYE_JUV = { ...EYE_LOOK, iris: { inner: srgb(0x201a16), mid: srgb(0x3a2e26), hi: srgb(0x5a4838), outer: srgb(0x181410) }, lidColor: srgb(0x5a4a3a), pupilSize: [0.5, 0.62] };

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

@@ -0,0 +1,177 @@
+// Chicken motion data for the bird engine (schema: src/core/motion/bird.js). Numbers are for the
+// reference individual (params.size = 1: a ~2 kg brown layer hen, hip 0.21 m, 0.42 m bill to tail);
+// the engine scales them by dynamic similarity.
+//
+// Ground: a strictly alternating walk (duty 0.72 -> 0.6) with the signature head bob (the head holds
+// still in space for ~60 % of each step, then thrusts forward), a grounded run (duty ~0.5) and an
+// aerial sprint (wings folded on the body). Chickens never hop to travel (hop only as a jump).
+// Flight: burst flight only - wingbeats ~10 Hz, amplitude ~135 deg (laying hens, R. Soc. Open Sci.
+// 2021), a flutter up onto a perch or a short escape flight, then a steep glide down (not sustained).
+// Per individual (motion.individual): roosters attack with a flapping jump-kick (spurs), hens peck;
+// roosters crow as an idle behaviour; chicks have stubby wings and no tail.
+const G = (name, v, f, D, off, o) => ({ name, v, f, D, off, ...o });
+
+// Wing (humerus, ulna, hand in metres; configurations in degrees, see core/rig/bird.js). The folded
+// wing lies high on the flank, its primaries tucked under the secondaries, tips below the tail base.
+export function wingFor(form = {}) {
+  const k = form.wingK ?? 1;
+  return {
+    lengths: [0.077 * k, 0.07 * k, 0.066 * k],
+    bind: { elev: -30, pitch: 0, alpha: 35, elbow: 95, wrist: 100, bend: 0, twist: 0 },
+    // folded: the wing plane leans out 14 deg from the vertical, on the barrel of the flank (fitted so
+    // the stack's outline lies on the body; the flank under it is flattened and bedded, sculpt.js
+    // flankUnderWing / wingPocket; leaning in more cut the primaries' tips into the rump); an upright
+    // individual (form.up: a rooster's torso is pitched up) folds it turned down at the back with the
+    // body, off the saddle (2 deg per deg of pitch: at 1.3 the primaries' tips cut into the thigh)
+    fold: { elev: -76, pitch: 4, alpha: 76 - 2.0 * (form.up ?? 0), elbow: 171, wrist: 170, bend: 0, twist: 0 },
+    glide: { elev: 6, pitch: 4, alpha: 6, elbow: 22, wrist: 12, bend: 2, twist: 2 },
+    // burst flight: fast, deep beats (the wing tips clap close above and below the body); a chick's
+    // stubby wings flutter above its round body (deep strokes dipped them into the ball of down)
+    flap: form.chick ? { freq: 8.5, amp: 70, mid: 30, down: 0.55, upFlex: 30, upWrist: 36, sweep: 12, twist: 12 } : { freq: 8.5, amp: 108, mid: 8, down: 0.55, upFlex: 40, upWrist: 48, sweep: 16, twist: 16 },
+    power: form.chick ? { freq: 9.6, amp: 78, mid: 32, down: 0.52, upFlex: 36, upWrist: 44, sweep: 14, twist: 14 } : { freq: 9.6, amp: 124, mid: 14, down: 0.52, upFlex: 52, upWrist: 62, sweep: 22, twist: 18 },
+    glideShare: 0.35,
+  };
+}
+
+// Flight feathers. 10 primaries (rounded galliform wing: p7-p8 longest; no emargination: the engine
+// bends notched primaries up under load by their notch, and the outer three rose through each other), 10
+// secondaries + tertials, 7 rectrices a side held as a steep "roof" (the two halves of the tail meet
+// in an inverted V: fanned up and back, vanes near vertical); roosters add two sickles a side (long,
+// arching central coverts) and chicks have only short pin feathers.
+export function feathersFor(form = {}) {
+  const pk = form.priK ?? 1, rk = form.recK ?? 1, wk = form.fwK ?? 1;
+  // Stacking (every card lies on its neighbour, none cuts through it, folded or spread): each feather's
+  // root is lifted 0.8 mm above the next one in the overlap order (primaries: inner on top; secondaries:
+  // the tertials on top, all above the primaries), with nearly flat vanes (arch 3 % of the half width:
+  // the default 12 % dropped a neighbour's vane edge through the next card wherever they overlap
+  // sideways), little twist and droop (a twisted vane crossed its fanned neighbour); the folded
+  // primaries lie almost along the hand, under the secondaries (steeper fold angles lifted their outer
+  // vanes over the top of the wing into the back).
+  const LP = 0.0008, LS = 0.0008, LS0 = 0.008, ARCH = 0.03;
+  const P = [
+    [0.06, 0.128, 78, -4], [0.16, 0.136, 70, -2.5], [0.26, 0.145, 62, -1], [0.36, 0.154, 54, 0.5], [0.46, 0.163, 46, 2.7],
+    [0.56, 0.171, 38, 2.5], [0.66, 0.178, 30, 2.3], [0.76, 0.18, 22, 2], [0.87, 0.172, 14, 1], [0.98, 0.15, 6, 0.5],
+  ];
+  const primaries = P.map(([u, len, spread, fold], i) => ({ u, len: len * pk, width: 0.036 * wk, spread, fold, emarg: 0, tipRound: 0.5, outer: i < 3 ? 0.42 : 0.34, lift: (P.length - 1 - i) * LP, twist: 1, droop: 0.01, curve: 0.03, arch: ARCH,
+    // the innermost primary coverts lie wholly under the covert shield when folded (their roots at the
+    // wrist cut out through its front rim); the first one a little higher (half open, it crossed the
+    // third secondary under the shield's thin front)
+    ...(i < 2 ? { cov: { shift: 0.004, lenK: 0.3, ...(i === 0 && !form.chick ? { lift: 0.003 } : {}) } } : {}) }));
+  // (the tertials, innermost, are shorter: their rounded ends step up along the folded wing's top)
+  const S = [[0.03, 0.122], [0.13, 0.123], [0.23, 0.123], [0.33, 0.122], [0.43, 0.12], [0.53, 0.118], [0.63, 0.116], [0.73, 0.128], [0.83, 0.118], [0.93, 0.108]];
+  // greater coverts: sculpted as skin (sculpt.js coverts(): the shingled shield of the folded wing), no
+  // covert cards (a chick keeps its little covert cards: without them the metrics put its lying shank
+  // skin 0.8 mm into the ground, seed 3 - the cause is in the engine's lie, not traced)
+  // (a chick's inner secondaries are short pin feathers: longer ones swept into its round body as the wing
+  // opened and folded)
+  const ST = form.chick ? [1, 1, 1, 1, 1, 1, 0.9, 0.7, 0.62, 0.55] : null;
+  const secondaries = S.map(([u, len], i) => ({
+    u, len: (ST ? Math.min(len, 0.122) * ST[i] : len) * pk, width: 0.046 * wk, spread: 90 + i * 3.5, fold: 163 + i * 1.2, tipRound: i >= 7 && !form.chick ? 0.32 : 0.6, ...(i >= 7 && !form.chick ? { base0: 0.6 } : {}), outer: 0.42, lift: LS0 + i * LS, twist: 1, arch: ARCH,
+    cov: { skip: true },
+  }));
+  // rectrices: central -> outer. `bend` lifts the feather out of the tail plane (the pygostyle already
+  // points up and back), `twist` stands the vane up (roof), `fan` spreads it sideways when fanned. A hen's
+  // roof is steep at the ridge (the central pairs near vertical, 80 / 74 deg; at 68 the second crossed the
+  // first) and opens to 58 deg at the sides (at 44-50 the outer pairs' inner vanes met under the ridge),
+  // her rectrices straight (curved in toward the midline, the two halves crossed); a rooster's arched
+  // rectrices sit 6 mm further out from the midline with their vanes on edge (nearly vertical: each arc
+  // curves back and down in its own side's plane; tilted like a hen's roof, the arcs of the two sides
+  // curved in to the midline and crossed under the tail). No covert cards on the rectrices (each one's
+  // covert crossed its inner neighbour or the other side's at the ridge as the tail swayed and fanned;
+  // the uppertail coverts' mass, the saddle and the sickles cover the base), and a rooster's second sickle
+  // fans no wider than his first rectrix (at 6 deg it crossed it in the landing flare).
+  const R = [
+    [0.002, 0.13, 3, 12], [0.004, 0.128, 7, 6], [0.006, 0.125, 12, 0], [0.008, 0.12, 17, -6],
+    [0.01, 0.113, 22, -12], [0.012, 0.105, 27, -18], [0.014, 0.096, 32, -24],
+  ];
+  const rectrices = R.map(([x, len, fan, bend], i) => ({
+    x: form.sickles ? x * 1.4 + 0.006 : x, len: len * rk, width: (form.sickles ? 0.034 : 0.042) * wk, fan, fold: 1 + i * 0.4, bend: bend + (form.sickles ? -6 : 0), twist: form.sickles ? 90 - i : i === 0 ? 80 : i === 1 ? 74 : 72 - i * 2, lift: 0.0024 - i * 0.0003,
+    tipRound: 0.62, outer: 0.44, arc: form.sickles ? 55 + i * 5 : 0, cov: { skip: true },
+  }));
+  if (form.sickles) {
+    // sickles: long, narrow, arching back and down over the tail (roosters)
+    const sk = form.sickles;
+    rectrices.push(
+      { x: 0.001, len: 0.36 * sk, width: 0.03 * wk, fan: 2, fold: 0.5, bend: 30, twist: 90, lift: 0.004, tipRound: 0.8, outer: 0.46, arc: 118, droop: 0.02 },
+      { x: 0.003, len: 0.3 * sk, width: 0.026 * wk, fan: 3, fold: 1, bend: 18, twist: 90, lift: 0.0035, tipRound: 0.8, outer: 0.46, arc: 108, droop: 0.02 },
+    );
+  }
+  return { primaries, secondaries, rectrices, coverts: { primary: 0.4, secondary: 0.5, tail: form.sickles ? 0.62 : 0.55 } };
+}
+
+export const WING = wingFor();
+export const FEATHERS = feathersFor();
+
+const base = {
+  gears: { walk: 0.55, run: 1.9, fly: 5 },
+  maxSpeed: 7,
+  ground: { maxSpeed: 3.6, accel: [2.5, 5], decel: 5.5, turnRate: 5 },
+  gaits: [
+    // slow foraging walk -> preferred walk -> fast walk (head bob every step)
+    G('walk', 0.0, 1.3, 0.74, [0, 0.5], { lift: 0.03, bob: 0.004, sway: 0.008, pitch: 0, headBob: 1, wings: 0, tail: 0.5 }),
+    G('walk', 0.55, 1.9, 0.66, [0, 0.5], { lift: 0.038, bob: 0.006, sway: 0.009, pitch: -2, headBob: 1, wings: 0, tail: 0.7 }),
+    G('walk', 0.95, 2.4, 0.6, [0, 0.5], { lift: 0.04, bob: 0.007, sway: 0.007, pitch: -5, headBob: 0.8, wings: 0.03, tail: 0.7 }),
+    // grounded run (no aerial phase), then an aerial sprint; the wings stay folded on the body (part
+    // open they stood off the flank)
+    G('run', 1.4, 2.9, 0.52, [0, 0.5], { lift: 0.042, bob: 0.006, sway: 0.004, pitch: -12, headBob: 0.25, wings: 0, tail: 0.5 }),
+    G('run', 2.6, 3.6, 0.42, [0, 0.5], { lift: 0.046, bob: 0.005, sway: 0.003, pitch: -18, headBob: 0.05, wings: 0, tail: 0.4 }),
+  ],
+  feet: { spread: [0, 24, 2, -26], curl: 75, grip: 1, pad: 0.009, hock: 0.0085, sole: 0.0125 },
+  // belly section (bind, ref size): centre height, half height, half width
+  body: { tilt: 22, belly: { y: 0.15, hh: 0.08, hw: 0.068 } },
+  head: { bob: 1.33, bobHold: 0.62, yaw: 2.6, pitchUp: 1.0, pitchDown: 1.25, saccade: 1, cock: 0.45, jawRest: -2, radius: 0.017 },
+  tail: { walkBob: 5, sway: 4, flick: 1, fanRest: 0.02 },
+  wing: WING,
+  feathers: FEATHERS,
+  flight: {
+    minSpeed: 2.6, cruise: 5, maxSpeed: 7, climb: [2.4, -3.5], bankMax: 45, turnRate: 3.2,
+    clearance: 0.8, glideRatio: 2.5, sustained: false, maxTime: 2.5,
+  },
+  takeoff: { crouch: 0.18, jump: 2.4, angle: 50, beats: 6 },
+  landing: { approach: 4, flare: 0.4, touch: 1.2 },
+  actions: {
+    attack: { style: 'peck' },
+    // scratch the ground (two rakes of one foot, one or two of the other, step back), then peck
+    eat: { style: 'scratch', rate: 2.6 },
+    drink: {},
+    jump: { height: 0.25, distance: 0.35 },
+    // lying at rest with the wings folded on the body (the engine's default lie droops and part spreads
+    // them, sunning)
+    lie: { wings: 0 },
+    death: { wings: 0 },
+    // roosting: fluffed, settled on the hocks, head drawn into the shoulders (fluffed less than the engine's
+    // default: the torso swells about the hips and the flank rose into the folded primaries)
+    sleep: { style: 'sink', fluff: 0.4 },
+    idle: {},
+  },
+};
+
+// per-individual overrides (sex, age): read by the bird engine (motion.individual)
+function individual(p = {}) {
+  const out = {};
+  const form = p.form || {};
+  if (form.wingK || form.priK || form.recK || form.sickles) {
+    out.wing = wingFor(form);
+    out.feathers = feathersFor(form);
+  }
+  if (p.age === 'juvenile') {
+    // chicks: short quick steps, no real flight (a flutter), peeping bill
+    // (short legs: quicker, shorter steps and lower speeds than a scaled-down hen)
+    out.gaits = base.gaits.map((g) => ({ ...g, f: g.f * 1.1, lift: g.lift * 1.1 }));
+    out.gears = { walk: 0.4, run: 1.25, fly: 3.2 };
+    out.ground = { ...base.ground, maxSpeed: 2.4 };
+    out.maxSpeed = 4;
+    out.flight = { ...base.flight, minSpeed: 2, cruise: 3.2, maxSpeed: 4, maxTime: 0.6, climb: [1.2, -3] };
+    out.body = { tilt: 18, belly: { y: 0.15, hh: 0.075, hw: 0.075 } };
+    out.actions = { ...base.actions, attack: { style: 'peck' }, eat: { style: 'peck', rate: 3 } };
+    out.feet = { ...base.feet, pad: 0.011 };
+  } else if (p.sex === 'male') {
+    // roosters: flapping jump-kick with the spurs; crow as an idle behaviour
+    out.actions = { ...base.actions, attack: { style: 'spur' }, idle: { crow: 0.22 } };
+    // the sickle tail stays half raised in flight (it would sweep the ground in the landing flare)
+    out.tail = { ...base.tail, flight: 0.45 };
+  }
+  return out;
+}
+
+export const motion = { ...base, individual };