@bitefoundry/retrieviewer 0.0.3 → 0.0.4

package/vendor/procedural-animals/src/core/build/featherCards.js

@@ -1,189 +0,0 @@
-// Flight-feather cards: real feather geometry (primaries, secondaries, rectrices and their coverts)
-// appended to the base surface. Each card is a thin two-sided vane (top and bottom layer, rachis
-// down the middle, asymmetric outer / inner vane, rounded or emarginated tip, curved rachis) rigidly
-// skinned to its own feather bone, so the engine can fan, fold, twist and splay every feather while
-// the base draw call renders it (one draw, shadows and the crowd tier included). Material id 10
-// (vane) is shaded in core/render/coatMaterial.js from surf = [gloss, iridescence, across, along]:
-// across -1 (outer vane edge) .. 0 (rachis) .. 1 (inner vane edge), along 0 (root) .. 1 (tip).
-// colour(kind, i, side, t, c, layer) -> { rgb, gloss, irid, bar? }: bar { rgb, period (m) } draws bars
-// across the vane in the shader (patternColor = [rgb, -bar count]; opt-in, e.g. barred poultry).
-//
-// Species usage (surfaces hook, see core/build/pipeline.js):
-//   surfaces: (ctx) => featherCards({ ...ctx, wing: motion.wing, feathers: motion.feathers,
-//                                    tail: motion.tail, colour: (kind, i, side, t, c) => ({ rgb, gloss, irid }) })
-import { featherJoints, DEG } from '../rig/bird.js';
-import { MAT } from './coatKit.js';
-
-const V = (x, y, z) => [x, y, z];
-const addS = (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 norm = (a) => { const l = Math.hypot(a[0], a[1], a[2]) || 1; return [a[0] / l, a[1] / l, a[2] / l]; };
-const mirror = (p) => [-p[0], p[1], p[2]];
-
-// vane half-widths at t (0 root .. 1 tip): [outer, inner] (also used by the bird engine's ground checks)
-// (f.base0: the vane's width at the root as a fraction of its full width, default 0.3)
-export function vaneWidth(f, t, w) {
-  const b0 = f.base0 ?? 0.3;
-  const base = b0 + (1 - b0) * smooth(0.0, 0.16, t);
-  const tr = f.tipRound;
-  let tip = 1;
-  if (t > 1 - tr) { const x = (t - (1 - tr)) / tr; tip = Math.sqrt(Math.max(0, 1 - x * x)); }
-  let wo = w * f.outer * base * tip, wi = w * (1 - f.outer) * base * tip;
-  if (f.emarg > 0) {
-    // emarginated primaries: both vanes step in beyond the notch, leaving a narrow "finger"
-    const k = smooth(0.5, 0.64, t) * f.emarg;
-    wi *= 1 - 0.62 * k; wo *= 1 - 0.3 * k;
-  }
-  return [wo, Math.max(wi, 0.0006)];
-}
-function smooth(a, b, x) { const t = Math.min(1, Math.max(0, (x - a) / (b - a))); return t * t * (3 - 2 * t); }
-
-/**
- * @param ctx { rig, params, Q, wing, feathers, tail, colour, thickness? }
- * @returns surfaces block { nV, pos, nrm, index, skinIndex, skinWeight, comb, tint, pattern, mark, furLen, patternColor, surf }
- */
-export function featherCards(ctx) {
-  const { rig, Q, wing, feathers, tail } = ctx;
-  const colour = ctx.colour || (() => ({ rgb: [0.02, 0.02, 0.02], gloss: 0.5, irid: 0 }));
-  // the bind layout (the rig built the joints from the same call)
-  const Jl = {};
-  for (const k of ['shoulderL', 'tailBase', 'tailTip']) Jl[k] = rig.J[k];
-  const lay = featherJoints(Jl, wing, feathers, tail);
-  const res = Q?.res ?? 1;
-  const nA = res <= 1.35 ? 9 : res <= 2.1 ? 6 : res <= 3.1 ? 4 : 3;
-  const th = ctx.thickness ?? 0.0005;
-  const coverts = res < 4 || ctx.crowdCoverts;
-  const P = [], N = [], C = [], T = [], S = [], SI = [], I = [], X = [];
-  const PCL = []; // vane bars: [vertex, rgb, -count]
-  const cov = lay.F.coverts;
-
-  const card = (bone, side, fr, f, opts) => {
-    const b = rig.BONE[bone];
-    if (!b) throw new Error('featherCards: missing bone ' + bone);
-    const s = side;
-    const m = (p) => (s > 0 ? p : mirror(p));
-    const L = f.len * (opts.lenK || 1), W = f.width * (opts.widthK || 1);
-    const A = m(V(fr.axis.x, fr.axis.y, fr.axis.z)), Nn = m(V(fr.normal.x, fr.normal.y, fr.normal.z));
-    // inner vane side (+across): s * (N x A)
-    const Tv = norm(cross(Nn, A)).map((x) => x * s);
-    const root0 = m(V(fr.root.x, fr.root.y, fr.root.z));
-    const root = addS(addS(root0, Nn, opts.lift || 0), A, opts.shift || 0);
-    const fo = opts.shape ? { ...f, ...opts.shape } : f;
-    // vane arch: the edges sit this fraction of the half-width below the rachis (feather spec `arch`,
-    // default 0.12; a flatter vane lets overlapping neighbours stack on smaller lift steps)
-    const arch = fo.arch ?? 0.12;
-    const v0 = P.length / 3;
-    const ts = [];
-    for (let j = 0; j <= nA; j++) { const u = j / nA; ts.push(0.5 - 0.5 * Math.cos(Math.PI * u)); }
-    const pt = (t, c) => {
-      const [wo, wi] = vaneWidth(fo, t, W);
-      const w = c < 0 ? wo : wi;
-      if (fo.arc) {
-        // rachis bent along a circular arc of total angle `arc` (rad) toward the inner vane, length
-        // kept (long display feathers: a rooster's sickles); the vane width turns with the rachis
-        const a = fo.arc * t, R = L / fo.arc, ca = Math.cos(a), sa = Math.sin(a);
-        let p = addS(root, A, R * sa);
-        p = addS(p, Tv, R * (1 - ca));
-        p = addS(p, A, -sa * c * w);
-        p = addS(p, Tv, ca * c * w);
-        return addS(p, Nn, -fo.droop * L * t * t - Math.abs(c) * w * arch);
-      }
-      // curved rachis (toward the inner vane, drooping), vanes slightly convex (edges lower)
-      const along = t * L, curve = fo.curve * L * t * t, droop = fo.droop * L * t * t;
-      let p = addS(root, A, along);
-      p = addS(p, Tv, curve + c * w);
-      p = addS(p, Nn, -droop - Math.abs(c) * w * arch);
-      return p;
-    };
-    const cols = [-1, 0, 1];
-    for (const layer of [1, -1]) {
-      for (let j = 0; j <= nA; j++) {
-        const t = ts[j];
-        for (const c of cols) {
-          const p = addS(pt(t, c), Nn, layer * th * 0.5 * (1 - 0.6 * t));
-          // surface tangents for the normal
-          const e = 1e-3;
-          const pa = pt(Math.min(1, t + e), c), pb = pt(Math.max(0, t - e), c);
-          const pc = pt(t, Math.min(1, c + 0.05)), pd = pt(t, Math.max(-1, c - 0.05));
-          const dt = [pa[0] - pb[0], pa[1] - pb[1], pa[2] - pb[2]], dc = [pc[0] - pd[0], pc[1] - pd[1], pc[2] - pd[2]];
-          let n = norm(cross(dt, dc));
-          const sgn = (n[0] * Nn[0] + n[1] * Nn[1] + n[2] * Nn[2]) < 0 ? -1 : 1;
-          n = n.map((x) => x * sgn * layer);
-          if (!Number.isFinite(n[0])) n = Nn.map((x) => x * layer);
-          P.push(...p); N.push(...n);
-          C.push(...norm(dt));
-          const col = colour(opts.kind, f.i, s, t, c, layer);
-          T.push(col.rgb[0], col.rgb[1], col.rgb[2], MAT.VANE);
-          // opt-in bars across the vane (colour() returns bar: { rgb, period (m) }): shader-drawn
-          if (col.bar) PCL.push([P.length / 3 - 1, col.bar.rgb, -L / col.bar.period]);
-          S.push(col.gloss ?? 0.5, col.irid ?? 0, c, t);
-          const wv = vaneWidth(fo, t, W);
-          X.push(c * (c < 0 ? wv[0] : wv[1]) * s);
-          SI.push(b.index, 0, 0, 0);
-        }
-      }
-      const base = v0 + (layer > 0 ? 0 : (nA + 1) * 3);
-      for (let j = 0; j < nA; j++) {
-        for (let k = 0; k < 2; k++) {
-          const a = base + j * 3 + k, bq = a + 1, c2 = a + 3, d = a + 4;
-          // top layer faces +N; the bottom layer is wound the other way
-          if ((layer > 0) === (s > 0)) I.push(a, c2, bq, bq, c2, d);
-          else I.push(a, bq, c2, bq, d, c2);
-        }
-      }
-    }
-    // winding sanity: flip this card's triangles if their geometric normal disagrees with the layer normal
-    fixWinding(P, N, I, v0);
-  };
-
-  // per-feather covert overrides (spec field `cov`: { lift, shift, lenK, widthK, shape }, merged over
-  // the defaults below; opt-in: a species can restack its coverts, e.g. reverse their overlap order;
-  // `cov: { skip: true }` drops the covert card, e.g. where the species sculpts the coverts as skin)
-  const covOpts = (f, o) => (f.cov ? { ...o, ...f.cov, shape: { ...o.shape, ...(f.cov.shape || {}) } } : o);
-  const wEH = lay.frames;
-  for (const side of [1, -1]) {
-    const S2 = side > 0 ? 'L' : 'R';
-    for (const fr of wEH.pri) {
-      const f = fr.f;
-      card(`pri${f.i + 1}${S2}`, side, fr, f, { kind: 'primary' });
-      if (coverts && !f.cov?.skip) card(`pri${f.i + 1}${S2}`, side, fr, f, covOpts(f, { kind: 'primaryCovert', lenK: cov.primary * (1 - 0.25 * f.i / Math.max(1, f.n - 1)), widthK: 1.05, lift: 0.0022, shift: -0.004, shape: { emarg: 0, tipRound: 0.6, outer: 0.45, curve: 0.02 } }));
-    }
-    for (const fr of wEH.sec) {
-      const f = fr.f;
-      card(`sec${f.i + 1}${S2}`, side, fr, f, { kind: 'secondary' });
-      if (coverts && !f.cov?.skip) card(`sec${f.i + 1}${S2}`, side, fr, f, covOpts(f, { kind: 'secondaryCovert', lenK: cov.secondary, widthK: 1.15, lift: 0.0028, shift: -0.006, shape: { tipRound: 0.65, outer: 0.45, curve: 0.02 } }));
-    }
-    for (const fr of wEH.rec) {
-      const f = fr.f;
-      card(`rec${f.i + 1}${S2}`, side, fr, f, { kind: 'rectrix' });
-      if (coverts && f.i < 4 && !f.cov?.skip) card(`rec${f.i + 1}${S2}`, side, fr, f, covOpts(f, { kind: 'tailCovert', lenK: cov.tail * (1 - 0.1 * f.i), widthK: 1.2, lift: 0.0025, shift: -0.012, shape: { tipRound: 0.7, outer: 0.5 } }));
-    }
-  }
-  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(C), tint: Float32Array.from(T), surf: Float32Array.from(S),
-    pattern: Float32Array.from(X), mark: new Float32Array(nV).fill(1), furLen: 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;
-}
-
-function fixWinding(P, N, I, v0) {
-  // triangles are appended per card; check the first triangle referencing v0's range
-  for (let t = 0; t < I.length; t += 3) {
-    const a = I[t], b = I[t + 1], c = I[t + 2];
-    if (a < v0) continue;
-    const e1 = [P[b * 3] - P[a * 3], P[b * 3 + 1] - P[a * 3 + 1], P[b * 3 + 2] - P[a * 3 + 2]];
-    const e2 = [P[c * 3] - P[a * 3], P[c * 3 + 1] - P[a * 3 + 1], P[c * 3 + 2] - P[a * 3 + 2]];
-    const g = cross(e1, e2);
-    const d = g[0] * N[a * 3] + g[1] * N[a * 3 + 1] + g[2] * N[a * 3 + 2];
-    if (d < 0) { I[t + 1] = c; I[t + 2] = b; }
-  }
-}
-
-export { DEG };

package/vendor/procedural-animals/src/core/build/finEdges.js

@@ -1,85 +0,0 @@
-// Knife-thin fin edges below the mesh cell size.
-//
-// A fin slab (SDFModel.fin) meshes with a rim no thinner than ~2 cells (thinner slabs alias into
-// holes), so at 1 cm cells a shark's fins end in 2 cm rounded, rubbery edges. A fin primitive tagged
-// `sharpen: { edge, band, rim }` has its meshed surface squeezed toward its mid-plane near its free
-// outline: every vertex whose nearest fin slab is that primitive has its distance from the plane
-// scaled by `edge` (e.g. 0.15) at the outline, easing back to 1 at `band` mesh cells (of the vertex's
-// region, so every quality tier) inside it; the rounded rim beyond the outline is drawn in toward it
-// by `rim` (0.4: to 0.4 of its width), so the squeezed edge runs straight instead of following the
-// cells' sampling of the round cap. Where the fin grows out of the body (the field of the non-fin
-// primitives within ~1.5-4 cells of the vertex) nothing moves, so the root fillet keeps its shape.
-// Same vertex count; the field's analytic normals are carried through the squeeze (inverse transpose
-// of its Jacobian), so the shading stays as smooth as the field's. Opt-in: no tagged primitive, no
-// change.
-import { SDFModel, T_FIN, polySD } from '../sdf/sdf.js';
-
-const smooth = (a, b, x) => { const t = Math.min(1, Math.max(0, (x - a) / (b - a))); return t * t * (3 - 2 * t); };
-const dsmooth = (a, b, x) => { if (x <= a || x >= b) return 0; const t = (x - a) / (b - a); return (6 * t * (1 - t)) / (b - a); };
-
-/** @returns the number of vertices moved */
-export function sharpenFinEdges({ pos, nrm, lists, nV, regionOf }, hOfRegion) {
-  let n = 0;
-  for (let v = 0; v < nV; v++) {
-    const L = lists[v];
-    if (!L) continue;
-    const h = hOfRegion[regionOf[v]];
-    let fin = null, best = Infinity;
-    const x = pos[v * 3], y = pos[v * 3 + 1], z = pos[v * 3 + 2];
-    for (const pr of L) {
-      if (pr.type !== T_FIN || !pr.sharpen || pr.carve) continue;
-      const d = Math.abs(SDFModel.dist(pr, x, y, z));
-      if (d < best) { best = d; fin = pr; }
-    }
-    if (!fin) continue;
-    const P = fin.P, S = fin.sharpen, e = S.edge, B = S.band * h, c = S.rim ?? 1;
-    const dx = x - P[0], dy = y - P[1], dz = z - P[2];
-    const pu = dx * P[3] + dy * P[4] + dz * P[5], pv = dx * P[6] + dy * P[7] + dz * P[8];
-    const pn = dx * P[9] + dy * P[10] + dz * P[11];
-    // depth inside the outline (< 0 on the rounded rim beyond it)
-    const din = -polySD(P, pu, pv);
-    if (din >= B) continue;
-    // the body around the root: the field of every non-fin primitive near the vertex
-    const rest = L.filter((pr) => pr.type !== T_FIN && !pr.carve);
-    const dBody = rest.length ? SDFModel.evalList(rest, x, y, z) : 1e9;
-    const wr = smooth(1.5 * h, 4 * h, dBody);
-    if (wr < 1e-3) continue;
-    // squeeze factor s(din) = 1 - wr (1 - k(din)), k = e + (1 - e) smooth(0, B, din)
-    const s = 1 - wr * (1 - e) * (1 - smooth(0, B, din));
-    const ds = wr * (1 - e) * dsmooth(0, B, din);
-    // in-plane gradient of din (unit, pointing into the fin)
-    const eps = 0.25 * h;
-    let gu = -(polySD(P, pu + eps, pv) - polySD(P, pu - eps, pv)) / (2 * eps);
-    let gv = -(polySD(P, pu, pv + eps) - polySD(P, pu, pv - eps)) / (2 * eps);
-    const gl = Math.hypot(gu, gv) || 1;
-    gu /= gl; gv /= gl;
-    const gx = P[3] * gu + P[6] * gv, gy = P[4] * gu + P[7] * gv, gz = P[5] * gu + P[8] * gv;
-    // the rim beyond the outline drawn in toward it (to c of its width)
-    const pull = din < 0 ? (1 - c) * -din * wr : 0;
-    const off = pn * (s - 1);
-    pos[v * 3] += P[9] * off + gx * pull; pos[v * 3 + 1] += P[10] * off + gy * pull; pos[v * 3 + 2] += P[11] * off + gz * pull;
-    // normal: J = I + nf a^T (a = (s - 1) nf + pn ds g) -> J^-T n0 = n0 - a (nf . n0) / s; the rim pull
-    // scales along g by c' = 1 - (1 - c) wr -> divide the g component by c'
-    let nx = nrm[v * 3], ny = nrm[v * 3 + 1], nz = nrm[v * 3 + 2];
-    const fn = (nx * P[9] + ny * P[10] + nz * P[11]) / s;
-    const ax = (s - 1) * P[9] + pn * ds * gx, ay = (s - 1) * P[10] + pn * ds * gy, az = (s - 1) * P[11] + pn * ds * gz;
-    nx -= ax * fn; ny -= ay * fn; nz -= az * fn;
-    if (din < 0 && c < 1) {
-      const cc = 1 - (1 - c) * wr, gn = (nx * gx + ny * gy + nz * gz) * (1 / cc - 1);
-      nx += gx * gn; ny += gy * gn; nz += gz * gn;
-    }
-    // at the knife edge itself the faces above and below meet: a vertex there (on the field's rounded
-    // cap, close to the mid-plane) takes the edge's in-plane normal; otherwise vertices a hair above and
-    // below the plane along the rim would alternate up / down normals (stripes across the edge)
-    const q = Math.abs(pn) / Math.max(1e-9, P[12]);
-    const fq = smooth(0.15, 0.7, q);
-    if (fq < 1) {
-      const nfc = (nx * P[9] + ny * P[10] + nz * P[11]) * (1 - fq);
-      nx -= P[9] * nfc; ny -= P[10] * nfc; nz -= P[11] * nfc;
-    }
-    const l = Math.hypot(nx, ny, nz) || 1;
-    nrm[v * 3] = nx / l; nrm[v * 3 + 1] = ny / l; nrm[v * 3 + 2] = nz / l;
-    n++;
-  }
-  return n;
-}

package/vendor/procedural-animals/src/core/build/furSlope.js

@@ -1,115 +0,0 @@
-// Fur-length slope limit (shorten only), applied by the pipeline to every coat.
-//
-// The coat shells are offset copies of the skin at hair height x (0..1) x furLen, so where the hair
-// length jumps from one vertex to the next the shells stand up as a wall: a round pad with a hard
-// rim (a cheek switched from 5 to 11 mm across a plane), an eye sunk in a ring of long fur, a strand
-// pattern smeared into a smooth plate over the steep triangles. Real hair changes length gradually
-// and lies over the shorter hair around it, so the coat surface has no cliffs.
-//
-// The limit: hair may grow no faster than `slope` metres of hair per metre of skin above the hair
-// around it, U(v) = min(L(v), min_u U(u) + s(v) |p_u - p_v|) over the furred, hairy vertices of the
-// same surface (a Dijkstra sweep from the shortest hair outward: exact, one pass). Long hair may rise
-// proportionally faster, s(v) = slope x max(1, L(v) / free): every boundary then bevels over at most
-// ~free / slope of skin whatever the hair length, so manes, ruffs, forelocks and fleeces keep
-// standing off (their edge is beveled, not flattened) while a face loses its walls.
-//
-// Species control (optional):
-//   species.render.furSlope      slope for hair up to `furSlopeFree` long (default 1); false / 0: off
-//   species.render.furSlopeFree  hair length (m) above which the allowed slope grows (default 0.025)
-//   coat().furSlope              per-vertex slope (Float32Array) replacing the default at that vertex;
-//                                Infinity (or <= 0) leaves that vertex's hair as painted (a crest meant
-//                                to stand up as a wall)
-// Bare vertices (no hair, or a material without shells) neither limit nor get limited: fur may meet a
-// lid margin, the nose leather or a hoof at full length.
-
-export const FUR_SLOPE_DEFAULTS = { slope: 1.0, free: 0.025 };
-
-const HAIRY = (m) => m === 0 || m === 4 || m === 8 || m === 9; // materials that grow shells (coatMaterial.js hairy())
-
-/**
- * Shortens furLen in place so that no hair rises faster than the slope above its neighbours.
- * @param {Float32Array} furLen per-vertex hair length (m), modified in place
- * @param {Float32Array} pos    per-vertex positions (reference space)
- * @param {Uint32Array} index   triangle indices
- * @param {number} nV           vertex count (vertices >= nV are ignored)
- * @param {Float32Array} tint   per-vertex rgba, a = material id
- * @param {object} o            { slope, free, perVertex }
- * @returns {{ shortened: number, maxCut: number }} vertices shortened by more than 0.1 mm, the largest cut (m)
- */
-export function limitFurSlope(furLen, pos, index, nV, tint, { slope = FUR_SLOPE_DEFAULTS.slope, free = FUR_SLOPE_DEFAULTS.free, perVertex = null } = {}) {
-  const res = { shortened: 0, maxCut: 0 };
-  if (!furLen || !(slope > 0) || !(free > 0)) return res;
-  const L0 = Float32Array.from(furLen.subarray(0, nV));
-  const active = new Uint8Array(nV);
-  let any = false;
-  for (let v = 0; v < nV; v++) {
-    if (L0[v] > 0 && HAIRY(Math.round(tint[v * 4 + 3]))) { active[v] = 1; any = true; }
-  }
-  if (!any) return res;
-  // the allowed slope of each vertex's hair (0 = unlimited)
-  const sOf = new Float32Array(nV);
-  for (let v = 0; v < nV; v++) {
-    if (!active[v]) continue;
-    let s = perVertex ? perVertex[v] : slope;
-    if (perVertex && !(s > 0)) s = Infinity; // a species' explicit "leave as painted"
-    sOf[v] = Number.isFinite(s) ? s * Math.max(1, L0[v] / free) : 0;
-  }
-  // adjacency (CSR) over the active vertices
-  const deg = new Uint32Array(nV + 1);
-  for (let i = 0; i < index.length; i += 3) {
-    for (let e = 0; e < 3; e++) {
-      const u = index[i + e], v = index[i + ((e + 1) % 3)];
-      if (u < nV && v < nV && active[u] && active[v]) { deg[u + 1]++; deg[v + 1]++; }
-    }
-  }
-  for (let v = 0; v < nV; v++) deg[v + 1] += deg[v];
-  const adj = new Uint32Array(deg[nV]), fill = deg.slice(0, nV);
-  for (let i = 0; i < index.length; i += 3) {
-    for (let e = 0; e < 3; e++) {
-      const u = index[i + e], v = index[i + ((e + 1) % 3)];
-      if (u < nV && v < nV && active[u] && active[v]) { adj[fill[u]++] = v; adj[fill[v]++] = u; }
-    }
-  }
-  // Dijkstra: settle vertices in increasing (limited) length; a settled vertex bounds its neighbours
-  const U = furLen;
-  let hk = new Float64Array(4096), hv = new Int32Array(4096), n = 0;
-  const push = (k, v) => {
-    if (n === hk.length) { const k2 = new Float64Array(n * 2); k2.set(hk); hk = k2; const v2 = new Int32Array(n * 2); v2.set(hv); hv = v2; }
-    let i = n++;
-    while (i > 0) { const p = (i - 1) >> 1; if (hk[p] <= k) break; hk[i] = hk[p]; hv[i] = hv[p]; i = p; }
-    hk[i] = k; hv[i] = v;
-  };
-  const pop = () => {
-    const top = hv[0], k = hk[--n], v = hv[n];
-    let i = 0;
-    for (;;) {
-      const l = 2 * i + 1;
-      if (l >= n) break;
-      const r = l + 1, m = r < n && hk[r] < hk[l] ? r : l;
-      if (hk[m] >= k) break;
-      hk[i] = hk[m]; hv[i] = hv[m]; i = m;
-    }
-    hk[i] = k; hv[i] = v;
-    return top;
-  };
-  const done = new Uint8Array(nV);
-  for (let v = 0; v < nV; v++) if (active[v]) push(U[v], v);
-  while (n) {
-    const v = pop();
-    if (done[v]) continue;
-    done[v] = 1;
-    const Uv = U[v], px = pos[v * 3], py = pos[v * 3 + 1], pz = pos[v * 3 + 2];
-    for (let k = deg[v]; k < deg[v + 1]; k++) {
-      const u = adj[k];
-      if (done[u] || sOf[u] === 0) continue;
-      const cand = Uv + sOf[u] * Math.hypot(pos[u * 3] - px, pos[u * 3 + 1] - py, pos[u * 3 + 2] - pz);
-      if (cand < U[u]) { U[u] = cand; push(cand, u); }
-    }
-  }
-  for (let v = 0; v < nV; v++) {
-    const cut = L0[v] - U[v];
-    if (cut > 0.0001) res.shortened++;
-    if (cut > res.maxCut) res.maxCut = cut;
-  }
-  return res;
-}

package/vendor/procedural-animals/src/core/build/mesh.js

@@ -1,67 +0,0 @@
-// Meshing stage: turns a species' SDF sculpt into surface pieces ("regions").
-//
-// A species describes its regions as jobs (each job can run in its own worker):
-//   { name, part, bmin, bmax, h, F?, clip?(x,y,z), patches?: [{ c, R, B, h }], rigidBone? }
-//  part:     which primitives to mesh (primitives carry part: 'body' | 'jaw' | ...)
-//  h:        cell size in metres (quality tiers multiply it)
-//  clip:     keep only cells whose centre passes (used for overlapping regions that cross-fade)
-//  patches:  balls re-meshed at a finer cell size (eyelid margins); the region itself is clipped
-//            to exclude the inner ball and the two cross-fade in a thin shell
-//  rigidBone: the whole region follows one bone (a separately meshed jaw)
-import { meshSDF } from '../sdf/mesher.js';
-
-export function meshRegion(model, R) {
-  const prims = model.forPart(R.part || 'body');
-  if (!prims.length) throw new Error(`region ${R.name}: no primitives in part ${R.part}`);
-  const d2 = (x, y, z, c) => (x - c[0]) * (x - c[0]) + (y - c[1]) * (y - c[1]) + (z - c[2]) * (z - c[2]);
-  const patches = R.patches || [];
-  const baseClip = R.clip || null;
-  // The region stops one of its own cells inside the patch's inner radius: its cut is as ragged as its
-  // cells, and a cut that pokes past the middle of the cross-fade band (a cell wider than the band B) left
-  // a slit there that neither surface covered; one cell further in, the cut lies where the patch shows
-  // alone and the region's fade is ~0 (drawn nowhere).
-  const clip = patches.length
-    ? (x, y, z) => (!baseClip || baseClip(x, y, z)) && patches.every((p) => d2(x, y, z, p.c) > Math.max(0, p.R - p.B - R.h) ** 2)
-    : baseClip;
-  const parts = [meshSDF(prims, R.bmin, R.bmax, R.h, R.F || 6, null, clip)];
-  for (const p of patches) {
-    const rOut = p.R + p.B, pad = rOut + 3 * p.h;
-    parts.push(meshSDF(prims, [p.c[0] - pad, p.c[1] - pad, p.c[2] - pad], [p.c[0] + pad, p.c[1] + pad, p.c[2] + pad], p.h, 4, null, (x, y, z) => d2(x, y, z, p.c) < rOut * rOut && (!baseClip || baseClip(x, y, z))));
-  }
-  const m = parts.length > 1 ? mergeMeshes(parts) : { ...parts[0], patch: null };
-  return serialiseLists({ name: R.name, ...m });
-}
-
-export function mergeMeshes(meshes) {
-  let n = 0, ni = 0;
-  for (const m of meshes) { n += m.count; ni += m.indices.length; }
-  const positions = new Float32Array(n * 3), normals = new Float32Array(n * 3), indices = new Uint32Array(ni), patch = new Uint8Array(n);
-  const lists = new Array(n);
-  let v0 = 0, i0 = 0;
-  meshes.forEach((m, k) => {
-    positions.set(m.positions, v0 * 3);
-    normals.set(m.normals, v0 * 3);
-    for (let i = 0; i < m.indices.length; i++) indices[i0 + i] = m.indices[i] + v0;
-    for (let i = 0; i < m.count; i++) { lists[v0 + i] = m.lists[i]; patch[v0 + i] = k > 0 ? 1 : 0; }
-    v0 += m.count; i0 += m.indices.length;
-  });
-  return { positions, normals, indices, lists, count: n, patch };
-}
-
-// replace per-vertex primitive lists by ids so a region can cross a worker boundary
-function serialiseLists(p) {
-  const uniq = new Map();
-  const listIndex = new Uint32Array(p.count);
-  const listIds = [];
-  for (let v = 0; v < p.count; v++) {
-    const l = p.lists[v];
-    let k = uniq.get(l);
-    if (k === undefined) { k = listIds.length; uniq.set(l, k); listIds.push(Int16Array.from(l.map((q) => q.id))); }
-    listIndex[v] = k;
-  }
-  return { name: p.name, positions: p.positions, normals: p.normals, indices: p.indices, count: p.count, listIndex, listIds, patch: p.patch || null };
-}
-
-export function regionTransferables(parts) {
-  return parts.flatMap((p) => [p.positions.buffer, p.normals.buffer, p.indices.buffer, p.listIndex.buffer]);
-}