@bitefoundry/retrieviewer 0.0.3 → 0.0.4

package/vendor/procedural-animals/src/core/rig/snake.js

@@ -1,76 +0,0 @@
-// Standard snake skeleton (the names the snake motion engine, core/motion/snake.js, expects).
-//
-// Axial chain, head to tail tip:  nose <- v0 -> v1 -> ... -> vN
-//   head        v0 -> nose            (v0 = occiput / atlas, the head's pivot on the neck)
-//   spine0..    v(i) -> v(i+1)        (N bones, each pointing tail-ward; spine0 is the root bone)
-// Rigid parts riding on the head (each meshed as its own rigid region):
-//   jaw         jawHinge -> jawTip    (lower jaw, rotates about the quadrate hinge)
-//   tongue      tongueBase -> tongueFork   (tongue shaft; slides forward out of its sheath in the jaw)
-//   tongueTip   tongueFork -> tongueTip    (the forked tips; flick up and down)
-//   fang        fangBase -> fangTip   (hinged maxillary fangs of vipers; folded along the palate at rest)
-// A rattle (or any tail-tip ornament) is meshed as a rigid region on the last spine bone.
-//
-// Bind pose: the snake lies straight along -Z with its belly on y = 0; joint vi sits on the body axis
-// at height = the distance from the axis to the belly (the engine reads it back as the axis height).
-// Joints are on the midline (no left/right pairs).
-
-/**
- * Spine joints v0..vN from a list of segment lengths and axis heights.
- * @param J        joint table to fill
- * @param z0       z of v0 (the occiput)
- * @param lens     N segment lengths (m), head -> tail
- * @param height   (sigma, t) -> axis height above the belly at arc distance sigma from v0 (t = sigma / total)
- */
-export function snakeSpine(J, z0, lens, height) {
-  const total = lens.reduce((a, b) => a + b, 0);
-  let s = 0;
-  J.v0 = [0, height(0, 0), z0];
-  // place joints by arc length along the (slightly tilted) axis so bone lengths equal `lens`
-  let z = z0;
-  for (let i = 0; i < lens.length; i++) {
-    s += lens[i];
-    const y = height(s, s / total);
-    const dy = y - J['v' + i][1];
-    z -= Math.sqrt(Math.max(1e-10, lens[i] * lens[i] - dy * dy));
-    J['v' + (i + 1)] = [0, y, z];
-  }
-  return J;
-}
-
-/** Bone list: head, jaw, tongue, tongueTip, fang, spine0..spine(n-1). */
-export function snakeBones(n, { neck = 4, tail = 0 } = {}) {
-  const b = [];
-  for (let i = 0; i < n; i++) {
-    const region = i < neck ? 'neck' : i >= n - tail ? 'tail' : 'torso';
-    b.push(['spine' + i, 'v' + i, 'v' + (i + 1), i === 0 ? null : 'spine' + (i - 1), { region }]);
-  }
-  b.push(
-    ['head', 'v0', 'nose', 'spine0', { region: 'head' }],
-    ['jaw', 'jawHinge', 'jawTip', 'head', { region: 'jaw', group: 'jaw' }],
-    ['tongue', 'tongueBase', 'tongueFork', 'jaw', { region: 'tongue', group: 'tongue' }],
-    ['tongueTip', 'tongueFork', 'tongueTip', 'tongue', { region: 'tongue', group: 'tongue' }],
-    ['fang', 'fangBase', 'fangTip', 'head', { region: 'fang', group: 'fang' }],
-  );
-  return b;
-}
-
-/** Axial chain description for buildRig (skin weights along nose -> tail tip). */
-export function snakeAxial(n) {
-  return {
-    points: ['nose', ...Array.from({ length: n + 1 }, (_, i) => 'v' + i)],
-    bones: ['head', ...Array.from({ length: n }, (_, i) => 'spine' + i)],
-  };
-}
-
-/** Segment lengths for n bones over `total` metres: uniform, shortened toward the tail tip so the
- *  thin tail can curl tightly (tipShrink = length of the last bone relative to the others). */
-export function snakeSegments(n, total, { tipShrink = 0.55, tipBones = 8, neckShrink = 0.85, neckBones = 3 } = {}) {
-  const w = Array.from({ length: n }, (_, i) => {
-    let k = 1;
-    if (i >= n - tipBones) k = 1 - (1 - tipShrink) * ((i - (n - tipBones) + 1) / tipBones);
-    if (i < neckBones) k = neckShrink + (1 - neckShrink) * (i / neckBones);
-    return k;
-  });
-  const sw = w.reduce((a, b) => a + b, 0);
-  return w.map((k) => (k * total) / sw);
-}

package/vendor/procedural-animals/src/core/rig/spider.js

@@ -1,110 +0,0 @@
-// Standard spider skeleton (the names the spider motion engine expects) and helpers to build it.
-//
-// Axial (nose -> tail): front (clypeus) - ceph (cephalic / thoracic boundary) - pedA (rear of the
-//   carapace, pedicel start) - pedB (pedicel end, abdomen front) - abdEnd (above the spinnerets) -
-//   spinTip. Bones: head (ceph -> front, rigid on the prosoma, carries the eyes), prosoma (root,
-//   pedA -> ceph), pedicel, abdomen, spinnerets.
-// Chelicerae: cheBase{S} -> cheTip{S} (bone chelicera{S}), fang cheTip{S} -> fangTip{S} (fang{S}).
-// Legs i = 1..4 (I front .. IV hind), 7 segments each: coxa, troch, femur, patella, tibia, meta,
-//   tarsus. The joint named after a segment is where that segment starts; `claw{i}{S}` is the tip.
-//   Bones carry the same names as their start joint (coxa1L = coxa1L -> troch1L ...); groups 'L1' ..
-//   'R4' (the metrics and state.legs keys); the tarsus is the 'foot' region.
-// Pedipalps: palpCoxa, palpTroch, palpFemur, palpPatella, palpTibia, palpTarsus (+ palpTip), group
-//   'P{S}', no foot region (palps are not walking legs).
-import { add, mul } from '../math/vec.js';
-
-export const LEG_SEGS = ['coxa', 'troch', 'femur', 'patella', 'tibia', 'meta', 'tarsus'];
-export const PALP_SEGS = ['palpCoxa', 'palpTroch', 'palpFemur', 'palpPatella', 'palpTibia', 'palpTarsus'];
-export const LEG_KEYS = ['L1', 'L2', 'L3', 'L4', 'R1', 'R2', 'R3', 'R4'];
-export const AXIAL_POINTS = ['front', 'ceph', 'pedA', 'pedB', 'abdEnd', 'spinTip'];
-export const AXIAL_BONES = ['head', 'prosoma', 'pedicel', 'abdomen', 'spinnerets'];
-
-/** joint names of leg i (1..4) on side S ('L' | 'R'), base -> claw tip */
-export const legJoints = (i, S) => [...LEG_SEGS.map((g) => g + i + S), 'claw' + i + S];
-export const legBones = (i, S) => LEG_SEGS.map((g) => g + i + S);
-export const palpJoints = (S) => [...PALP_SEGS.map((g) => g + S), 'palpTip' + S];
-export const palpBones = (S) => PALP_SEGS.map((g) => g + S);
-
-// Direction of a segment in a vertical leg plane: azimuth phi from forward (+Z) toward the leg's
-// side (side = +1 left, -1 right), elevation e above horizontal.
-export function planeDir(phi, e, side) {
-  const c = Math.cos(e);
-  return [Math.sin(phi) * c * side, Math.sin(e), Math.cos(phi) * c];
-}
-
-/**
- * Writes a planar chain into J: joints names[0..n] starting at base, segment k along azimuth
- * az[k] (or one number) and elevation el[k] (radians), length lens[k].
- */
-export function planarChain(J, names, base, az, el, lens, side) {
-  let p = base.slice();
-  J[names[0]] = p.slice();
-  for (let k = 0; k < lens.length; k++) {
-    const a = Array.isArray(az) ? az[k] : az;
-    p = add(p, mul(planeDir(a, el[k], side), lens[k]));
-    J[names[k + 1]] = p;
-  }
-  return J;
-}
-
-/**
- * Bind-pose leg: finds the elevation of segment `free` so that the claw tip ends at height yTip.
- * Returns the elevations used (radians). If the target cannot be met the free segment is clamped
- * to straight down / up.
- */
-export function solveBindElevations(yBase, lens, el, free, yTip) {
-  let drop = 0;
-  for (let k = 0; k < lens.length; k++) if (k !== free) drop += lens[k] * Math.sin(el[k]);
-  const s = (yTip - yBase - drop) / lens[free];
-  const out = el.slice();
-  out[free] = Math.asin(Math.max(-1, Math.min(1, s)));
-  return out;
-}
-
-export function spiderBones({ chelicerae = true, palps = true, spinnerets = true, extra = [] } = {}) {
-  const b = [
-    ['prosoma', 'pedA', 'ceph', null, { region: 'torso' }],
-    ['head', 'ceph', 'front', 'prosoma', { region: 'head' }],
-    ['pedicel', 'pedA', 'pedB', 'prosoma', { region: 'torso' }],
-    ['abdomen', 'pedB', 'abdEnd', 'pedicel', { region: 'torso' }],
-  ];
-  if (spinnerets) b.push(['spinnerets', 'abdEnd', 'spinTip', 'abdomen', { region: 'tail' }]);
-  if (chelicerae) {
-    b.push(['chelicera{S}', 'cheBase{S}', 'cheTip{S}', 'head', { region: 'jaw', group: 'chel{S}' }]);
-    b.push(['fang{S}', 'cheTip{S}', 'fangTip{S}', 'chelicera{S}', { region: 'jaw', group: 'fang{S}' }]);
-  }
-  if (palps) {
-    const pj = palpJoints('{S}'), pb = palpBones('{S}');
-    pb.forEach((name, k) => b.push([name, pj[k], pj[k + 1], k === 0 ? 'prosoma' : pb[k - 1], { region: 'limb', group: 'P{S}' }]));
-  }
-  for (let i = 1; i <= 4; i++) {
-    const lj = legJoints(i, '{S}'), lb = legBones(i, '{S}');
-    lb.forEach((name, k) => b.push([name, lj[k], lj[k + 1], k === 0 ? 'prosoma' : lb[k - 1], { region: k === 6 ? 'foot' : 'limb', group: '{S}' + i }]));
-  }
-  return b.concat(extra);
-}
-
-// Limb descriptions for the harmonic limb weights (see core/build/weights.js). The limb core starts
-// part way along the coxa (tCore of the way from the coxa base to the femur base), so the coxa's
-// arthrodial membrane blends into the prosoma.
-export function spiderLimbs({ leg = {}, palp = {} } = {}) {
-  const L = {};
-  for (const S of ['L', 'R']) {
-    const side = S === 'L' ? 1 : -1;
-    for (let i = 1; i <= 4; i++) {
-      const bones = legBones(i, S);
-      L[S + i] = {
-        side, S, front: i <= 2, leg: i,
-        bones, proximal: [bones[0]], distal: bones.slice(5),
-        field: { a: 'coxa' + i + S, b: 'femur' + i + S, top: bones[0], tCore: 0.45, aCore: 0.03, aBody: -0.05, midX: 0.0, ...leg },
-      };
-    }
-    const pb = palpBones(S);
-    L['P' + S] = {
-      side, S, front: true, palp: true,
-      bones: pb, proximal: [pb[0]], distal: pb.slice(4),
-      field: { a: 'palpCoxa' + S, b: 'palpFemur' + S, top: pb[0], tCore: 0.4, aCore: 0.03, aBody: -0.05, midX: 0.0, ...palp },
-    };
-  }
-  return L;
-}

package/vendor/procedural-animals/src/core/rig/swimmer.js

@@ -1,181 +0,0 @@
-// Standard swimmer skeleton (fish, sharks: the names the swimmer motion engine expects) and helpers
-// for sculpting fins as thin membranes.
-//
-// Axial chain (snout -> caudal fin tip; drives the body wave, and the median fins ride on it):
-//   joints  snout, spine0 (head-trunk joint, behind the skull), spine1 .. spine{N} (spine{N} = caudal
-//           base / hypural plate = caudal0), caudal1 .. caudal{M} (along the caudal fin; for a shark's
-//           heterocercal tail they climb into the upper lobe)
-//   bones   head (spine0 -> snout), spine0 .. spine{N-1}, caudal0 .. caudal{M-1}
-// Head:    jaw (jawHinge -> jawTip, lower jaw, rigid part), upperJaw (premaxBase -> premaxTip, optional:
-//          protrusion for suction feeding / shark bites), operculum{S} (opHinge -> opEdge, optional;
-//          auxiliary joint opLow{S} gives the hinge axis with opHinge)
-// Paired fins (appendages): pectoral{S} (pecBase -> pecTip, auxiliary pecUp{S}: a second point on the
-//          fin base line = the fold axis), pelvic{S} (pelBase -> pelTip, auxiliary pelFront{S})
-// Dorsal, anal and adipose fins are skinned to the spine (they follow the body wave); the caudal fin
-// to the caudal bones.
-//
-// Everything is measured from the joints, so any fish (or shark) shape works: the engine reads the
-// rest geometry of the chain (segment lengths and pitch, e.g. an up-turned heterocercal tail).
-import { add, sub, mul, norm, cross, dot, lerp, len } from '../math/vec.js';
-
-export const spineName = (i) => 'spine' + i;
-export const caudalName = (i) => 'caudal' + i;
-
-/** Joint list of the axial chain, snout -> caudal tip. */
-export function axialJoints(spineSegs, caudalSegs) {
-  const pts = ['snout'];
-  for (let i = 0; i <= spineSegs; i++) pts.push(spineName(i));
-  for (let i = 1; i <= caudalSegs; i++) pts.push(caudalName(i));
-  return pts;
-}
-/** Bone list of the axial chain, matching axialJoints (head first). */
-export function axialBones(spineSegs, caudalSegs) {
-  const b = ['head'];
-  for (let i = 0; i < spineSegs; i++) b.push(spineName(i));
-  for (let i = 0; i < caudalSegs; i++) b.push(caudalName(i));
-  return b;
-}
-
-/**
- * Standard swimmer bones for buildRig.
- * @param o { spineSegs, caudalSegs, jaw, upperJaw, opercula, pectoral, pelvic,
- *            pectoralParent, pelvicParent (spine bone names), extra }
- * The caudal chain's joint 0 is spine{N}: J.caudal0 must equal J['spine' + N] (swimmerJointsAlias does it).
- */
-export function swimmerBones({ spineSegs = 12, caudalSegs = 3, jaw = true, upperJaw = false, opercula = true, pectoral = true, pelvic = true, pectoralParent = 'spine0', pelvicParent = 'spine4', extra = [] } = {}) {
-  const b = [];
-  b.push([spineName(0), spineName(0), spineName(1), null, { region: 'torso' }]);
-  b.push(['head', spineName(0), 'snout', spineName(0), { region: 'head' }]);
-  for (let i = 1; i < spineSegs; i++) b.push([spineName(i), spineName(i), spineName(i + 1), spineName(i - 1), { region: 'torso' }]);
-  for (let i = 0; i < caudalSegs; i++) b.push([caudalName(i), caudalName(i), caudalName(i + 1), i === 0 ? spineName(spineSegs - 1) : caudalName(i - 1), { region: 'tail' }]);
-  if (jaw) b.push(['jaw', 'jawHinge', 'jawTip', 'head', { region: 'jaw', group: 'jaw' }]);
-  if (upperJaw) b.push(['upperJaw', 'premaxBase', 'premaxTip', 'head', { region: 'head', group: 'upperJaw' }]);
-  if (opercula) b.push(['operculum{S}', 'opHinge{S}', 'opEdge{S}', 'head', { region: 'head', group: 'operculum{S}' }]);
-  if (pectoral) b.push(['pectoral{S}', 'pecBase{S}', 'pecTip{S}', pectoralParent, { region: 'fin', group: 'pectoral{S}' }]);
-  if (pelvic) b.push(['pelvic{S}', 'pelBase{S}', 'pelTip{S}', pelvicParent, { region: 'fin', group: 'pelvic{S}' }]);
-  return b.concat(extra);
-}
-
-/** Appendage list (skin blended by SDF distance) for the optional head and paired-fin bones. */
-export function swimmerAppendages({ upperJaw = false, opercula = true, pectoral = true, pelvic = true, blend = [-0.003, 0.005] } = {}) {
-  const a = [];
-  const add2 = (g) => { for (const S of ['L', 'R']) a.push({ group: g + S, bone: g + S, blend }); };
-  if (opercula) add2('operculum');
-  if (pectoral) add2('pectoral');
-  if (pelvic) add2('pelvic');
-  if (upperJaw) a.push({ group: 'upperJaw', bone: 'upperJaw', blend });
-  return a;
-}
-
-/** The caudal chain starts at the last spine joint. */
-export function swimmerJointsAlias(J, spineSegs) {
-  J.caudal0 = J[spineName(spineSegs)].slice();
-  return J;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Fins as membranes: an outline polygon in the fin's plane, extruded to a thin slab (SDF T_FIN).
-// A fin is described by its rays: each ray runs from a point on the base line to a tip. The outline
-// is base0 (sunk into the body) -> ray tips (with optional notches between spiny rays) -> baseN (sunk).
-// The prim keeps the ray layout so the coat can paint the rays (phase between rays, fraction along).
-// ------------------------------------------------------------------------------------------------
-
-/**
- * @param m SDFModel
- * @param o { origin [x,y,z], u, v (in-plane axes, 3D), rays: [[bu, bv], [tu, tv]] (2D, u/v coords),
- *            sink: how far the base is pushed into the body (along -outward2D), notch: 0..1 depth of
- *            the membrane notch between ray tips (spiny fins), t: thickness, bone, group, tag, k,
- *            thin, round }
- * @returns the primitive (with prim.fin = { rays2D, origin, u, v })
- */
-export function sculptFin(m, o) {
-  const rays = o.rays;
-  const n = rays.length;
-  const sink = o.sink || 0;
-  const poly = [];
-  // base line direction (first base -> last base) and the side the tips are on
-  const b0 = rays[0][0], bN = rays[n - 1][0];
-  const bd = [bN[0] - b0[0], bN[1] - b0[1]];
-  const bl = Math.hypot(bd[0], bd[1]) || 1;
-  let nx = -bd[1] / bl, ny = bd[0] / bl; // normal to the base line
-  const tipMid = rays[Math.floor(n / 2)][1];
-  if ((tipMid[0] - b0[0]) * nx + (tipMid[1] - b0[1]) * ny < 0) { nx = -nx; ny = -ny; }
-  const sunk = (p) => [p[0] - nx * sink, p[1] - ny * sink];
-  poly.push(sunk(b0));
-  for (let i = 0; i < n; i++) {
-    poly.push(rays[i][1].slice());
-    if (o.notch && i < n - 1) {
-      const a = rays[i][1], b = rays[i + 1][1], ba = rays[i][0], bb = rays[i + 1][0];
-      const tm = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2], bm = [(ba[0] + bb[0]) / 2, (ba[1] + bb[1]) / 2];
-      const nt = typeof o.notch === 'function' ? o.notch(i) : o.notch;
-      poly.push([tm[0] + (bm[0] - tm[0]) * nt, tm[1] + (bm[1] - tm[1]) * nt]);
-    }
-  }
-  poly.push(sunk(bN));
-  const prim = m.fin({ o: o.origin, u: o.u, v: o.v, t: o.t, poly, bone: o.bone, group: o.group, tag: o.tag, k: o.k ?? o.t, round: o.round, part: o.part });
-  prim.thin = o.thin !== false;
-  const u = norm(o.u), nn = norm(cross(o.u, o.v)), v = cross(nn, u);
-  prim.fin = { rays: rays.map((r) => [r[0].slice(), r[1].slice()]), origin: o.origin.slice(), u, v, n: nn, name: o.name || o.tag };
-  return prim;
-}
-
-/** 2D coordinates of a 3D point in a fin's plane. */
-export function finUV(fin, p) {
-  const d = sub(p, fin.origin);
-  return [dot(d, fin.u), dot(d, fin.v)];
-}
-
-/**
- * Ray coordinates of a point in a fin: { phase: continuous ray index (0 .. n-1), along: 0 at the base,
- * 1 at the tip, dir: 3D ray direction there }. Points outside the fan are clamped to the nearest ray.
- */
-export function finRayCoords(fin, p) {
-  const q = finUV(fin, p);
-  const R = fin.rays, n = R.length;
-  // side of q relative to ray i (positive toward ray i+1)
-  const side = (i) => {
-    const [b, t] = R[i];
-    const dx = t[0] - b[0], dy = t[1] - b[1];
-    const l = Math.hypot(dx, dy) || 1;
-    return ((q[0] - b[0]) * -dy + (q[1] - b[1]) * dx) / l;
-  };
-  // orientation: does side increase from ray 0 to ray n-1?
-  const s0 = side(0), sN = side(n - 1);
-  const [b0, t0] = R[0], [bN] = R[n - 1];
-  const sgn = ((bN[0] - b0[0]) * -(t0[1] - b0[1]) + (bN[1] - b0[1]) * (t0[0] - b0[0])) >= 0 ? 1 : -1;
-  let phase;
-  if (s0 * sgn <= 0) phase = 0;
-  else if (sN * sgn >= 0) phase = n - 1;
-  else {
-    phase = 0;
-    let prev = s0 * sgn;
-    for (let i = 1; i < n; i++) {
-      const si = side(i) * sgn;
-      if (si <= 0) { phase = i - 1 + prev / (prev - si); break; }
-      prev = si;
-    }
-  }
-  const i0 = Math.min(n - 2, Math.floor(phase)), f = phase - i0;
-  const lp = (a, b) => [a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f];
-  const b = lp(R[i0][0], R[i0 + 1][0]), t = lp(R[i0][1], R[i0 + 1][1]);
-  const dx = t[0] - b[0], dy = t[1] - b[1];
-  const L2 = dx * dx + dy * dy || 1e-12;
-  const along = Math.max(0, Math.min(1.2, ((q[0] - b[0]) * dx + (q[1] - b[1]) * dy) / L2));
-  const dir3 = norm(add(mul(fin.u, dx), mul(fin.v, dy)));
-  return { phase, along, dir: dir3 };
-}
-
-/** Fan of rays between two base points toward tips given by angle (deg, in the u/v plane) and length. */
-export function fanRays({ base0, base1, n, angle0, angle1, length }) {
-  const rays = [];
-  for (let i = 0; i < n; i++) {
-    const t = n === 1 ? 0 : i / (n - 1);
-    const b = [base0[0] + (base1[0] - base0[0]) * t, base0[1] + (base1[1] - base0[1]) * t];
-    const a = ((angle0 + (angle1 - angle0) * t) * Math.PI) / 180;
-    const L = typeof length === 'function' ? length(t, i) : length;
-    rays.push([b, [b[0] + Math.cos(a) * L, b[1] + Math.sin(a) * L]]);
-  }
-  return rays;
-}
-
-export { lerp, len };

package/vendor/procedural-animals/src/core/sdf/eyeSocket.js

@@ -1,53 +0,0 @@
-// Eye geometry helpers shared by the sculpt (orbit, lids, almond aperture) and the eyeball shader.
-//
-// An eye spec (per species, head-local, left eye):
-//   c: centre [x,y,z] relative to the head origin; r: eyeball radius; back: how far the ball sits
-//   behind c; yaw: outward divergence (rad); pitch: upward tilt of the view axis (rad, optional);
-//   lid: lid skin thickness; R, d: the almond aperture is the intersection of two circles of radius R
-//   whose centres are offset -/+d (width = 2*sqrt(R^2-d^2), height = 2*(R-d)); off: aperture offset
-//   along the eye's up axis; tilt: roll of the aperture (inner corner lower for +);
-//   irisZ / irisR: iris plane depth and radius (eyeball-local).
-import { add, mul, frameZY } from '../math/vec.js';
-
-export function eyeFrameOf(E, headO, s) {
-  const c = [headO[0] + E.c[0] * s, headO[1] + E.c[1], headO[2] + E.c[2] - E.back];
-  const p = E.pitch || 0;
-  const z = [Math.sin(E.yaw) * Math.cos(p) * s, Math.sin(p), Math.cos(E.yaw) * Math.cos(p)];
-  const [x0, y0] = frameZY(z, [0, 1, 0]);
-  const ph = s * E.tilt;
-  const x = add(mul(x0, Math.cos(ph)), mul(y0, Math.sin(ph)));
-  const y = add(mul(x0, -Math.sin(ph)), mul(y0, Math.cos(ph)));
-  return { c, x, y, z };
-}
-
-// Adds an orbit hollow, a lid shell hugging the eyeball and the almond aperture cut into it.
-// `bone` is usually 'head'. `orbit` (optional) = { r:[rx,ry,rz], at:[u,v,w], k } in aperture frame.
-export function sculptEyeSocket(m, E, headO, s, { bone = 'head', orbit = null, zMax = null } = {}) {
-  const ef = eyeFrameOf(E, headO, s);
-  const at = (u, v, w) => add(add(add(ef.c, mul(ef.x, u)), mul(ef.y, v)), mul(ef.z, w));
-  if (orbit) m.ell({ bone, tag: 'orbit', c: at(orbit.at[0] * s, orbit.at[1], orbit.at[2]), axis: ef.z, up: ef.y, r: orbit.r, k: orbit.k ?? E.r * 0.65, carve: true });
-  m.sphere({ bone, tag: 'eyelid', c: ef.c, rad: E.r + E.lid, k: E.r * 0.4 });
-  m.lens({ bone, tag: 'eyesocket', c: add(ef.c, mul(ef.y, E.off)), x: ef.x, y: ef.y, z: ef.z, R: E.R, d: E.d, zMin: -E.r * 0.16, zMax: zMax ?? E.r * 2, k: E.r * 0.18, carve: true });
-  return ef;
-}
-
-// The aperture roll (E.tilt) that lays the almond's long axis along `axis` (e.g. the head axis: the eye
-// slit follows the face line), with the upper lid kept up. The long axis has no direction, so the roll
-// is the one within +-90 degrees of upright (the frame's y, the upper lid, stays on the upper side).
-// (A search for the largest dot(x, axis) over tilt in [-1.6, 1.6] does not do this: the left eye's
-// untilted x points backward, so such a search ends at the edge of its range and stands the almond on
-// end, the upper lid facing the ear.) Add the species' own roll to the result: + lowers the inner corner.
-export function apertureTiltAlong(E, headO, axis) {
-  const f = eyeFrameOf({ ...E, tilt: 0 }, headO, 1);
-  const k = axis[0] * f.z[0] + axis[1] * f.z[1] + axis[2] * f.z[2];
-  const a = [axis[0] - f.z[0] * k, axis[1] - f.z[1] * k, axis[2] - f.z[2] * k];
-  let ph = Math.atan2(a[0] * f.y[0] + a[1] * f.y[1] + a[2] * f.y[2], a[0] * f.x[0] + a[1] * f.x[1] + a[2] * f.x[2]);
-  if (ph > Math.PI / 2) ph -= Math.PI;
-  else if (ph < -Math.PI / 2) ph += Math.PI;
-  return ph;
-}
-
-// Aperture size in metres (for docs and checks).
-export function apertureSize(E) {
-  return { width: 2 * Math.sqrt(Math.max(0, E.R * E.R - E.d * E.d)), height: 2 * (E.R - E.d) };
-}

package/vendor/procedural-animals/src/core/sdf/mesher.js

@@ -1,238 +0,0 @@
-// Narrow-band Surface Nets polygoniser for the SDF model.
-// Coarse pass finds cells near the zero set; only those are refined to the fine grid.
-// Vertices are projected onto the true surface (Newton steps along the SDF gradient)
-// and normals come from the analytic field gradient, so the mesh is smooth and accurate.
-import { SDFModel, gradient } from './sdf.js';
-
-export function meshSDF(prims, bmin, bmax, h, F = 6, onProgress, clip = null) {
-  const kmax = prims.reduce((m, p) => Math.max(m, p.k), 0);
-  // absolute steps tuned for cheetah-sized cells (>= 1 mm), scaled down for finer grids
-  const eP = Math.min(0.0006, 0.6 * h), eN = Math.min(0.0008, 0.8 * h), tolP = Math.min(2e-5, 0.02 * h);
-  const nx = Math.ceil((bmax[0] - bmin[0]) / h) + 3;
-  const ny = Math.ceil((bmax[1] - bmin[1]) / h) + 3;
-  const nz = Math.ceil((bmax[2] - bmin[2]) / h) + 3;
-  const ox = bmin[0] - h, oy = bmin[1] - h, oz = bmin[2] - h;
-  const cnx = Math.ceil((nx - 1) / F), cny = Math.ceil((ny - 1) / F), cnz = Math.ceil((nz - 1) / F);
-  const H = h * F;
-
-  // --- coarse samples, evaluated per super-cell with culled primitive lists
-  const T0 = performance.now();
-  const cv = new Float32Array((cnx + 1) * (cny + 1) * (cnz + 1)).fill(NaN);
-  const cidx = (i, j, k) => i + (cnx + 1) * (j + (cny + 1) * k);
-  const F2 = 4;
-  const snx = Math.ceil(cnx / F2), sny = Math.ceil(cny / F2), snz = Math.ceil(cnz / F2);
-  const H2 = H * F2, rho2 = H2 * Math.sqrt(3) * 0.5;
-  const superLists = new Map();
-  for (let sk = 0; sk < snz; sk++)
-    for (let sj = 0; sj < sny; sj++)
-      for (let si = 0; si < snx; si++) {
-        const list2 = SDFModel.cull(prims, ox + (si + 0.5) * H2, oy + (sj + 0.5) * H2, oz + (sk + 0.5) * H2, rho2, kmax);
-        superLists.set(si + snx * (sj + sny * sk), list2);
-        for (let k = sk * F2; k <= Math.min(sk * F2 + F2, cnz); k++)
-          for (let j = sj * F2; j <= Math.min(sj * F2 + F2, cny); j++)
-            for (let i = si * F2; i <= Math.min(si * F2 + F2, cnx); i++) {
-              const id = cidx(i, j, k);
-              if (cv[id] === cv[id]) continue;
-              cv[id] = list2.length ? SDFModel.evalList(list2, ox + i * H, oy + j * H, oz + k * H) : 1;
-            }
-      }
-  const superListFor = (i, j, k) => superLists.get(Math.min(snx - 1, Math.floor(i / F2)) + snx * (Math.min(sny - 1, Math.floor(j / F2)) + sny * Math.min(snz - 1, Math.floor(k / F2))));
-  const T1 = performance.now();
-
-  // --- active coarse cells (surface may pass through), dilated by one
-  const cellIdx = (i, j, k) => i + cnx * (j + cny * k);
-  const active0 = new Uint8Array(cnx * cny * cnz);
-  const reach = H * Math.sqrt(3) * 1.15;
-  for (let k = 0; k < cnz; k++)
-    for (let j = 0; j < cny; j++)
-      for (let i = 0; i < cnx; i++) {
-        let mn = 1e9, neg = false, pos_ = false;
-        for (let c = 0; c < 8; c++) {
-          const v = cv[cidx(i + (c & 1), j + ((c >> 1) & 1), k + ((c >> 2) & 1))];
-          const a = Math.abs(v);
-          if (a < mn) mn = a;
-          if (v < 0) neg = true; else pos_ = true;
-        }
-        // a surface point inside the cube is within half a diagonal of some corner
-        if ((neg && pos_) || mn < reach * 0.5) active0[cellIdx(i, j, k)] = 1;
-      }
-  const active = active0; // every cell crossed by the surface is already active (1-Lipschitz bound)
-
-  // --- fine samples inside active coarse cells
-  const N = nx * ny * nz;
-  const fv = new Float32Array(N).fill(NaN);
-  const fidx = (x, y, z) => x + nx * (y + ny * z);
-  const cellLists = new Map();
-  const rho = H * Math.sqrt(3) * 0.5;
-  let cellCount = 0;
-  for (let k = 0; k < cnz; k++)
-    for (let j = 0; j < cny; j++)
-      for (let i = 0; i < cnx; i++) {
-        const ci = cellIdx(i, j, k);
-        if (!active[ci]) continue;
-        cellCount++;
-        const cx = ox + (i + 0.5) * H, cy = oy + (j + 0.5) * H, cz = oz + (k + 0.5) * H;
-        const list = SDFModel.cull(superListFor(i, j, k), cx, cy, cz, rho, kmax);
-        cellLists.set(ci, list);
-        const x0 = i * F, y0 = j * F, z0 = k * F;
-        for (let z = z0; z <= Math.min(z0 + F, nz - 1); z++)
-          for (let y = y0; y <= Math.min(y0 + F, ny - 1); y++)
-            for (let x = x0; x <= Math.min(x0 + F, nx - 1); x++) {
-              const id = fidx(x, y, z);
-              if (fv[id] === fv[id]) continue; // already evaluated
-              fv[id] = SDFModel.evalList(list, ox + x * h, oy + y * h, oz + z * h);
-            }
-      }
-  const T2 = performance.now();
-  onProgress && onProgress('field', cellCount);
-
-  const listFor = (x, y, z) => {
-    const i = Math.min(cnx - 1, Math.floor(x / F)), j = Math.min(cny - 1, Math.floor(y / F)), k = Math.min(cnz - 1, Math.floor(z / F));
-    return cellLists.get(cellIdx(i, j, k)) || prims;
-  };
-
-  // --- surface nets vertices
-  const vmap = new Map();
-  const pos = [];
-  const cellOf = [];
-  const edges = [
-    [0, 1], [2, 3], [4, 5], [6, 7],
-    [0, 2], [1, 3], [4, 6], [5, 7],
-    [0, 4], [1, 5], [2, 6], [3, 7],
-  ];
-  const corner = new Float64Array(8);
-  for (let k = 0; k < cnz; k++)
-    for (let j = 0; j < cny; j++)
-      for (let i = 0; i < cnx; i++) {
-        if (!active[cellIdx(i, j, k)]) continue;
-        const list = cellLists.get(cellIdx(i, j, k));
-        const x0 = i * F, y0 = j * F, z0 = k * F;
-        for (let z = z0; z < Math.min(z0 + F, nz - 1); z++)
-          for (let y = y0; y < Math.min(y0 + F, ny - 1); y++)
-            for (let x = x0; x < Math.min(x0 + F, nx - 1); x++) {
-              let mask = 0, bad = false;
-              for (let c = 0; c < 8; c++) {
-                const v = fv[fidx(x + (c & 1), y + ((c >> 1) & 1), z + ((c >> 2) & 1))];
-                if (v !== v) { bad = true; break; }
-                corner[c] = v;
-                if (v < 0) mask |= 1 << c;
-              }
-              if (bad || mask === 0 || mask === 255) continue;
-              if (clip && !clip(ox + (x + 0.5) * h, oy + (y + 0.5) * h, oz + (z + 0.5) * h)) continue;
-              // mass point of edge crossings
-              let sx = 0, sy = 0, sz = 0, cnt = 0;
-              for (const [a, b] of edges) {
-                const va = corner[a], vb = corner[b];
-                if ((va < 0) === (vb < 0)) continue;
-                const t = va / (va - vb);
-                const ax = a & 1, ay = (a >> 1) & 1, az = (a >> 2) & 1;
-                const bx = b & 1, by = (b >> 1) & 1, bz = (b >> 2) & 1;
-                sx += ax + (bx - ax) * t;
-                sy += ay + (by - ay) * t;
-                sz += az + (bz - az) * t;
-                cnt++;
-              }
-              let px = ox + (x + sx / cnt) * h, py = oy + (y + sy / cnt) * h, pz = oz + (z + sz / cnt) * h;
-              // project onto the surface (tetrahedral samples give value + gradient)
-              for (let it = 0; it < 2; it++) {
-                const e = eP; // finite-difference step: 0.6 mm, smaller on very fine grids (tiny animals)
-                const a = SDFModel.evalList(list, px + e, py - e, pz - e);
-                const b = SDFModel.evalList(list, px - e, py - e, pz + e);
-                const c2 = SDFModel.evalList(list, px - e, py + e, pz - e);
-                const d2 = SDFModel.evalList(list, px + e, py + e, pz + e);
-                const d = (a + b + c2 + d2) * 0.25;
-                const gx = (a - b - c2 + d2) / (4 * e), gy = (-a - b + c2 + d2) / (4 * e), gz = (-a + b - c2 + d2) / (4 * e);
-                const g2 = gx * gx + gy * gy + gz * gz + 1e-12;
-                let stx = (-d * gx) / g2, sty = (-d * gy) / g2, stz = (-d * gz) / g2;
-                const sl = Math.hypot(stx, sty, stz);
-                if (sl > h) { stx *= h / sl; sty *= h / sl; stz *= h / sl; }
-                px += stx; py += sty; pz += stz;
-                if (Math.abs(d) < tolP) break;
-              }
-              // keep inside an expanded cell to avoid folding
-              const lo = 0.35 * h;
-              px = Math.min(Math.max(px, ox + x * h - lo), ox + (x + 1) * h + lo);
-              py = Math.min(Math.max(py, oy + y * h - lo), oy + (y + 1) * h + lo);
-              pz = Math.min(Math.max(pz, oz + z * h - lo), oz + (z + 1) * h + lo);
-              vmap.set(fidx(x, y, z), pos.length / 3);
-              pos.push(px, py, pz);
-              cellOf.push(fidx(x, y, z));
-            }
-      }
-  const T3 = performance.now();
-  onProgress && onProgress('verts', pos.length / 3);
-
-  // --- faces
-  const idx = [];
-  const nV = pos.length / 3;
-  const P = pos;
-  const dist2 = (a, b) => {
-    const dx = P[a * 3] - P[b * 3], dy = P[a * 3 + 1] - P[b * 3 + 1], dz = P[a * 3 + 2] - P[b * 3 + 2];
-    return dx * dx + dy * dy + dz * dz;
-  };
-  const strides = [1, nx, nx * ny];
-  for (let v = 0; v < nV; v++) {
-    const c = cellOf[v];
-    const z = Math.floor(c / (nx * ny));
-    const y = Math.floor((c - z * nx * ny) / nx);
-    const x = c - z * nx * ny - y * nx;
-    const xyz = [x, y, z];
-    for (let a = 0; a < 3; a++) {
-      const b = (a + 1) % 3, cc = (a + 2) % 3;
-      // edge from grid point (cell + e_b + e_c) along axis a
-      const p0 = [x, y, z];
-      p0[b] += 1;
-      p0[cc] += 1;
-      if (p0[0] >= nx || p0[1] >= ny || p0[2] >= nz) continue;
-      const p1 = p0.slice();
-      p1[a] += 1;
-      if (p1[a] >= [nx, ny, nz][a]) continue;
-      const v0 = fv[fidx(p0[0], p0[1], p0[2])], v1 = fv[fidx(p1[0], p1[1], p1[2])];
-      if (v0 !== v0 || v1 !== v1) continue;
-      if ((v0 < 0) === (v1 < 0)) continue;
-      const cA = c, cB = c + strides[b], cC = c + strides[b] + strides[cc], cD = c + strides[cc];
-      const A = vmap.get(cA), B = vmap.get(cB), C = vmap.get(cC), D = vmap.get(cD);
-      if (A === undefined || B === undefined || C === undefined || D === undefined) continue;
-      // orientation: inside->outside along +a means normal points +a
-      const flip = v0 < 0;
-      let q = flip ? [A, B, C, D] : [A, D, C, B];
-      if (dist2(q[0], q[2]) <= dist2(q[1], q[3])) idx.push(q[0], q[1], q[2], q[0], q[2], q[3]);
-      else idx.push(q[0], q[1], q[3], q[1], q[2], q[3]);
-      void xyz;
-    }
-  }
-
-  // --- normals from field gradient
-  const nrm = new Float32Array(nV * 3);
-  for (let v = 0; v < nV; v++) {
-    const c = cellOf[v];
-    const z = Math.floor(c / (nx * ny));
-    const y = Math.floor((c - z * nx * ny) / nx);
-    const x = c - z * nx * ny - y * nx;
-    const list = listFor(x, y, z);
-    const g = gradient(list, P[v * 3], P[v * 3 + 1], P[v * 3 + 2], eN);
-    const l = Math.hypot(g[0], g[1], g[2]) || 1;
-    nrm[v * 3] = g[0] / l;
-    nrm[v * 3 + 1] = g[1] / l;
-    nrm[v * 3 + 2] = g[2] / l;
-  }
-
-  const lists = new Array(nV);
-  for (let v = 0; v < nV; v++) {
-    const c = cellOf[v];
-    const z = Math.floor(c / (nx * ny));
-    const y = Math.floor((c - z * nx * ny) / nx);
-    const x = c - z * nx * ny - y * nx;
-    lists[v] = listFor(x, y, z);
-  }
-
-  const T4 = performance.now();
-  if (typeof process !== 'undefined' && process.env && process.env.MESH_TIMING) console.log('coarse', (T1-T0)|0, 'fine', (T2-T1)|0, 'verts', (T3-T2)|0, 'faces+normals', (T4-T3)|0, 'cells', cellCount);
-  return {
-    positions: new Float32Array(pos),
-    normals: nrm,
-    indices: nV > 65535 ? new Uint32Array(idx) : new Uint16Array(idx),
-    lists,
-    count: nV,
-  };
-}