@bitefoundry/retrieviewer 0.0.0-stage → 0.0.1

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

@@ -0,0 +1,66 @@
+// The folded wing's tertials (sec8-10, the top of the folded stack behind the shield) read as contour
+// feathers: their top layers are restyled from vane cards to material FEATHER (the body's shingle shading,
+// the wing tract's colour and markings) with the body's down shells (furLen), so the rear of the folded
+// wing continues the plumage (as vanes they were one flat, glossy panel). Their undersides stay vanes.
+import { MAT } from '../../core/build/coatKit.js';
+
+// the cards of a featherCards block: [{ bone, start, n, top: [start, start + n / 2) }]
+export function cardBlocks(fc, boneNames) {
+  const out = [];
+  let v = 0;
+  const nV = fc.nV;
+  // runs of one bone; each run holds 1 or 2 cards of equal size (feather, covert)
+  const runs = [];
+  while (v < nV) {
+    const b = fc.skinIndex[v * 4];
+    let e = v; while (e < nV && fc.skinIndex[e * 4] === b) e++;
+    runs.push([b, v, e]); v = e;
+  }
+  const cs = Math.min(...runs.map(([, a, e]) => e - a));
+  for (const [b, a, e] of runs) for (let k = 0; a + k * cs < e; k++) out.push({ bone: b, name: boneNames[b], covert: k > 0, start: a + k * cs, n: cs });
+  return out;
+}
+
+export function restyleWing(fc, rig, look) {
+  if (!look) return fc;
+  const names = rig.BONES.map((b) => b.name);
+  for (const c of cardBlocks(fc, names)) {
+    const m = /^sec(\d+)[LR]$/.exec(c.name);
+    if (!m || c.covert) continue;
+    const i = +m[1] - 1;
+    if (i < 7) continue;
+    for (let v = c.start; v < c.start + c.n / 2; v++) {
+      fc.tint.set([look.rgb[0], look.rgb[1], look.rgb[2], MAT.FEATHER], v * 4);
+      fc.surf.set([look.gloss, look.size, look.mz, look.irid], v * 4);
+      fc.pattern[v] = 1;
+      fc.furLen[v] = look.fur ?? 0;
+      if (look.mcol) fc.patternColor.set([look.mcol[0], look.mcol[1], look.mcol[2], 0], v * 4);
+    }
+  }
+  return fc;
+}
+
+// A chick's wing is down-covered skin with at most a few short pin feathers at its tip: its flight-feather
+// cards (narrow pin-feather cards, motion.js feathersFor) are restyled as down, both faces material FUR
+// with the down shells of the wing tract around them (the top the colour of the down on the folded wing's
+// bed, the underside the pale underwing), so the folded wing reads as part of the ball of down and the
+// flapping wing as a small downy wing (as plain vanes they were a pale opaque lens on the down).
+// look: { top: rgb, under: rgb, fur (m), furUnder (m, the underside's short down), furTip (fraction of fur left at the tip), size, gloss }
+export function downyWing(fc, rig, look) {
+  if (!look) return fc;
+  const names = rig.BONES.map((b) => b.name);
+  for (const c of cardBlocks(fc, names)) {
+    if (!/^(pri|sec)\d+[LR]$/.test(c.name)) continue;
+    for (let v = c.start; v < c.start + c.n; v++) {
+      const top = v < c.start + c.n / 2;
+      const t = fc.surf[v * 4 + 3], k = 1 + 0.05 * Math.sin(v * 0.37);
+      const rgb = top ? look.top : look.under;
+      fc.tint.set([rgb[0] * k, rgb[1] * k, rgb[2] * k, MAT.FUR], v * 4);
+      fc.surf.set([look.gloss, look.size, 0, 0], v * 4);
+      fc.pattern[v] = 1;
+      fc.furLen[v] = (top ? look.fur : look.furUnder ?? look.fur) * (1 - (1 - look.furTip) * t);
+      fc.patternColor.set([0, 0, 0, 0], v * 4);
+    }
+  }
+  return fc;
+}

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

@@ -0,0 +1,124 @@
+// The stack of flight-feather cards seen in the forearm's plan: a height map of the top card above the
+// wing plane, the highest over the wing's motion (folded, half open, spread and over-fanned). The covert
+// shield on the forearm (sculpt.js coverts()) and the greater covert cards along its rim (coverts.js)
+// are placed from it, so the coverts lie ON the stack (a small gap above its top card) in every pose and
+// no flight feather comes out through them.
+//
+// Plan frame (the ulna's): x from the wrist toward the elbow, y toward the trailing edge, h along the
+// wing's dorsal normal; mm, for this individual (not normalised by the wing's size).
+import { wingFK, makeWingFrames, degs, featherFrame, makeFeatherFrame, resolveFeathers, extension, DEG } from '../../core/rig/bird.js';
+import { vaneWidth } from '../../core/build/featherCards.js';
+import { wingFor, feathersFor } from './motion.js';
+
+const V = (o) => [o.x, o.y, o.z];
+const add = (a, b, k) => [a[0] + b[0] * k, a[1] + b[1] * k, a[2] + b[2] * k];
+const cross = (a, b) => [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const nrm = (a) => { const l = Math.hypot(a[0], a[1], a[2]) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
+
+// wing states between folded (0) and spread (1, glide), the feather fan up to the engine's over-fan
+export const STACK_STATES = [0, 0.15, 0.3, 0.5, 0.7, 0.85, 1, 1.2];
+
+const cache = new Map();
+/**
+ * @returns { at(x, y) -> top card height (mm, max over the states) or -Infinity where no card lies,
+ *            fold(x, y) -> the same, folded only, cell (mm) }
+ */
+export function wingStack(form = {}, states = STACK_STATES) {
+  const key = JSON.stringify([form.wingK, form.priK, form.fwK, form.chick, form.up, states]);
+  if (cache.has(key)) return cache.get(key);
+  const W = wingFor(form), F = resolveFeathers(feathersFor(form)), cov = F.coverts;
+  const L = { h: W.lengths[0], u: W.lengths[1], m: W.lengths[2] };
+  const cell = 1, X0 = -40, Y0 = -70, NX = 320, NY = 160;
+  const maxH = new Float32Array(NX * NY).fill(-Infinity), foldH = new Float32Array(NX * NY).fill(-Infinity);
+  const ff = makeFeatherFrame();
+  for (const e of states) {
+    const eW = Math.min(1, e), cfg = Object.fromEntries(Object.keys(W.fold).map((k) => [k, W.fold[k] + (W.glide[k] - W.fold[k]) * eW]));
+    const fr = wingFK(makeWingFrames(), 1, L, degs(cfg));
+    const eH = Math.min(1.25, extension(cfg.wrist * DEG, W.fold.wrist * DEG, W.glide.wrist * DEG) + Math.max(0, e - 1));
+    const eU = Math.min(1.2, extension(cfg.elbow * DEG, W.fold.elbow * DEG, W.glide.elbow * DEG) + Math.max(0, e - 1));
+    const P0 = V(fr.wrist), dU = V(fr.dU), nU = V(fr.nU), tU = nrm(cross(nU, dU)), X = dU.map((x) => -x);
+    const proj = (p) => { const q = [p[0] - P0[0], p[1] - P0[1], p[2] - P0[2]]; return [dot(q, X) * 1000, dot(q, tU) * 1000, dot(q, nU) * 1000]; };
+    const P0o = { x: P0[0], y: P0[1], z: P0[2] };
+    const raster = (f, o = {}) => {
+      const A = V(ff.axis), N = V(ff.normal), Tv = nrm(cross(N, A));
+      const fo = o.shape ? { ...f, ...o.shape } : f;
+      const len = f.len * (o.lenK || 1), w = f.width * (o.widthK || 1);
+      const root = add(add(V(ff.root), N, o.lift || 0), A, o.shift || 0), arch = fo.arch ?? 0.12;
+      // the card's top layer on a (t, c) grid
+      const nt = 24, nc = 6, G = [];
+      for (let i = 0; i <= nt; i++) {
+        const t = i / nt, [wo, wi] = vaneWidth(fo, Math.min(t, 0.999), w), cu = (fo.curve || 0) * len * t * t, dr = (fo.droop || 0) * len * t * t;
+        const row = [];
+        for (let j = 0; j <= nc; j++) {
+          const c = -1 + 2 * j / nc, ww = c < 0 ? wo : wi;
+          let p = add(root, A, t * len);
+          p = add(p, Tv, cu + c * ww);
+          p = add(p, N, -dr - Math.abs(c) * ww * arch + 0.00025);
+          row.push(proj(p));
+        }
+        G.push(row);
+      }
+      for (let i = 0; i < nt; i++) for (let j = 0; j < nc; j++) {
+        const a = G[i][j], b = G[i + 1][j], c = G[i + 1][j + 1], d = G[i][j + 1];
+        tri(a, b, c); tri(a, c, d);
+      }
+    };
+    const tri = (a, b, c) => {
+      const x0 = Math.floor((Math.min(a[0], b[0], c[0]) - X0) / cell), x1 = Math.ceil((Math.max(a[0], b[0], c[0]) - X0) / cell);
+      const y0 = Math.floor((Math.min(a[1], b[1], c[1]) - Y0) / cell), y1 = Math.ceil((Math.max(a[1], b[1], c[1]) - Y0) / cell);
+      const den = (b[1] - c[1]) * (a[0] - c[0]) + (c[0] - b[0]) * (a[1] - c[1]);
+      if (Math.abs(den) < 1e-9) return;
+      for (let iy = Math.max(0, y0); iy <= Math.min(NY - 1, y1); iy++) for (let ix = Math.max(0, x0); ix <= Math.min(NX - 1, x1); ix++) {
+        const px = X0 + ix * cell, py = Y0 + iy * cell;
+        const l1 = ((b[1] - c[1]) * (px - c[0]) + (c[0] - b[0]) * (py - c[1])) / den;
+        const l2 = ((c[1] - a[1]) * (px - c[0]) + (a[0] - c[0]) * (py - c[1])) / den;
+        const l3 = 1 - l1 - l2;
+        // (a cell touched by the triangle's edge counts: the outline is conservative by ~half a cell)
+        if (l1 < -0.08 || l2 < -0.08 || l3 < -0.08) continue;
+        const h = l1 * a[2] + l2 * b[2] + l3 * c[2], k = iy * NX + ix;
+        if (h > maxH[k]) maxH[k] = h;
+        if (e === 0 && h > foldH[k]) foldH[k] = h;
+      }
+    };
+    for (const f of F.primaries) {
+      featherFrame(ff, P0o, fr.dM, fr.nM, L.m, 1, f, f.fold + (f.spread - f.fold) * eH, false);
+      raster(f);
+      if (!f.cov?.skip) raster(f, { lenK: cov.primary * (1 - 0.25 * f.i / Math.max(1, f.n - 1)), widthK: 1.05, lift: 0.0022, shift: -0.004, ...(f.cov || {}), shape: { emarg: 0, tipRound: 0.6, outer: 0.45, curve: 0.02, ...(f.cov?.shape || {}) } });
+    }
+    for (const f of F.secondaries) {
+      featherFrame(ff, P0o, fr.dU, fr.nU, L.u, 1, f, f.fold + (f.spread - f.fold) * eU, true);
+      raster(f);
+      if (!f.cov?.skip) raster(f, { lenK: cov.secondary, widthK: 1.15, lift: 0.0028, shift: -0.006, ...(f.cov || {}), shape: { tipRound: 0.65, outer: 0.45, curve: 0.02, ...(f.cov?.shape || {}) } });
+    }
+  }
+  const look = (A) => (x, y) => {
+    const ix = Math.round((x - X0) / cell), iy = Math.round((y - Y0) / cell);
+    if (ix < 0 || iy < 0 || ix >= NX || iy >= NY) return -Infinity;
+    return A[iy * NX + ix];
+  };
+  // the highest card within r mm of (x, y) (a footprint's clearance)
+  const near = (A) => (x, y, r = 1) => {
+    let m = -Infinity;
+    const ix0 = Math.round((x - X0) / cell), iy0 = Math.round((y - Y0) / cell), R = Math.ceil(r / cell);
+    for (let iy = iy0 - R; iy <= iy0 + R; iy++) for (let ix = ix0 - R; ix <= ix0 + R; ix++) {
+      if (ix < 0 || iy < 0 || ix >= NX || iy >= NY) continue;
+      if ((ix - ix0) ** 2 + (iy - iy0) ** 2 > R * R) continue;
+      m = Math.max(m, A[iy * NX + ix]);
+    }
+    return m;
+  };
+  const out = { at: look(maxH), fold: look(foldH), near: near(maxH), cell };
+  cache.set(key, out);
+  return out;
+}
+
+// point in polygon (plan)
+export function insidePoly(poly, x, y) {
+  let c = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const a = poly[i], b = poly[j];
+    if ((a[1] > y) !== (b[1] > y) && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0]) c = !c;
+  }
+  return c;
+}