@bitefoundry/retrieviewer 0.0.0-stage → 0.0.2

package/vendor/procedural-animals/src/species/fish/rig.js

@@ -0,0 +1,143 @@
+// Fish skeleton (bind pose, metres): forward = +Z, up = +Y, left = +X; the body rests just above y = 0.
+// All landmarks come from the variant's outline table (variants.js), so the four body plans share one
+// rig builder. The standard swimmer bone set is in core/rig/swimmer.js.
+import { buildRig } from '../../core/rig/rig.js';
+import { swimmerBones, swimmerAppendages, axialJoints, axialBones, swimmerJointsAlias, spineName } from '../../core/rig/swimmer.js';
+import { VARIANTS } from './variants.js';
+import { norm, add, mul } from '../../core/math/vec.js';
+
+const cr = (p0, p1, p2, p3, t) => {
+  // Catmull-Rom (centripetal enough for our smooth tables), clamped to the neighbours' range
+  const t2 = t * t, t3 = t2 * t;
+  const v = 0.5 * (2 * p1 + (-p0 + p2) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (-p0 + 3 * p1 - 3 * p2 + p3) * t3);
+  const lo = Math.min(p1, p2), hi = Math.max(p1, p2), pad = (hi - lo) * 0.25;
+  return Math.max(lo - pad, Math.min(hi + pad, v));
+};
+
+/** Geometry helper for one variant: outline lookups (metres) and the landmarks. Cached per params. */
+export function fishGeo(params) {
+  const key = params.variant;
+  const V = VARIANTS[key];
+  if (!V) throw new Error(`fish: unknown variant "${key}"`);
+  const SL = V.SL;
+  const rows = V.prof;
+  const n = rows.length;
+  const col = (i, k) => rows[Math.max(0, Math.min(n - 1, i))][k];
+  const at = (u, k) => {
+    if (u <= rows[0][0]) return rows[0][k] * Math.sqrt(Math.max(0, u) / rows[0][0]);
+    if (u >= rows[n - 1][0]) return rows[n - 1][k];
+    let i = 0;
+    while (i < n - 2 && u > rows[i + 1][0]) i++;
+    const t = (u - rows[i][0]) / (rows[i + 1][0] - rows[i][0]);
+    return cr(col(i - 1, k), col(i, k), col(i + 1, k), col(i + 2, k), t);
+  };
+  let maxBot = 0;
+  for (const r of rows) maxBot = Math.max(maxBot, r[2]);
+  const axisY = (maxBot + 0.04) * SL;
+  const z0 = 0.42 * SL;
+  const G = {
+    V, SL, axisY, z0,
+    tailLen: V.fins.caudal.len * (params.tailK || 1),
+    finK: params.finK || 1,
+    L: SL * (1 + V.fins.caudal.len * (params.tailK || 1) * 0.95),
+    z: (u) => z0 - u * SL,
+    u: (z) => (z0 - z) / SL,
+    top: (u) => at(u, 1) * SL,
+    bot: (u) => at(u, 2) * SL,
+    hw: (u) => at(u, 3) * SL,
+    yc: (u) => axisY + ((at(u, 1) - at(u, 2)) / 2) * SL,
+    hd: (u) => ((at(u, 1) + at(u, 2)) / 2) * SL,
+  };
+  // surface half width at height y (elliptic cross-section)
+  G.surfX = (u, y) => {
+    const e = (y - G.yc(u)) / Math.max(1e-6, G.hd(u));
+    return G.hw(u) * Math.sqrt(Math.max(0, 1 - e * e));
+  };
+  // a point on the flank surface at (u, height fraction e in -1..1 of the half depth)
+  G.flank = (u, e, s = 1) => {
+    const y = G.yc(u) + e * G.hd(u);
+    return [s * G.surfX(u, y), y, G.z(u)];
+  };
+  const H = V.head;
+  G.mouthY = axisY + H.mouth.h * SL;
+  const eu = H.eye.u, ey = axisY + H.eye.h * SL;
+  G.eye = { u: eu, y: ey, r: H.eye.r * SL, z: G.z(eu) };
+  G.eye.x = G.surfX(eu, ey) - 0.62 * G.eye.r; // flush: only a shallow cap shows
+  G.headO = [0, ey, G.z(eu)];
+  return G;
+}
+
+export function fishJoints(params) {
+  const G = fishGeo(params);
+  const V = G.V, SL = G.SL, H = V.head, F = V.fins;
+  const N = V.spineSegs, M = V.caudalSegs;
+  const J = {};
+  J.snout = [0, G.mouthY + 0.004 * SL, G.z0];
+  for (let i = 0; i <= N; i++) {
+    const u = H.occ + ((1 - H.occ) * i) / N;
+    J[spineName(i)] = [0, G.yc(u), G.z(u)];
+  }
+  swimmerJointsAlias(J, N);
+  const cl = G.tailLen * 0.86;
+  for (let j = 1; j <= M; j++) J['caudal' + j] = [0, G.yc(1), G.z(1 + (cl * j) / M)];
+  // lower jaw: hinge below the end of the gape, tip at the chin
+  const g = H.mouth.gape;
+  J.jawHinge = [0, G.mouthY - H.mouth.jawDepth * SL * 0.55, G.z(g + 0.02)];
+  J.jawTip = [0, G.mouthY - 0.006 * SL, G.z(0.004)];
+  J.premaxBase = [0, G.mouthY + 0.03 * SL, G.z(g * 0.85)];
+  J.premaxTip = [0, G.mouthY + 0.008 * SL, G.z(0.0)];
+  // gill cover: hinge along its front edge, free edge at the back
+  const op = H.op;
+  J.opHingeL = G.flank(op - 0.075, 0.5);
+  J.opLowL = G.flank(op - 0.1, -0.45);
+  J.opEdgeL = G.flank(op, 0.05);
+  // pectoral fin: base line on the flank behind the gill cover
+  const P = F.pectoral;
+  const pb = G.flank(P.u, (P.h * SL - (G.yc(P.u) - G.axisY)) / G.hd(P.u));
+  pb[0] += 0.004 * SL;
+  J.pecBaseL = pb;
+  J.pecUpL = [pb[0] - 0.004 * SL, pb[1] + 0.03 * SL, pb[2] + 0.008 * SL];
+  J.pecTipL = add(pb, mul(finDir(P.sweep, P.droop, P.abduct), P.len * G.finK * SL));
+  // pelvic fin: on the belly
+  const Q = F.pelvic;
+  const ybot = G.yc(Q.u) - G.hd(Q.u);
+  const pl = [G.hw(Q.u) * 0.42, ybot + 0.18 * G.hd(Q.u) * 0.3, G.z(Q.u)];
+  pl[1] = G.yc(Q.u) - G.hd(Q.u) * Math.sqrt(1 - Math.pow(pl[0] / G.hw(Q.u), 2)) + 0.003 * SL;
+  J.pelBaseL = pl;
+  J.pelFrontL = [pl[0] + 0.02 * SL, pl[1] - 0.004 * SL, pl[2] + 0.004 * SL];
+  J.pelTipL = add(pl, mul(finDir(90 - Q.sweep, 90 - Q.sweep * 0.2, Q.abduct, true), Q.len * G.finK * SL));
+  return { J, G };
+}
+
+// Fin direction: `sweep` deg back from lateral toward -Z, `droop` deg below horizontal, `abduct` deg
+// out from the body wall. For the pelvic (ventral) fins pass ventral = true: they point back and down.
+export function finDir(sweep, droop, abduct, ventral = false) {
+  const d2r = Math.PI / 180;
+  if (ventral) {
+    const back = Math.cos(abduct * d2r), out = Math.sin(abduct * d2r);
+    return norm([out * 0.8, -Math.sin((90 - droop) * d2r) * 0.55 - 0.25, -back]);
+  }
+  const ab = abduct * d2r, dr = droop * d2r;
+  return norm([Math.sin(ab), -Math.sin(dr), -Math.cos(ab) * Math.cos(dr)]);
+}
+
+export function pickParent(G, u) {
+  const V = G.V, N = V.spineSegs, occ = V.head.occ;
+  const i = Math.max(0, Math.min(N - 1, Math.floor(((u - occ) / (1 - occ)) * N)));
+  return spineName(i);
+}
+
+export function fishRig(params) {
+  const { J, G } = fishJoints(params);
+  const V = G.V, N = V.spineSegs, M = V.caudalSegs;
+  return buildRig({
+    joints: J,
+    unit: G.L / 1.3,
+    headOrigin: G.headO,
+    bones: swimmerBones({ spineSegs: N, caudalSegs: M, jaw: true, upperJaw: true, opercula: true, pectoralParent: pickParent(G, V.fins.pectoral.u), pelvicParent: pickParent(G, V.fins.pelvic.u) }),
+    axial: { points: axialJoints(N, M), bones: axialBones(N, M) },
+    limbs: {},
+    appendages: swimmerAppendages({ upperJaw: true, blend: [-0.004, 0.006] }),
+    meta: { variant: params.variant, SL: G.SL },
+  });
+}

package/vendor/procedural-animals/src/species/fish/sculpt.js

@@ -0,0 +1,214 @@
+// Fish sculpt: a dense chain of elliptic cross-sections along the outline table, a separately meshed
+// lower jaw (cut from the same sections with two complementary profile prisms, so the lip line
+// matches exactly), gill covers with a free rear edge over a gill slit, lidless eyes seated in a
+// shallow orbit, and every fin as a thin membrane slab (core/rig/swimmer.js sculptFin).
+import { fishGeo, pickParent } from './rig.js';
+import { sculptFin, fanRays, spineName } from '../../core/rig/swimmer.js';
+import { add, sub, mul, norm, lerp } from '../../core/math/vec.js';
+
+// hero cell size relative to SL (regions.js) and the fin membrane thickness derived from it
+export const CELL = 1 / 300;
+export const finThickness = (SL, V) => SL * CELL * (V?.cellK || 1) * 2.9;
+// lip thickness in front of the buccal cavity (fraction of SL)
+export const MOUTH_LIP = 0.022;
+// the free (rear) edge of the gill cover: u (fraction of SL) at height e (-1 belly .. 1 back, fraction of
+// the half depth); the gill cover plate below follows it, the coat paints the edge line along it
+export const opEdgeU = (op, e) => op + 0.003 - 0.045 * Math.min(1.44, e * e);
+
+export function sculptFish(m, rig, params) {
+  const G = fishGeo(params);
+  const V = G.V, SL = G.SL, J = rig.J, H = V.head, F = V.fins;
+  const N = V.spineSegs;
+  const boneAt = (u) => (u < H.occ ? 'head' : pickParent(G, u));
+  const t = finThickness(SL, V);
+
+  // ---------------------------------------------------------------- body sections
+  const step = 0.018, rzMax = 0.05;
+  const station = (u, part = 'body', extra = {}) => {
+    const rz = Math.min(rzMax, u * 0.95 + 0.004) * SL;
+    return m.ell({ tag: u < H.op ? 'head' : 'body', bone: boneAt(u), c: [0, G.yc(u), G.z(u)], r: [G.hw(u), G.hd(u), rz], k: 0.007 * SL, part, ...extra });
+  };
+  for (let u = 0.012; u <= 1.0001; u += step) station(Math.min(u, 1));
+  // the caudal peduncle runs on into the fin base
+  m.ell({ tag: 'body', bone: 'caudal0', c: [0, G.yc(1), G.z(1.025)], r: [G.hw(1) * 0.8, G.hd(1) * 0.92, 0.035 * SL], k: 0.008 * SL });
+
+  // ---------------------------------------------------------------- head features
+  // Eyes: no socket and no orbit rim. A fish's cornea bulges straight out of smooth head skin, so the
+  // lidless eyeball (drawn by the eye renderer) simply stands out of the head surface: the depth test
+  // draws the skin / cornea boundary as a clean circle at every tier. A socket carved around the ball
+  // left a sub-cell gap that meshed into a jagged dark rim, and a hole at the eye's front corner.
+  // gill covers: a plate on each cheek, slightly proud, free along its rear edge
+  const op = H.op;
+  for (const S of ['L', 'R']) {
+    const s = S === 'L' ? 1 : -1;
+    const uc = op - 0.055;
+    const c = G.flank(uc, 0.02, s);
+    const nrm = norm([s, 0, 0.12]);
+    m.ell({ tag: 'operculum', bone: 'operculum' + S, group: 'operculum' + S, c: sub(c, mul(nrm, 0.0205 * SL)), axis: [0, 0, 1], up: [0, 1, 0], r: [0.0225 * SL, G.hd(uc) * 0.78, 0.062 * SL], k: 0.014 * SL });
+    if (H.earFlap) {
+      // bluegill "ear": a black lobe at the top of the gill cover
+      // a flat rounded lobe reaching back from the upper gill cover (about 0.08 SL long, 0.05 high)
+      const ce = G.flank(op + 0.03, 0.2, s);
+      m.ell({ tag: 'earflap', bone: 'operculum' + S, group: 'operculum' + S, c: sub(ce, [s * 0.0035 * SL, 0, 0]), axis: [0, 0, 1], up: [0, 1, 0], r: [0.0065 * SL, H.earFlap * 0.5 * SL, H.earFlap * 0.8 * SL], k: 0.004 * SL });
+    }
+  }
+  // upper lip / premaxilla (protrudes when feeding)
+  m.ell({ tag: 'lip', bone: 'upperJaw', group: 'upperJaw', c: [0, G.mouthY + 0.01 * SL, G.z(0.02)], r: [G.hw(0.03) * 0.95, 0.012 * SL, 0.022 * SL], k: 0.006 * SL });
+
+  // ---------------------------------------------------------------- carvers (after every union)
+  // mouth: the lower-jaw region, a profile prism in the median plane (z, y), cut out of the body
+  const gape = H.mouth.gape, jd = H.mouth.jawDepth * SL;
+  const zS = G.z0 + 0.03 * SL, yLow = -0.05 * SL;
+  const zc = G.z(gape), zh = G.z(gape + 0.03), zb = G.z(gape + 0.075);
+  const up = H.mouth.upturn * 0.012 * SL;
+  const jawPoly = [[zS, G.mouthY + up], [(zS + zc) / 2, G.mouthY + up * 0.4], [zc, G.mouthY], [zh, G.mouthY - jd * 0.55], [zb, yLow], [zS, yLow]];
+  const gap = 0.0013 * SL;
+  const wide = 0.5 * SL;
+  const prism = (poly, o) => m.fin({ o: [0, 0, 0], u: [0, 0, 1], v: [0, 1, 0], t: wide, poly, round: 0, ...o });
+  prism(offsetPoly(jawPoly, gap * 0.5), { tag: 'mouthcut', bone: 'head', carve: true, k: 0.004 * SL });
+  // buccal cavity: it starts behind the lips (MOUTH_LIP of SL behind the snout), so a closed mouth
+  // shows only the lip line and the dark cavity appears when the jaw drops. (Reaching through the
+  // snout, it held the mouth open as a dark O at rest.)
+  const uF = MOUTH_LIP, uB = gape + 0.035;
+  const cavY = G.mouthY - 0.003 * SL;
+  const mouthCav = (o) => m.ell({ tag: 'mouth', bone: 'head', c: [0, cavY, G.z((uF + uB) / 2)], r: [G.hw((uF + uB) / 2) * 0.55, Math.min(0.024 * SL, jd * 0.45), ((uB - uF) / 2) * SL], k: 0.003 * SL, carve: true, ...o });
+  mouthCav({});
+  // The gill slit is not carved: a sub-cell groove along the gill cover's edge meshed into a jagged
+  // dark crack. The coat paints the edge as a soft shading line instead (coat.js opEdgeU).
+
+  // ---------------------------------------------------------------- lower jaw (own surface, rigid)
+  const JW = { bone: 'jaw', group: 'jaw', part: 'jaw' };
+  for (let u = 0.012; u <= gape + 0.1; u += step) station(u, 'jaw', { ...JW, tag: 'jaw' });
+  // everything that is not lower jaw: the complement of the jaw prism
+  const big = SL;
+  const rest = [[zS, G.mouthY + up], [zS, G.mouthY + big], [zb - big, G.mouthY + big], [zb - big, yLow], [zb, yLow], [zh, G.mouthY - jd * 0.55], [zc, G.mouthY], [(zS + zc) / 2, G.mouthY + up * 0.4]];
+  prism(offsetPoly(rest, gap * 0.5), { ...JW, tag: 'jawcut', carve: true, k: 0.004 * SL });
+  mouthCav({ ...JW });
+
+  // ---------------------------------------------------------------- median fins (membranes, x = 0 plane)
+  const median = { origin: [0, 0, 0], u: [0, 0, 1], v: [0, 1, 0], t, sink: 0.022 * SL };
+  const dorsalBase = (u) => [G.z(u), G.yc(u) + G.hd(u) - 0.006 * SL];
+  const ventralBase = (u) => [G.z(u), G.yc(u) - G.hd(u) + 0.006 * SL];
+  const profileRays = (d, base, sign) => {
+    const rays = [];
+    for (let i = 0; i < d.n; i++) {
+      const f = d.n === 1 ? 0 : i / (d.n - 1);
+      const u = d.u0 + (d.u1 - d.u0) * f;
+      const a = ((d.a0 + (d.a1 - d.a0) * f) * Math.PI) / 180;
+      let L = d.len[0] + (d.len[1] - d.len[0]) * f;
+      if (d.round) L *= 0.78 + 0.34 * Math.sin(Math.PI * Math.min(1, f * 1.15 + 0.08));
+      if (d.spiny) L *= 1 - 0.18 * f * f;
+      if (!d.round && !d.spiny) L *= 1 - 0.12 * Math.pow(f, 0.7) * (1 - f) * 2.5;
+      const b = base(u);
+      rays.push([b, [b[0] + Math.cos(a) * L * SL, b[1] + Math.sin(a) * L * SL * sign]]);
+    }
+    // close the fin back to the body behind the last ray
+    return rays;
+  };
+  let fi = 0;
+  for (const d of F.dorsal) {
+    const rays = profileRays(d, dorsalBase, 1);
+    sculptFin(m, { ...median, rays, bone: boneAt((d.u0 + d.u1) / 2), tag: 'fin', name: 'dorsal' + fi++, notch: d.notch || 0, k: t * 1.2 });
+  }
+  for (const d of F.anal) {
+    // anal fin angles are given as absolute angles (below the axis)
+    const rays = [];
+    for (let i = 0; i < d.n; i++) {
+      const f = i / (d.n - 1);
+      const u = d.u0 + (d.u1 - d.u0) * f;
+      const a = ((d.a0 + (d.a1 - d.a0) * f) * Math.PI) / 180;
+      let L = d.len[0] + (d.len[1] - d.len[0]) * f;
+      if (d.round) L *= 0.8 + 0.3 * Math.sin(Math.PI * Math.min(1, f * 1.1 + 0.1));
+      const b = ventralBase(u);
+      rays.push([b, [b[0] + Math.cos(a) * L * SL, b[1] + Math.sin(a) * L * SL]]);
+    }
+    sculptFin(m, { ...median, rays, bone: boneAt((d.u0 + d.u1) / 2), tag: 'fin', name: 'anal', k: t * 1.2 });
+  }
+  if (F.adipose) {
+    const d = F.adipose, rays = [];
+    for (let i = 0; i < 6; i++) {
+      const f = i / 5, u = d.u0 + (d.u1 - d.u0) * f;
+      const b = dorsalBase(u);
+      const L = d.h * SL * (0.35 + 0.75 * Math.sin(Math.PI * Math.min(1, f * 0.9 + 0.1)));
+      const a = ((100 + 60 * f) * Math.PI) / 180;
+      rays.push([b, [b[0] + Math.cos(a) * L, b[1] + Math.sin(a) * L]]);
+    }
+    sculptFin(m, { ...median, t: 0.01 * SL, round: 0.004 * SL, rays, bone: boneAt(d.u0), tag: 'adipose', name: 'adipose', k: 0.006 * SL });
+  }
+  // caudal fin: rays fan from the hypural plate; fork > 0 shortens the middle rays (forked tail),
+  // fork < 0 lengthens them (rounded tail)
+  {
+    const C = F.caudal;
+    const h1 = G.hd(1), yb = G.yc(1), zb0 = G.z(1.0);
+    const rays = [];
+    for (let i = 0; i < C.n; i++) {
+      const f = i / (C.n - 1);
+      const e = 1 - 2 * f; // +1 upper lobe .. -1 lower lobe
+      const a = Math.PI + (e * C.spread * Math.PI) / 180;
+      const mid = 1 - Math.pow(Math.abs(e), C.lobe === 'pointed' ? 1.3 : 2.2);
+      let L = G.tailLen * SL * (1 - C.fork * mid);
+      if (C.lobe === 'rounded') L *= 1 - 0.1 * Math.pow(Math.abs(e), 4);
+      const b = [zb0 + 0.012 * SL, yb + e * h1 * 0.78];
+      rays.push([b, [b[0] + Math.cos(a) * L, b[1] - Math.sin(a) * L]]);
+    }
+    const bone = 'caudal0';
+    sculptFin(m, { ...median, sink: 0.03 * SL, rays, bone, tag: 'fin', name: 'caudal', k: t * 1.5 });
+  }
+
+  // ---------------------------------------------------------------- paired fins (appendages)
+  for (const S of ['L', 'R']) {
+    const s = S === 'L' ? 1 : -1;
+    // pectoral: plane through the base line (pecBase -> pecUp) and the fin direction
+    {
+      const P = F.pectoral;
+      const b = J['pecBase' + S], upJ = J['pecUp' + S], tip = J['pecTip' + S];
+      const u = norm(sub(tip, b));
+      const vb = sub(upJ, b);
+      const v = norm(sub(vb, mul(u, vb[0] * u[0] + vb[1] * u[1] + vb[2] * u[2])));
+      const bl = 0.036 * SL, L = P.len * G.finK * SL;
+      const shape = P.shape;
+      const rays = fanRays({
+        base0: [-0.004 * SL, bl * 0.55], base1: [0.002 * SL, -bl * 0.45], n: P.n,
+        angle0: shape === 'sickle' ? 12 : 15, angle1: -17,
+        length: (f) => {
+          if (shape === 'pointed') return L * (1.0 - 0.55 * Math.pow(f, 1.2)) * (0.8 + 0.2 * Math.min(1, f * 6));
+          if (shape === 'sickle') return L * (1.0 - 0.78 * Math.pow(f, 0.8)) * (0.7 + 0.3 * Math.min(1, f * 8));
+          return L * (0.72 + 0.3 * Math.sin(Math.PI * Math.min(1, f * 1.05 + 0.12)));
+        },
+      });
+      // the right fin mirrors the left: flip the plane's v so the rays mirror too
+      sculptFin(m, { origin: b, u, v: s > 0 ? v : v, rays, t, sink: 0.006 * SL, bone: 'pectoral' + S, group: 'pectoral' + S, tag: 'fin', name: 'pectoral' + S, k: t * 0.9 });
+    }
+    // pelvic
+    {
+      const Q = F.pelvic;
+      const b = J['pelBase' + S], fr = J['pelFront' + S], tip = J['pelTip' + S];
+      const u = norm(sub(tip, b));
+      const vb = sub(fr, b);
+      const v = norm(sub(vb, mul(u, vb[0] * u[0] + vb[1] * u[1] + vb[2] * u[2])));
+      const bl = 0.026 * SL, L = Q.len * G.finK * SL;
+      const rays = fanRays({
+        base0: [0.002 * SL, bl * 0.5], base1: [-0.002 * SL, -bl * 0.5], n: Q.n, angle0: 18, angle1: -14,
+        length: (f) => L * (1.0 - 0.45 * Math.pow(f, 1.1)) * (0.85 + 0.15 * Math.min(1, f * 5)),
+      });
+      sculptFin(m, { origin: b, u, v, rays, t, sink: 0.006 * SL, bone: 'pelvic' + S, group: 'pelvic' + S, tag: 'fin', name: 'pelvic' + S, k: t * 0.9 });
+    }
+  }
+  void spineName; void lerp; void add; void N;
+  return m;
+}
+
+// grows / shrinks a polygon outward by d (approximate: along the averaged edge normals)
+function offsetPoly(poly, d) {
+  const n = poly.length;
+  let area = 0;
+  for (let i = 0; i < n; i++) { const a = poly[i], b = poly[(i + 1) % n]; area += a[0] * b[1] - b[0] * a[1]; }
+  const sgn = area > 0 ? 1 : -1;
+  return poly.map((p, i) => {
+    const a = poly[(i + n - 1) % n], b = poly[(i + 1) % n];
+    const e1 = norm([p[0] - a[0], p[1] - a[1], 0]), e2 = norm([b[0] - p[0], b[1] - p[1], 0]);
+    const n1 = [e1[1] * sgn, -e1[0] * sgn], n2 = [e2[1] * sgn, -e2[0] * sgn];
+    const nn = norm([n1[0] + n2[0], n1[1] + n2[1], 0]);
+    return [p[0] + nn[0] * d, p[1] + nn[1] * d];
+  });
+}

package/vendor/procedural-animals/src/species/fish/variants.js

@@ -0,0 +1,126 @@
+// Fish variants: four teleost body plans in one species module.
+//
+// Every length is a fraction of the standard length SL (snout tip -> caudal base). `prof` rows are
+// [u (fraction of SL from the snout), top (dorsal outline above the axis), bot (ventral outline below
+// the axis), hw (half width)]. Fins are given by their base (u range on the outline) and ray
+// lengths / angles in the median plane (u forward, v up; angle 90 = straight up, 180 = straight back).
+// Colours are sRGB hex sampled from reference photos.
+
+export const VARIANT_KEYS = ['trout', 'goldfish', 'clownfish', 'bluegill'];
+
+export const VARIANTS = {
+  // Rainbow trout (Oncorhynchus mykiss), stream-resident adult: fusiform, small head-scales, spotted.
+  trout: {
+    name: 'Rainbow trout', latin: 'Oncorhynchus mykiss',
+    SL: 0.26, cellK: 1.0,
+    prof: [
+      [0.012, 0.016, 0.012, 0.012], [0.03, 0.028, 0.022, 0.022], [0.06, 0.0497, 0.0432, 0.034], [0.1, 0.0691, 0.0648, 0.045],
+      [0.16, 0.0886, 0.0842, 0.055], [0.23, 0.1048, 0.1004, 0.062], [0.32, 0.1188, 0.1145, 0.066], [0.42, 0.1264, 0.1188, 0.066],
+      [0.52, 0.121, 0.1112, 0.061], [0.62, 0.1058, 0.095, 0.053], [0.72, 0.0864, 0.0756, 0.042], [0.82, 0.068, 0.0594, 0.031],
+      [0.9, 0.0572, 0.0508, 0.023], [0.96, 0.054, 0.0497, 0.018], [1.0, 0.0562, 0.054, 0.015],
+    ],
+    head: { op: 0.235, occ: 0.19, eye: { u: 0.072, h: 0.03, r: 0.022 }, mouth: { h: -0.012, gape: 0.105, jawDepth: 0.03, upturn: 0 }, snout: 0.5 },
+    fins: {
+      dorsal: [{ u0: 0.42, u1: 0.565, n: 12, a0: 118, a1: 150, len: [0.135, 0.05], notch: 0 }],
+      adipose: { u0: 0.79, u1: 0.845, h: 0.03 },
+      anal: [{ u0: 0.675, u1: 0.79, n: 10, a0: 238, a1: 208, len: [0.11, 0.045] }],
+      caudal: { len: 0.23, fork: 0.18, spread: 37, n: 19, lobe: 'pointed' },
+      pectoral: { u: 0.245, h: -0.07, len: 0.13, n: 12, sweep: 38, droop: 22, abduct: 28, shape: 'pointed', parentU: 0.25 },
+      pelvic: { u: 0.5, len: 0.105, n: 9, sweep: 22, abduct: 25 },
+    },
+    spineSegs: 12, caudalSegs: 3,
+    scale: 0.004, gloss: 0.8, irid: 0.45,
+    colour: {
+      back: 0x56604a, upper: 0x80846a, band: 0xb66f78, lower: 0xc2c6be, belly: 0xe9e9e2, spot: 0x1d1d19,
+      fin: 0x5e5c42, finEdge: 0xe8e6dc, head: 0x6f7456, cheek: 0xc97884, gill: 0x7a1c22,
+    },
+    eye: { iris: [0x3a3522, 0xb7a76e, 0xd8cc98, 0x2a2618] },
+  },
+
+  // Common goldfish (Carassius auratus): deep, round-backed cyprinid, big reflective scales, long dorsal.
+  goldfish: {
+    name: 'Goldfish', latin: 'Carassius auratus',
+    SL: 0.125, cellK: 1.33,
+    prof: [
+      [0.012, 0.024, 0.016, 0.016], [0.035, 0.05, 0.036, 0.034], [0.07, 0.084, 0.064, 0.056], [0.11, 0.113, 0.093, 0.074],
+      [0.17, 0.145, 0.123, 0.088], [0.24, 0.172, 0.15, 0.097], [0.33, 0.194, 0.172, 0.101], [0.43, 0.2, 0.176, 0.097],
+      [0.53, 0.19, 0.162, 0.09], [0.63, 0.166, 0.138, 0.078], [0.73, 0.133, 0.109, 0.062], [0.82, 0.102, 0.086, 0.046],
+      [0.9, 0.08, 0.071, 0.034], [0.96, 0.071, 0.066, 0.028], [1.0, 0.073, 0.069, 0.024],
+    ],
+    head: { op: 0.275, occ: 0.22, eye: { u: 0.105, h: 0.046, r: 0.036 }, mouth: { h: -0.008, gape: 0.036, jawDepth: 0.026, upturn: 0.3 }, snout: 0.8 },
+    fins: {
+      dorsal: [{ u0: 0.42, u1: 0.77, n: 16, a0: 108, a1: 150, len: [0.22, 0.075], firstSpine: true }],
+      anal: [{ u0: 0.72, u1: 0.815, n: 7, a0: 238, a1: 214, len: [0.22, 0.12] }],
+      caudal: { len: 0.36, fork: 0.45, spread: 38, n: 19, lobe: 'rounded' },
+      pectoral: { u: 0.29, h: -0.13, len: 0.23, n: 14, sweep: 40, droop: 26, abduct: 32, shape: 'rounded' },
+      pelvic: { u: 0.48, len: 0.23, n: 9, sweep: 26, abduct: 28 },
+    },
+    spineSegs: 12, caudalSegs: 3,
+    scale: 0.052, gloss: 0.6, irid: 0.3, scaleEdge: 0.075, scaleFade: 0.03,
+    colour: {
+      back: 0xe0691a, upper: 0xee8a1e, band: 0xef8e22, lower: 0xf29a30, belly: 0xf6b25a, spot: 0xf4f1ea,
+      fin: 0xf5a04a, finEdge: 0xf6b872, head: 0xee8a1e, cheek: 0xf09a34, gill: 0x8a2020,
+    },
+    eye: { iris: [0x3b2a0c, 0xa8781f, 0xd8ae52, 0x2c1e08] },
+  },
+
+  // Ocellaris clownfish (Amphiprion ocellaris): short oval body, rounded fins, three white bands.
+  clownfish: {
+    name: 'Clownfish', latin: 'Amphiprion ocellaris',
+    SL: 0.068, cellK: 1.45,
+    prof: [
+      [0.012, 0.03, 0.022, 0.018], [0.035, 0.066, 0.05, 0.04], [0.07, 0.106, 0.084, 0.06], [0.12, 0.145, 0.12, 0.08],
+      [0.2, 0.183, 0.16, 0.097], [0.3, 0.206, 0.188, 0.103], [0.4, 0.21, 0.198, 0.1], [0.5, 0.2, 0.19, 0.094],
+      [0.6, 0.18, 0.17, 0.084], [0.7, 0.152, 0.142, 0.07], [0.8, 0.118, 0.112, 0.055], [0.9, 0.092, 0.087, 0.04],
+      [0.96, 0.083, 0.08, 0.033], [1.0, 0.085, 0.082, 0.029],
+    ],
+    head: { op: 0.315, occ: 0.26, eye: { u: 0.12, h: 0.055, r: 0.046 }, mouth: { h: -0.02, gape: 0.055, jawDepth: 0.04, upturn: 0.2 }, snout: 0.9 },
+    fins: {
+      dorsal: [
+        { u0: 0.3, u1: 0.55, n: 10, a0: 100, a1: 128, len: [0.1, 0.085], notch: 0.15, spiny: true },
+        { u0: 0.55, u1: 0.88, n: 15, a0: 112, a1: 158, len: [0.16, 0.1], round: true },
+      ],
+      anal: [{ u0: 0.62, u1: 0.85, n: 12, a0: 250, a1: 205, len: [0.15, 0.1], round: true }],
+      caudal: { len: 0.24, fork: -0.08, spread: 36, n: 17, lobe: 'rounded' },
+      pectoral: { u: 0.33, h: -0.035, len: 0.21, n: 14, sweep: 30, droop: 10, abduct: 35, shape: 'rounded' },
+      pelvic: { u: 0.38, len: 0.17, n: 6, sweep: 30, abduct: 30 },
+    },
+    spineSegs: 12, caudalSegs: 2,
+    scale: 0.004, gloss: 0.65, irid: 0.02,
+    colour: {
+      back: 0xe85a14, upper: 0xf26b1d, band: 0xf26b1d, lower: 0xf47a28, belly: 0xf58a38, spot: 0xf7f7f2,
+      fin: 0xf07a25, finEdge: 0x111111, head: 0xf26b1d, cheek: 0xf57d30, gill: 0x7a1c1c,
+    },
+    eye: { iris: [0x2a1004, 0xc2561a, 0xea8a3c, 0x0c0604] },
+  },
+
+  // Bluegill (Lepomis macrochirus): deep, strongly compressed disc, dark ear flap, vertical bars.
+  bluegill: {
+    name: 'Bluegill', latin: 'Lepomis macrochirus',
+    SL: 0.155, cellK: 1.38,
+    prof: [
+      [0.012, 0.03, 0.022, 0.014], [0.035, 0.072, 0.052, 0.028], [0.07, 0.12, 0.09, 0.043], [0.12, 0.168, 0.138, 0.06],
+      [0.2, 0.218, 0.196, 0.075], [0.3, 0.254, 0.228, 0.083], [0.4, 0.262, 0.238, 0.083], [0.5, 0.25, 0.224, 0.078],
+      [0.6, 0.222, 0.196, 0.07], [0.7, 0.178, 0.156, 0.058], [0.8, 0.124, 0.11, 0.044], [0.88, 0.087, 0.078, 0.033],
+      [0.95, 0.07, 0.065, 0.026], [1.0, 0.07, 0.067, 0.022],
+    ],
+    head: { op: 0.315, occ: 0.25, eye: { u: 0.118, h: 0.065, r: 0.042 }, mouth: { h: -0.01, gape: 0.05, jawDepth: 0.035, upturn: 0.25 }, snout: 0.85, earFlap: 0.055 },
+    fins: {
+      dorsal: [
+        { u0: 0.36, u1: 0.6, n: 10, a0: 104, a1: 125, len: [0.13, 0.12], notch: 0.25, spiny: true },
+        { u0: 0.6, u1: 0.88, n: 12, a0: 112, a1: 160, len: [0.18, 0.1], round: true },
+      ],
+      anal: [{ u0: 0.6, u1: 0.87, n: 13, a0: 252, a1: 205, len: [0.15, 0.1], round: true }],
+      caudal: { len: 0.23, fork: 0.1, spread: 36, n: 17, lobe: 'rounded' },
+      pectoral: { u: 0.33, h: -0.03, len: 0.28, n: 13, sweep: 25, droop: -12, abduct: 30, shape: 'sickle' },
+      pelvic: { u: 0.36, len: 0.15, n: 6, sweep: 30, abduct: 30, spine: true },
+    },
+    spineSegs: 12, caudalSegs: 3,
+    scale: 0.007, gloss: 0.55, irid: 0.1,
+    colour: {
+      back: 0x4a5236, upper: 0x6e7250, band: 0x76784e, lower: 0x9a8a50, belly: 0xd8b050, spot: 0x33362a,
+      fin: 0x55543c, finEdge: 0x4c4a36, head: 0x666a48, cheek: 0x4a5aa0, gill: 0x6e1c1c, ear: 0x0f0f12, breast: 0xd9722a,
+    },
+    eye: { iris: [0x1c0a06, 0x5e2418, 0x8a3c26, 0x120604] },
+  },
+};