@bitefoundry/retrieviewer 0.0.3 → 0.0.5

package/vendor/procedural-animals/src/bake.js

@@ -1,51 +0,0 @@
-// .animal bake files: a built individual, stored so it loads instantly (no SDF meshing, no weights).
-// Layout: "PANM" | u32 version | u32 headerBytes | header JSON (utf-8, padded to 8) | array blobs (8-aligned)
-import { ARRAY_KEYS, FORMAT_VERSION } from './core/build/pipeline.js';
-
-const TYPES = { Float32Array, Uint32Array, Uint16Array, Int16Array, Uint8Array, Int8Array, Int32Array };
-
-export function writeBake(data) {
-  const header = {};
-  for (const [k, v] of Object.entries(data)) if (!ARRAY_KEYS.includes(k)) header[k] = v;
-  header.arrays = [];
-  let offset = 0;
-  for (const k of ARRAY_KEYS) {
-    const a = data[k];
-    header.arrays.push({ key: k, type: a.constructor.name, length: a.length, offset });
-    offset += Math.ceil(a.byteLength / 8) * 8;
-  }
-  let json = new TextEncoder().encode(JSON.stringify(header));
-  const hb = Math.ceil((json.length) / 8) * 8;
-  const total = 12 + hb + offset;
-  const buf = new ArrayBuffer(Math.ceil(total / 8) * 8 + 8);
-  const u8 = new Uint8Array(buf);
-  u8.set([80, 65, 78, 77], 0); // "PANM"
-  const dv = new DataView(buf);
-  dv.setUint32(4, FORMAT_VERSION, true);
-  dv.setUint32(8, hb, true);
-  u8.set(json, 12);
-  for (let i = 12 + json.length; i < 12 + hb; i++) u8[i] = 32;
-  const base = 16 + hb - ((16 + hb) % 8 === 0 ? 0 : (16 + hb) % 8) ;
-  // blobs start at an 8-aligned offset after the header
-  const start = align8(12 + hb);
-  for (const a of header.arrays) u8.set(new Uint8Array(data[a.key].buffer, data[a.key].byteOffset, data[a.key].byteLength), start + a.offset);
-  void base;
-  return buf.slice(0, start + offset);
-}
-
-export function readBake(buf) {
-  const u8 = new Uint8Array(buf);
-  if (u8[0] !== 80 || u8[1] !== 65 || u8[2] !== 78 || u8[3] !== 77) throw new Error('not a .animal file');
-  const dv = new DataView(buf);
-  const version = dv.getUint32(4, true);
-  if (version !== FORMAT_VERSION) throw new Error(`.animal version ${version} is not supported (expected ${FORMAT_VERSION})`);
-  const hb = dv.getUint32(8, true);
-  const header = JSON.parse(new TextDecoder().decode(u8.subarray(12, 12 + hb)));
-  const start = align8(12 + hb);
-  const data = { ...header };
-  for (const a of header.arrays) data[a.key] = new TYPES[a.type](buf, start + a.offset, a.length);
-  delete data.arrays;
-  return data;
-}
-
-const align8 = (n) => Math.ceil(n / 8) * 8;

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

@@ -1,81 +0,0 @@
-// Builds an individual's data: in Web Workers when possible (meshing jobs in parallel, then
-// weights + coat), otherwise on the calling thread. Results are cached per (species, seed, quality,
-// sex, age) so a herd that reuses individuals shares geometry.
-import { buildSync, normaliseOptions } from './core/build/pipeline.js';
-import { loadSpecies } from './registry.js';
-
-let defaultWorkerFactory = null;
-export function setWorkerFactory(fn) { defaultWorkerFactory = fn; }
-
-function makeWorker(opt) {
-  if (opt === false) return null;
-  try {
-    if (typeof opt === 'function') return opt();
-    if (defaultWorkerFactory) return defaultWorkerFactory();
-    if (typeof Worker === 'undefined') return null;
-    return new Worker(new URL('./worker.js', import.meta.url), { type: 'module' });
-  } catch (e) {
-    return null;
-  }
-}
-
-const cache = new Map();
-export function cacheKey(speciesId, opts) {
-  const o = normaliseOptions(opts);
-  return [speciesId, o.seed, o.quality, o.sex || '', o.age || '', o.variant || '', JSON.stringify(o.overrides)].join('|');
-}
-
-export async function buildAnimalData(species, opts = {}, onProgress = () => {}) {
-  const s = await loadSpecies(species);
-  const key = cacheKey(s.id, opts);
-  if (cache.has(key)) return cache.get(key);
-  const p = buildInWorkers(s, opts, onProgress).catch((e) => { cache.delete(key); throw e; });
-  cache.set(key, p);
-  return p;
-}
-export function clearBuildCache() { cache.clear(); }
-
-async function buildInWorkers(species, opts, onProgress) {
-  const o = normaliseOptions(opts);
-  const nJobs = species.regions ? null : 1;
-  void nJobs;
-  const first = makeWorker(opts.worker);
-  if (!first) {
-    await new Promise((r) => setTimeout(r, 0));
-    return buildSync(species, o, onProgress);
-  }
-  const t0 = performance.now();
-  // how many meshing jobs? (cheap: prepare runs the sculpt only)
-  const { prepare } = await import('./core/build/pipeline.js');
-  const jobsN = prepare(species, o).reg.jobs.length;
-  const workers = [first];
-  for (let i = 1; i < jobsN; i++) { const w = makeWorker(opts.worker); if (w) workers.push(w); }
-  const call = (w, msg) => new Promise((resolve, reject) => {
-    w.onmessage = (e) => {
-      const m = e.data;
-      if (m.type === 'progress') onProgress(m.msg);
-      else if (m.type === 'error') reject(new Error(m.message));
-      else resolve(m);
-    };
-    w.onerror = (e) => reject(new Error(e.message || 'procedural-animals worker failed'));
-    w.postMessage(msg);
-  });
-  try {
-    const jobs = new Array(jobsN);
-    let next = 0;
-    await Promise.all(workers.map(async (w) => {
-      while (next < jobsN) {
-        const j = next++;
-        onProgress('mesh ' + j);
-        const r = await call(w, { task: 'mesh', species: species.id, opts: o, job: j });
-        jobs[j] = r.parts;
-      }
-    }));
-    onProgress('finish');
-    const r = await call(first, { task: 'finish', species: species.id, opts: o, jobs });
-    r.data.stats.buildMs = Math.round(performance.now() - t0);
-    return r.data;
-  } finally {
-    for (const w of workers) w.terminate();
-  }
-}

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

@@ -1,121 +0,0 @@
-// Helpers for species coat painters.
-import { SDFModel } from '../sdf/sdf.js';
-import { sub, add, mul, dot, len, clamp, mix } from '../math/vec.js';
-
-// sRGB hex -> linear rgb
-export const srgb = (hex) => {
-  const c = [(hex >> 16) & 255, (hex >> 8) & 255, hex & 255].map((v) => v / 255);
-  return c.map((v) => (v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4)));
-};
-export const mix3 = (a, b, t) => [mix(a[0], b[0], t), mix(a[1], b[1], t), mix(a[2], b[2], t)];
-export const scale3 = (a, k) => [a[0] * k, a[1] * k, a[2] * k];
-
-// Material ids stored in tint.w (see render/coatMaterial.js)
-export const MAT = { FUR: 0, NOSE: 1, DARK_SKIN: 2, MOUTH: 3, SKIN: 4, KERATIN: 5, SCALES: 6, WET_SKIN: 7, CHITIN: 8, FEATHER: 9, VANE: 10, FIN: 11 }; // 10: flight-feather vane (featherCards.js), 11: fin membrane (render/membranes.js)
-
-// Newton-project a point onto the zero set of a primitive list
-export function projectToSurface(prims, q, iters = 6) {
-  let x = q.slice();
-  for (let i = 0; i < iters; i++) {
-    const d = SDFModel.evalList(prims, x[0], x[1], x[2]);
-    const e = 0.0005;
-    const g = [
-      SDFModel.evalList(prims, x[0] + e, x[1], x[2]) - d,
-      SDFModel.evalList(prims, x[0], x[1] + e, x[2]) - d,
-      SDFModel.evalList(prims, x[0], x[1], x[2] + e) - d,
-    ].map((c) => c / e);
-    const gl = len(g) || 1;
-    x = sub(x, mul(g, d / (gl * gl)));
-  }
-  return x;
-}
-
-// distance from p to a polyline with per-vertex half widths (negative inside)
-export function distPolyline(p, poly, widths) {
-  let best = 1e9;
-  for (let i = 0; i < poly.length - 1; i++) {
-    const a = poly[i], b = poly[i + 1], ab = sub(b, a);
-    const t = clamp(dot(sub(p, a), ab) / dot(ab, ab), 0, 1);
-    const d = len(sub(p, add(a, mul(ab, t)))) - mix(widths[i], widths[i + 1], t);
-    if (d < best) best = d;
-  }
-  return best;
-}
-
-// Laplacian smoothing of a scalar field over the mesh graph; `lock(v)` keeps a vertex fixed
-export function smoothField(f, neighbors, iters = 2, lock = null) {
-  const n = f.length, tmp = new Float32Array(n);
-  for (let it = 0; it < iters; it++) {
-    for (let v = 0; v < n; v++) {
-      const ns = neighbors[v];
-      if (!ns.length || (lock && lock(v))) { tmp[v] = f[v]; continue; }
-      let a = 0;
-      for (const u of ns) a += f[u];
-      tmp[v] = 0.5 * f[v] + (0.5 * a) / ns.length;
-    }
-    f.set(tmp);
-  }
-  return f;
-}
-
-// Poisson-disc features grown on the surface. radius(v) -> r (0 = no feature here);
-// returns { spots, grid, cell, key } for use with featureField.
-export function poissonFeatures({ pos, nrm, nV, radius, R, spacing = 1.52, gap = 0.0025, cell = 0.03, skip = null, extra = null }) {
-  const order = new Uint32Array(nV);
-  for (let i = 0; i < nV; i++) order[i] = i;
-  for (let i = nV - 1; i > 0; i--) { const j = Math.floor(R() * (i + 1)); const t = order[i]; order[i] = order[j]; order[j] = t; }
-  const grid = new Map();
-  const key = (x, y, z) => ((x + 512) * 1024 + (y + 512)) * 1024 + (z + 512);
-  const spots = [];
-  for (let k = 0; k < nV; k++) {
-    const v = order[k];
-    if (skip && skip(v)) continue;
-    let r = radius(v);
-    if (!(r > 0)) continue;
-    r *= 0.78 + 0.44 * R();
-    const p = [pos[v * 3], pos[v * 3 + 1], pos[v * 3 + 2]];
-    const gx = Math.floor(p[0] / cell), gy = Math.floor(p[1] / cell), gz = Math.floor(p[2] / cell);
-    let ok = true;
-    for (let dz = -1; dz <= 1 && ok; dz++)
-      for (let dy = -1; dy <= 1 && ok; dy++)
-        for (let dx = -1; dx <= 1 && ok; dx++) {
-          const arr = grid.get(key(gx + dx, gy + dy, gz + dz));
-          if (!arr) continue;
-          for (const s of arr) {
-            const minD = spacing * (r + s.r) + gap;
-            const ddx = p[0] - s.p[0], ddy = p[1] - s.p[1], ddz = p[2] - s.p[2];
-            if (ddx * ddx + ddy * ddy + ddz * ddz < minD * minD) { ok = false; break; }
-          }
-        }
-    if (!ok) continue;
-    const s = { v, p, r, n: [nrm[v * 3], nrm[v * 3 + 1], nrm[v * 3 + 2]], ...(extra ? extra(v, R) : {}) };
-    spots.push(s);
-    const kk = key(gx, gy, gz);
-    (grid.get(kk) || grid.set(kk, []).get(kk)).push(s);
-  }
-  return { spots, grid, cell, key };
-}
-
-// Signed distance to the nearest feature of a poissonFeatures() set, elongated along each
-// feature's comb direction `c` by `el`. Returns [sdf, feature].
-export function featureDistance(F, p, n, wob = 1) {
-  const { grid, cell, key } = F;
-  let best = 1e9, bs = null;
-  const gx = Math.floor(p[0] / cell), gy = Math.floor(p[1] / cell), gz = Math.floor(p[2] / cell);
-  for (let dz = -1; dz <= 1; dz++)
-    for (let dy = -1; dy <= 1; dy++)
-      for (let dx = -1; dx <= 1; dx++) {
-        const arr = grid.get(key(gx + dx, gy + dy, gz + dz));
-        if (!arr) continue;
-        for (const s of arr) {
-          if (dot(s.n, n) < 0.2) continue;
-          const d = sub(p, s.p);
-          const el = s.el || 1;
-          const along = s.c ? dot(d, s.c) : 0;
-          const dd = Math.sqrt(Math.max(0, dot(d, d) - along * along * (1 - 1 / (el * el))));
-          const sd = dd - s.r * wob;
-          if (sd < best) { best = sd; bs = s; }
-        }
-      }
-  return [best, bs];
-}

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;
-}