@bitefoundry/retrieviewer 0.0.2 → 0.0.4

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

@@ -1,263 +0,0 @@
-// Signed distance field built from bone-attached primitives, combined with smooth unions
-// (polynomial smooth-min, per-primitive blend radius) and smooth subtractions (carvers).
-import { frameZY, sub, norm } from '../math/vec.js';
-
-export const T_ELL = 0;
-export const T_CONE = 1;
-export const T_LENS = 2; // almond (vesica) prism along a view axis, clipped to a depth slab: eye apertures
-export const T_FIN = 3; // thin slab: a planar polygon extruded to a thickness, rim rounded (fin membranes)
-
-function sminf(a, b, k) {
-  if (k <= 0) return a < b ? a : b;
-  const d = a - b;
-  const h = Math.max(k - Math.abs(d), 0) / k;
-  return (a < b ? a : b) - h * h * k * 0.25;
-}
-
-export class SDFModel {
-  constructor() {
-    this.prims = [];
-  }
-
-  // Ellipsoid. axis = direction of local Z (radius r[2]), up = hint for local Y (radius r[1]).
-  ell(o) {
-    const [ax, ay, az] = frameZY(o.axis || [0, 0, 1], o.up || [0, 1, 0]);
-    const P = new Float64Array(15);
-    P.set(o.c, 0);
-    P.set(ax, 3);
-    P.set(ay, 6);
-    P.set(az, 9);
-    P[12] = o.r[0];
-    P[13] = o.r[1];
-    P[14] = o.r[2];
-    return this._push(T_ELL, P, o);
-  }
-
-  sphere(o) {
-    return this.ell({ ...o, r: [o.rad, o.rad, o.rad] });
-  }
-
-  // Round cone (tapered capsule) between a and b with radii ra, rb.
-  cone(o) {
-    const P = new Float64Array(12);
-    const ba = sub(o.b, o.a);
-    const l2 = ba[0] * ba[0] + ba[1] * ba[1] + ba[2] * ba[2];
-    const rr = o.ra - o.rb;
-    P.set(o.a, 0);
-    P.set(ba, 3);
-    P[6] = l2;
-    P[7] = rr;
-    P[8] = l2 - rr * rr;
-    P[9] = 1 / l2;
-    P[10] = o.ra;
-    P[11] = o.rb;
-    return this._push(T_CONE, P, o);
-  }
-
-  // Almond-shaped aperture: the intersection of two cylinders of radius R whose axes run along the
-  // frame's Z and are offset by -/+d along its Y (upper / lower lid arcs), clipped to zMin..zMax.
-  lens(o) {
-    const P = new Float64Array(16);
-    P.set(o.c, 0);
-    P.set(o.x, 3);
-    P.set(o.y, 6);
-    P.set(o.z, 9);
-    P[12] = o.R;
-    P[13] = o.d;
-    P[14] = o.zMin;
-    P[15] = o.zMax;
-    return this._push(T_LENS, P, o);
-  }
-
-  // Fin membrane: a planar polygon (2D points in the plane spanned by u, v from origin o) extruded
-  // to thickness t along n = u x v, with a rounded rim (radius min(round, t/2)). Exact distance, so
-  // thin membranes mesh cleanly with a constant thickness right to the edge. `poly` is a closed
-  // outline [[u, v], ...] (either winding).
-  // Optional, for tiles of a curved sheet of varying thickness (a thick ear root thinning to its rim):
-  // - `grad: [gu, gv]`: the thickness tapers linearly in the plane (t at the origin, the half thickness
-  //   changing by gu / gv per metre along u / v, the rim radius in proportion);
-  // - `curve: [m0, mu, mv, muu, muv, mvv]`: the slab's mid-surface is the quadric patch
-  //   n = m0 + mu u + mv v + (muu u^2 + 2 muv u v + mvv v^2) / 2 over the polygon instead of the plane, so
-  //   neighbouring tiles fitted to one smooth sheet join with continuous tangents (no facets).
-  // The distance is then divided by sqrt(1 + (|grad| + |slope of the patch|)^2), a local Lipschitz bound
-  // (approximate: exact for the plane). Without them the slab and its distance are exactly as before.
-  fin(o) {
-    const u = norm(o.u), n = norm(crossV(o.u, o.v)), v = crossV(n, u);
-    const pts = o.poly;
-    const c = o.curve && o.curve.some((x) => x) ? o.curve : null;
-    const g = c || (o.grad && (o.grad[0] || o.grad[1])) ? o.grad || [0, 0] : null;
-    const P = new Float64Array(15 + pts.length * 2 + (g ? 2 : 0) + (c ? 6 : 0));
-    P.set(o.o, 0);
-    P.set(u, 3);
-    P.set(v, 6);
-    P.set(n, 9);
-    P[12] = o.t / 2;
-    P[13] = Math.min(o.round ?? o.t / 2, o.t / 2);
-    P[14] = pts.length;
-    for (let i = 0; i < pts.length; i++) { P[15 + i * 2] = pts[i][0]; P[16 + i * 2] = pts[i][1]; }
-    if (g) { P[15 + pts.length * 2] = g[0]; P[16 + pts.length * 2] = g[1]; }
-    if (c) for (let i = 0; i < 6; i++) P[17 + pts.length * 2 + i] = c[i];
-    return this._push(T_FIN, P, o);
-  }
-
-  _push(type, P, o) {
-    const prim = {
-      type,
-      P,
-      k: o.k ?? 0.02,
-      bone: o.bone,
-      group: o.group || 'axial',
-      part: o.part || 'body',
-      carve: !!o.carve,
-      tag: o.tag || '',
-      bias: o.bias || 0,
-      id: this.prims.length,
-    };
-    this.prims.push(prim);
-    return prim;
-  }
-
-  // Raw distance to a single primitive
-  static dist(pr, x, y, z) {
-    const P = pr.P;
-    if (pr.type === T_ELL) {
-      const dx = x - P[0], dy = y - P[1], dz = z - P[2];
-      const lx = dx * P[3] + dy * P[4] + dz * P[5];
-      const ly = dx * P[6] + dy * P[7] + dz * P[8];
-      const lz = dx * P[9] + dy * P[10] + dz * P[11];
-      const rx = P[12], ry = P[13], rz = P[14];
-      const qx = lx / rx, qy = ly / ry, qz = lz / rz;
-      const k0 = Math.sqrt(qx * qx + qy * qy + qz * qz);
-      const sx = qx / rx, sy = qy / ry, sz = qz / rz;
-      const k1 = Math.sqrt(sx * sx + sy * sy + sz * sz);
-      if (k1 < 1e-12) return -Math.min(rx, ry, rz);
-      return (k0 * (k0 - 1)) / k1;
-    } else if (pr.type === T_LENS) {
-      const dx = x - P[0], dy = y - P[1], dz = z - P[2];
-      const lx = dx * P[3] + dy * P[4] + dz * P[5];
-      const ly = dx * P[6] + dy * P[7] + dz * P[8];
-      const lz = dx * P[9] + dy * P[10] + dz * P[11];
-      const R = P[12], d = P[13];
-      const lens = Math.max(Math.hypot(lx, ly + d) - R, Math.hypot(lx, ly - d) - R);
-      return Math.max(lens, P[14] - lz, lz - P[15]);
-    } else if (pr.type === T_FIN) {
-      const dx = x - P[0], dy = y - P[1], dz = z - P[2];
-      const pu = dx * P[3] + dy * P[4] + dz * P[5];
-      const pv = dx * P[6] + dy * P[7] + dz * P[8];
-      const pn = dx * P[9] + dy * P[10] + dz * P[11];
-      const gi = 15 + 2 * P[14];
-      if (P.length > gi) {
-        // tapered (fin({ grad })) and curved (fin({ curve })) slab: half thickness and rim radius vary linearly
-        // in the plane, the mid-surface is a quadric patch over it
-        const gu = P[gi], gv = P[gi + 1];
-        const hh = Math.max(0.2 * P[12], P[12] + gu * pu + gv * pv), rho = Math.min(hh, (P[13] * hh) / P[12]);
-        let q = pn, sl = 0;
-        if (P.length > gi + 2) {
-          const su = P[gi + 3] + P[gi + 5] * pu + P[gi + 6] * pv, sv = P[gi + 4] + P[gi + 6] * pu + P[gi + 7] * pv;
-          q = pn - (P[gi + 2] + P[gi + 3] * pu + P[gi + 4] * pv + 0.5 * (P[gi + 5] * pu * pu + 2 * P[gi + 6] * pu * pv + P[gi + 7] * pv * pv));
-          sl = Math.sqrt(su * su + sv * sv);
-        }
-        const ex = polySD(P, pu, pv) + rho, ey = Math.abs(q) - (hh - rho);
-        const ox = ex > 0 ? ex : 0, oy = ey > 0 ? ey : 0;
-        const L = Math.sqrt(gu * gu + gv * gv) + sl;
-        return (Math.min(Math.max(ex, ey), 0) + Math.sqrt(ox * ox + oy * oy) - rho) / Math.sqrt(1 + L * L);
-      }
-      const rho = P[13];
-      const ex = polySD(P, pu, pv) + rho, ey = Math.abs(pn) - (P[12] - rho);
-      const ox = ex > 0 ? ex : 0, oy = ey > 0 ? ey : 0;
-      return Math.min(Math.max(ex, ey), 0) + Math.sqrt(ox * ox + oy * oy) - rho;
-    } else {
-      // IQ exact round cone
-      const pax = x - P[0], pay = y - P[1], paz = z - P[2];
-      const bax = P[3], bay = P[4], baz = P[5];
-      const l2 = P[6], rr = P[7], a2 = P[8], il2 = P[9], r1 = P[10], r2 = P[11];
-      const yy = pax * bax + pay * bay + paz * baz;
-      const zz = yy - l2;
-      const vx = pax * l2 - bax * yy, vy = pay * l2 - bay * yy, vz = paz * l2 - baz * yy;
-      const x2 = vx * vx + vy * vy + vz * vz;
-      const y2 = yy * yy * l2;
-      const z2 = zz * zz * l2;
-      const k = Math.sign(rr) * rr * rr * x2;
-      if (Math.sign(zz) * a2 * z2 > k) return Math.sqrt(x2 + z2) * il2 - r2;
-      if (Math.sign(yy) * a2 * y2 < k) return Math.sqrt(x2 + y2) * il2 - r1;
-      return (Math.sqrt(x2 * a2 * il2) + yy * rr) * il2 - r1;
-    }
-  }
-
-  // Evaluate the field using only the primitives in `list` (array of prim objects, in model order)
-  static evalList(list, x, y, z) {
-    let d = 1e9;
-    let carving = false;
-    for (let i = 0; i < list.length; i++) {
-      const pr = list[i];
-      const di = SDFModel.dist(pr, x, y, z);
-      if (!pr.carve) d = sminf(d, di, pr.k);
-      else {
-        carving = true;
-        d = -sminf(-d, di, pr.k);
-      }
-    }
-    return d;
-  }
-
-  forPart(part) {
-    return this.prims.filter((p) => p.part === part);
-  }
-
-  // Conservative culling: primitives that cannot influence the field inside a cell (center c, radius rho)
-  static cull(list, cx, cy, cz, rho, kmax) {
-    const n = list.length;
-    const dv = new Float64Array(n);
-    let best = 1e9;
-    for (let i = 0; i < n; i++) {
-      dv[i] = SDFModel.dist(list[i], cx, cy, cz);
-      if (!list[i].carve && dv[i] < best) best = dv[i];
-    }
-    const out = [];
-    const margin = 2.2 * rho + 0.5 * kmax;
-    for (let i = 0; i < n; i++) {
-      const pr = list[i];
-      if (!pr.carve) {
-        if (dv[i] - best < margin + pr.k) out.push(pr);
-      } else {
-        // carvers only matter close to the surface
-        if (dv[i] < pr.k + margin + Math.max(0, -best)) out.push(pr);
-      }
-    }
-    return out;
-  }
-}
-
-const crossV = (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]];
-
-// signed distance to a closed 2D polygon stored in P from index 15 (count at P[14]); < 0 inside
-export function polySD(P, px, py) {
-  const n = P[14];
-  let vx = P[15], vy = P[16];
-  let d = (px - vx) * (px - vx) + (py - vy) * (py - vy);
-  let s = 1;
-  for (let i = 0, j = n - 1; i < n; j = i, i++) {
-    const ix = P[15 + i * 2], iy = P[16 + i * 2], jx = P[15 + j * 2], jy = P[16 + j * 2];
-    const ex = jx - ix, ey = jy - iy, wx = px - ix, wy = py - iy;
-    const t = Math.max(0, Math.min(1, (wx * ex + wy * ey) / (ex * ex + ey * ey || 1e-18)));
-    const bx = wx - ex * t, by = wy - ey * t;
-    const dd = bx * bx + by * by;
-    if (dd < d) d = dd;
-    const c1 = py >= iy, c2 = py < jy, c3 = ex * wy > ey * wx;
-    if ((c1 && c2 && c3) || (!c1 && !c2 && !c3)) s = -s;
-  }
-  void vx; void vy;
-  return s * Math.sqrt(d);
-}
-
-export function gradient(list, x, y, z, e = 0.0006) {
-  // tetrahedral gradient
-  const f = SDFModel.evalList;
-  const a = f(list, x + e, y - e, z - e);
-  const b = f(list, x - e, y - e, z + e);
-  const c = f(list, x - e, y + e, z - e);
-  const d = f(list, x + e, y + e, z + e);
-  return [a - b - c + d, -a - b + c + d, -a + b - c + d].map((v) => v / (4 * e));
-}
-
-export { norm };

package/vendor/procedural-animals/src/index.d.ts

@@ -1,98 +0,0 @@
-// Type declarations for procedural-animals (three.js Procedural Animals).
-import type { Object3D, Vector3 } from 'three';
-
-export type SpeciesId =
-  | 'wolf' | 'dog' | 'fox' | 'cat' | 'lion' | 'cheetah' | 'bear' | 'rat'
-  | 'horse' | 'deer' | 'cow' | 'pig' | 'sheep' | 'goat' | 'boar'
-  | 'chicken' | 'crow' | 'eagle' | 'fish' | 'shark'
-  | 'rabbit' | 'frog' | 'snake' | 'spider';
-
-export type Quality = 'hero' | 'high' | 'medium' | 'low' | 'crowd';
-
-export type ActionName =
-  | 'idle' | 'jump' | 'sit' | 'lie' | 'sleep' | 'eat' | 'drink' | 'attack' | 'hit' | 'death' | 'stand'
-  | 'takeoff' | 'land' | 'perch' | 'glide' | 'flap' | 'burst' | 'coil' | 'strike' | 'hop'
-  | (string & {});
-
-export interface CreateAnimalOptions {
-  seed?: number;
-  quality?: Quality;
-  variant?: string;
-  sex?: 'male' | 'female' | string;
-  age?: 'adult' | 'juvenile' | string;
-  /** Terrain height in the space of animal.object.parent. Default: flat y = 0. */
-  ground?: (x: number, z: number) => number;
-  /** Water surface height, or null where dry (swimmers, drinking). */
-  water?: (x: number, z: number) => number | null;
-  /** Perch points for birds. */
-  perches?: Vector3[];
-  position?: Vector3;
-  heading?: number;
-  /** A .animal file (from `procedural-animals-bake`) instead of building procedurally. */
-  baked?: ArrayBuffer | Promise<ArrayBuffer>;
-  /** false: build on the calling thread; a function: returns a Worker running the library's worker (procedural-animals/worker). */
-  worker?: boolean | (() => Worker);
-  castShadow?: boolean;
-  receiveShadow?: boolean;
-  onProgress?: (message: string) => void;
-  overrides?: Record<string, unknown>;
-}
-
-export interface FootstepEvent { type: 'footstep'; animal: Animal; foot: string; position: Vector3; speed: number; strength: number; }
-export interface AttackHitEvent { type: 'attackHit'; animal: Animal; position: Vector3; direction?: Vector3; style?: string; }
-export interface ActionEvent { type: 'actionStart' | 'actionEnd'; animal: Animal; name: string; reason?: string; }
-export type AnimalEvent = FootstepEvent | AttackHitEvent | ActionEvent | { type: string; animal: Animal; [k: string]: unknown };
-
-export type PlayResult = 'done' | 'interrupted' | 'stopped' | 'refused';
-
-export interface PlayOptions { target?: Vector3; direction?: Vector3; loop?: boolean; speed?: number; [k: string]: unknown; }
-
-export declare class Animal {
-  readonly id: string;
-  readonly seed: number;
-  readonly params: Record<string, unknown>;
-  /** Add this to your scene; keep its own transform at identity. */
-  readonly object: Object3D;
-  /** Attachment points such as mouth, head, back (horse: seat, stirrupL/R, bitL/R). */
-  readonly attachments: Record<string, Object3D>;
-  readonly stats: { vertices: number; triangles: number; bones: number; buildMs: number; updateMs: number };
-  readonly actions: string[];
-  readonly gaits: string[];
-  /** Named speeds (m/s) for this individual, e.g. { walk: 1.2, trot: 3 }. */
-  readonly gears: Record<string, number>;
-  readonly position: Vector3;
-  readonly heading: number;
-  readonly speed: number;
-  readonly velocity: Vector3;
-  readonly state: Record<string, any>;
-
-  move(opts?: { speed?: number; heading?: number; climb?: number; gait?: string }): this;
-  stop(): this;
-  moveTo(point: Vector3 | null, opts?: { speed?: number }): this;
-  follow(position: Vector3, velocity?: Vector3, opts?: { heading?: number }): this;
-  lookAt(target: Vector3 | null): this;
-  play(name: ActionName, opts?: PlayOptions): Promise<PlayResult>;
-  stopAction(name?: string): this;
-  on(type: 'footstep', fn: (e: FootstepEvent) => void): () => void;
-  on(type: 'attackHit', fn: (e: AttackHitEvent) => void): () => void;
-  on(type: string, fn: (e: AnimalEvent) => void): () => void;
-  off(type: string, fn: (e: AnimalEvent) => void): this;
-  update(dt: number): this;
-  setQuality(q: Quality): this;
-  setLod(level: 0 | 1 | 2): this;
-  setDebug(mode: 'albedo' | 'weights' | 'material' | 'bare', on: boolean): this;
-  setCoverings(on: boolean): this;
-  dispose(): void;
-}
-
-export declare function createAnimal(species: SpeciesId | string | object, opts?: CreateAnimalOptions): Promise<Animal>;
-export declare function registerSpecies(mod: object): object;
-export declare function listSpecies(): string[];
-export declare function loadSpecies(id: string | object): Promise<any>;
-export declare function addLoader(id: string, loader: () => Promise<any>): void;
-export declare function buildAnimalData(species: string | object, opts?: CreateAnimalOptions, onProgress?: (m: string) => void): Promise<any>;
-export declare function setWorkerFactory(fn: (() => Worker) | null): void;
-export declare function clearBuildCache(): void;
-export declare function writeBake(data: any): ArrayBuffer;
-export declare function readBake(buf: ArrayBuffer): any;
-export declare const QUALITY: Record<Quality, { res: number; shells: number; fins: boolean; eyePatches: boolean }>;

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

@@ -1,29 +0,0 @@
-// procedural-animals: three.js Procedural Animals.
-//
-//   const wolf = await createAnimal('wolf', { seed: 3, quality: 'high', ground: (x, z) => h(x, z) });
-//   scene.add(wolf.object);
-//   wolf.move({ speed: 6, heading });   // or wolf.follow(body.position, body.velocity)
-//   wolf.update(dt);                     // every frame
-import { Animal } from './animal.js';
-import { buildAnimalData } from './build.js';
-import { loadSpecies } from './registry.js';
-import { readBake } from './bake.js';
-
-export { Animal } from './animal.js';
-export { registerSpecies, listSpecies, loadSpecies, addLoader } from './registry.js';
-export { buildAnimalData, setWorkerFactory, clearBuildCache } from './build.js';
-export { QUALITY } from './core/build/pipeline.js';
-export { writeBake, readBake } from './bake.js';
-
-/**
- * Create an animal. Builds it procedurally (in Web Workers when available) or loads a baked file.
- * @param {string|object} species  species id ('wolf') or an imported species module
- * @param {object} opts  { seed, quality, sex, age, ground, water, position, heading, baked, worker, onProgress }
- */
-export async function createAnimal(species, opts = {}) {
-  const s = await loadSpecies(species);
-  let data;
-  if (opts.baked) data = readBake(opts.baked instanceof ArrayBuffer ? opts.baked : await opts.baked);
-  else data = await buildAnimalData(s, opts, opts.onProgress);
-  return new Animal(s, data, opts);
-}

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

@@ -1,48 +0,0 @@
-// Species registry. String ids resolve through loaders (dynamic imports), so a bundler only pulls in
-// the species a game actually asks for. Species modules can also be imported and registered
-// directly: `import wolf from 'procedural-animals/species/wolf'; createAnimal(wolf, ...)`.
-const loaders = {
-  bear: () => import('./species/bear/index.js'),
-  boar: () => import('./species/boar/index.js'),
-  cat: () => import('./species/cat/index.js'),
-  cheetah: () => import('./species/cheetah/index.js'),
-  chicken: () => import('./species/chicken/index.js'),
-  cow: () => import('./species/cow/index.js'),
-  crow: () => import('./species/crow/index.js'),
-  deer: () => import('./species/deer/index.js'),
-  dog: () => import('./species/dog/index.js'),
-  eagle: () => import('./species/eagle/index.js'),
-  fish: () => import('./species/fish/index.js'),
-  fox: () => import('./species/fox/index.js'),
-  frog: () => import('./species/frog/index.js'),
-  goat: () => import('./species/goat/index.js'),
-  horse: () => import('./species/horse/index.js'),
-  lion: () => import('./species/lion/index.js'),
-  pig: () => import('./species/pig/index.js'),
-  rabbit: () => import('./species/rabbit/index.js'),
-  rat: () => import('./species/rat/index.js'),
-  shark: () => import('./species/shark/index.js'),
-  sheep: () => import('./species/sheep/index.js'),
-  snake: () => import('./species/snake/index.js'),
-  spider: () => import('./species/spider/index.js'),
-  wolf: () => import('./species/wolf/index.js'),
-};
-const loaded = new Map();
-
-export function registerSpecies(mod) {
-  const s = mod.default || mod;
-  loaded.set(s.id, s);
-  return s;
-}
-
-export async function loadSpecies(id) {
-  if (typeof id === 'object' && id) return registerSpecies(id);
-  if (loaded.has(id)) return loaded.get(id);
-  const l = loaders[id];
-  if (!l) throw new Error(`procedural-animals: unknown species "${id}". Known: ${listSpecies().join(', ')}`);
-  return registerSpecies(await l());
-}
-
-export function getLoadedSpecies(id) { return loaded.get(id); }
-export function listSpecies() { return [...new Set([...Object.keys(loaders), ...loaded.keys()])]; }
-export function addLoader(id, fn) { loaders[id] = fn; }