@bitefoundry/retrieviewer 0.0.2 → 0.0.4

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

@@ -1,146 +0,0 @@
-// The public Animal: build data + render object + motion engine behind a small game-facing API.
-import * as THREE from 'three';
-import { createAnimalObject } from './core/render/animalObject.js';
-import { createMotion } from './core/motion/index.js';
-
-const _v = new THREE.Vector3();
-
-export class Animal {
-  constructor(species, data, opts = {}) {
-    this.species = species;
-    this.id = species.id;
-    this.data = data;
-    this.seed = data.seed;
-    this.params = data.params;
-    this.quality = opts.quality || data.quality;
-    const ground = opts.ground || (() => 0);
-    this.ground = ground;
-    this.water = opts.water || null;
-    this.render = createAnimalObject(data, species, { quality: this.quality, castShadow: opts.castShadow, receiveShadow: opts.receiveShadow });
-    /** Add this to your scene. Keep its own transform at identity: the animal moves by itself. */
-    this.object = this.render.group;
-    this.object.userData.animal = this;
-    this._listeners = new Map();
-    this.motion = createMotion(species.plan, {
-      species, data, skeleton: this.render.skeleton, ground, water: this.water, perches: opts.perches,
-      position: opts.position, heading: opts.heading ?? 0,
-      emit: (type, payload) => this._emit(type, payload),
-    });
-    this.attachments = {};
-    this._attachDefs = [];
-    for (const [name, def] of Object.entries(this.motion.attachmentPoints || {})) {
-      const o = new THREE.Object3D();
-      o.name = name;
-      o.matrixAutoUpdate = false;
-      this.object.add(o);
-      this.attachments[name] = o;
-      this._attachDefs.push({ o, ...def });
-    }
-    this.stats = { vertices: data.nV, triangles: data.index.length / 3, bones: data.bones.length, buildMs: data.stats?.buildMs || 0, updateMs: 0 };
-    this.time = 0;
-    this._lastDt = 1 / 60;
-    this.update(0);
-  }
-
-  // ---------------------------------------------------------------- control
-  /** Locomotion: the animal moves itself. speed in m/s, heading in radians (0 = +Z). */
-  move({ speed = 0, heading, climb = 0, gait } = {}) {
-    const inp = this.motion.input;
-    inp.follow = null;
-    inp.target = null;
-    inp.speed = Math.max(0, speed);
-    if (heading !== undefined) inp.heading = heading;
-    inp.climb = climb;
-    inp.gait = gait || null;
-    return this;
-  }
-  stop() { return this.move({ speed: 0 }); }
-  /** Walk / run to a point and stop there. */
-  moveTo(point, { speed = 3 } = {}) {
-    const inp = this.motion.input;
-    inp.follow = null;
-    inp.target = point ? new THREE.Vector3().copy(point) : null;
-    inp.targetSpeed = speed;
-    return this;
-  }
-  /** Match your own physics body: the animal is placed at `position` and animates for `velocity`. */
-  follow(position, velocity, { heading } = {}) {
-    const inp = this.motion.input;
-    inp.follow = inp.follow || { position: new THREE.Vector3(), velocity: new THREE.Vector3(), heading: null };
-    inp.follow.position.copy(position);
-    inp.follow.velocity.copy(velocity || _v.set(0, 0, 0));
-    inp.follow.heading = heading ?? null;
-    return this;
-  }
-  /** Look at a world point (Vector3) or stop looking (null). The animal keeps tracking the point you pass. */
-  lookAt(target) {
-    this.motion.input.look = target ? (target.isVector3 ? target : new THREE.Vector3().copy(target)) : null;
-    return this;
-  }
-  /**
-   * Play an action ('jump', 'sit', 'lie', 'sleep', 'eat', 'drink', 'attack', 'hit', 'death', 'stand', ...).
-   * A new one-shot interrupts the running one; postures cross-fade.
-   * Resolves with 'done' | 'interrupted' | 'stopped' | 'refused'.
-   */
-  play(name, opts = {}) { return this.motion.play(name, opts); }
-  /** End an action (a posture: stand up), or every action but death when no name is given. */
-  stopAction(name) { this.motion.stop(name); return this; }
-  get actions() { return this.motion.actions; }
-  get gaits() { return this.motion.gaits; }
-  /** Named speeds for UIs ({ walk, trot, ... } in m/s, scaled to this individual's size). */
-  get gears() { return this.motion.gears || {}; }
-
-  // ---------------------------------------------------------------- events
-  on(type, fn) {
-    if (!this._listeners.has(type)) this._listeners.set(type, new Set());
-    this._listeners.get(type).add(fn);
-    return () => this.off(type, fn);
-  }
-  off(type, fn) { this._listeners.get(type)?.delete(fn); return this; }
-  _emit(type, payload) {
-    const set = this._listeners.get(type);
-    if (set) for (const fn of set) fn({ type, animal: this, ...payload });
-  }
-
-  // ---------------------------------------------------------------- state
-  get position() { return this.motion.state.position; }
-  get heading() { return this.motion.state.heading; }
-  get speed() { return this.motion.state.speed; }
-  get velocity() { return this.motion.state.velocity; }
-  get state() { return this.motion.state; }
-
-  // ---------------------------------------------------------------- frame
-  /** Call once per frame with the frame time in seconds. */
-  update(dt) {
-    const t0 = now();
-    if (!(dt >= 0) || !Number.isFinite(dt)) dt = 0;
-    dt = Math.min(dt, 0.1);
-    this.time += dt;
-    this.motion.update(dt);
-    this.render.update({ dt, time: this.time, motion: this.motion });
-    for (const a of this._attachDefs) {
-      const b = this.render.skeleton.byName[a.bone];
-      if (!b) continue;
-      a.o.matrix.multiplyMatrices(b.matrixWorld, a.local);
-      a.o.matrixWorld.multiplyMatrices(this.object.matrixWorld, a.o.matrix);
-      a.o.matrixWorldNeedsUpdate = false;
-    }
-    this.stats.updateMs = this.stats.updateMs * 0.9 + (now() - t0) * 0.1;
-    return this;
-  }
-
-  setQuality(q) { this.render.setQuality?.(q); this.quality = q; return this; }
-  /** Motion level of detail: 0 full, 1 reduced secondary motion, 2 crowd (half-rate IK). */
-  setLod(level) { this.motion.setLod?.(level); this.lod = level; return this; }
-  setDebug(mode, on) { this.render.setDebug?.(mode, on); return this; }
-  /** Show or hide the coverings (fur shells and silhouette fins); the base still reads as fur. */
-  setCoverings(on) { this.render.setCoverings?.(on); return this; }
-
-  dispose() {
-    this.render.dispose();
-    this.motion.dispose?.();
-    this._listeners.clear();
-  }
-}
-
-const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());

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