@bitefoundry/retrieviewer 0.0.2 → 0.0.4

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

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

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

@@ -1,177 +0,0 @@
-// 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 };