WVY-3D-1M / code /engine /brain.js
StarpowerTechnology's picture
Release WVY-3D-1M v1
7207c65 verified
Raw History Blame Contribute Delete
25.4 kB
// RigLM brain: runs the two trained networks (RigNet v2 + MotionGPT v2) in plain JS,
// plus the scene runtime (paths, ground contact, forward kinematics). No three.js here.
(function (root) {
"use strict";
const S = root.RigSculpt;
const FAMS = ["biped", "quadruped", "bird", "fish", "snake", "insect"];
const NJ = { biped: 17, quadruped: 19, bird: 17, fish: 8, snake: 10, insect: 21 };
const OFF = {}; { let o = 0; for (const f of FAMS) { OFF[f] = [o, o + NJ[f]]; o += NJ[f]; } }
const TOT = 92, K = 256, CLIP = 64, FPS = 15;
const ACTIONS = { biped: ["idle", "walk", "run", "wave", "jump", "dance"], quadruped: ["idle", "walk", "run", "jump", "sit", "eat"], bird: ["idle", "hop", "peck", "fly", "glide"], fish: ["idle", "swim", "dart"], snake: ["idle", "slither"], insect: ["idle", "crawl", "run"] };
const PROMPTS = []; for (const f of FAMS) for (const a of ACTIONS[f]) PROMPTS.push(f + ":" + a);
const VOCAB = K * FAMS.length + PROMPTS.length;
// ------------------------------------------------------------------ weights
function f16(h) { const s = (h & 0x8000) >> 15, e = (h & 0x7C00) >> 10, f = h & 0x03FF; if (e === 0) return (s ? -1 : 1) * Math.pow(2, -14) * (f / 1024); if (e === 31) return f ? NaN : (s ? -1 : 1) * Infinity; return (s ? -1 : 1) * Math.pow(2, e - 15) * (1 + f / 1024); }
function decodeArr(o) {
const bin = typeof atob === "function" ? atob(o.b64) : Buffer.from(o.b64, "base64").toString("binary");
const n = bin.length / 2, out = new Float32Array(n);
for (let i = 0; i < n; i++) out[i] = f16(bin.charCodeAt(2 * i) | (bin.charCodeAt(2 * i + 1) << 8));
out.shape = o.shape; return out;
}
let W = null;
function loadWeights(json) {
W = { rig: {}, gpt: {}, tok: {} };
for (const g of ["rig", "gpt", "tok"]) for (const k in json[g]) W[g][k] = decodeArr(json[g][k]);
W.cfg = json.cfg; return W;
}
// ------------------------------------------------------------------ tiny linear algebra
function linear(X, n, i, Wm, b, o, act) { // X: n x i, Wm: i x o
const Y = new Float32Array(n * o);
for (let r = 0; r < n; r++) {
const yo = r * o, xo = r * i;
for (let c = 0; c < o; c++) Y[yo + c] = b ? b[c] : 0;
for (let k = 0; k < i; k++) { const x = X[xo + k]; if (x === 0) continue; const wo = k * o; for (let c = 0; c < o; c++) Y[yo + c] += x * Wm[wo + c]; }
if (act === "relu") for (let c = 0; c < o; c++) if (Y[yo + c] < 0) Y[yo + c] = 0;
}
return Y;
}
function linearCols(X, n, i, Wm, b, o, c0, c1) { // only output columns [c0,c1)
const w = c1 - c0, Y = new Float32Array(n * w);
for (let r = 0; r < n; r++) {
for (let c = 0; c < w; c++) Y[r * w + c] = b[c0 + c];
for (let k = 0; k < i; k++) { const x = X[r * i + k]; if (x === 0) continue; const wo = k * o + c0; for (let c = 0; c < w; c++) Y[r * w + c] += x * Wm[wo + c]; }
}
return Y;
}
// ------------------------------------------------------------------ RigNet v2
function rigTrunk(P, n, g) {
const R = W.rig;
const f1 = linear(P, n, 3, R.l1w, R.l1b, 64, "relu");
const f2 = linear(f1, n, 64, R.l2w, R.l2b, 128, "relu");
let gl = g;
if (!gl) {
const f3 = linear(f2, n, 128, R.l3w, R.l3b, 256, "relu");
gl = new Float32Array(256).fill(-1e9);
for (let r = 0; r < n; r++) for (let c = 0; c < 256; c++) if (f3[r * 256 + c] > gl[c]) gl[c] = f3[r * 256 + c];
}
const gb = linear(gl, 1, 256, R.gbw, R.gbb, 256);
const ga = linear(f2, n, 128, R.gaw, R.gab, 256);
for (let r = 0; r < n; r++) for (let c = 0; c < 256; c++) { const v = ga[r * 256 + c] + gb[c]; ga[r * 256 + c] = v > 0 ? v : 0; }
const h = linear(ga, n, 256, R.l4w, R.l4b, 128, "relu");
return { g: gl, h };
}
function softmaxRows(A, n, m) { for (let r = 0; r < n; r++) { let mx = -1e9; for (let c = 0; c < m; c++) mx = Math.max(mx, A[r * m + c]); let s = 0; for (let c = 0; c < m; c++) { A[r * m + c] = Math.exp(A[r * m + c] - mx); s += A[r * m + c]; } for (let c = 0; c < m; c++) A[r * m + c] /= s; } return A; }
// Learned rig for a mesh: returns family guess, joints (world), per-vertex weights (sparse top-4)
function learnedRig(verts, faces, seed) {
const rng = S.RNG(seed || 1);
const pts = S.samplePoints({ verts, faces }, 512, rng);
const { c, s } = S.normalizeFrame(pts);
const P = new Float32Array(512 * 3);
pts.forEach((p, i) => { for (let d = 0; d < 3; d++) P[i * 3 + d] = (p[d] - c[d]) / s; });
const R = W.rig;
const { g, h } = rigTrunk(P, 512, null);
const logits = linear(g, 1, 256, R.clsw, R.clsb, 6);
const probs = softmaxRows(Float32Array.from(logits), 1, 6);
let fi = 0; for (let i = 1; i < 6; i++) if (probs[i] > probs[fi]) fi = i;
const fam = FAMS[fi], [a, b] = OFF[fam], nj = b - a;
const att = linearCols(h, 512, 128, R.haw, R.hab, TOT, a, b);
const off = linearCols(h, 512, 128, R.how, R.hob, TOT * 3, a * 3, b * 3);
// softmax over points for each joint
const J = [];
for (let j = 0; j < nj; j++) {
let mx = -1e9; for (let r = 0; r < 512; r++) mx = Math.max(mx, att[r * nj + j]);
let sw = 0; const acc = [0, 0, 0];
for (let r = 0; r < 512; r++) { const w = Math.exp(att[r * nj + j] - mx); sw += w; for (let d = 0; d < 3; d++) acc[d] += w * (P[r * 3 + d] + off[r * nj * 3 + j * 3 + d]); }
J.push(acc.map((v, d) => v / sw * s + c[d]));
}
// skin weights on (a subset of) vertices, then nearest-neighbour fill
const nv = verts.length, step = Math.max(1, Math.floor(nv / 1200));
const sub = []; for (let i = 0; i < nv; i += step) sub.push(i);
const Pv = new Float32Array(sub.length * 3);
sub.forEach((vi, k) => { for (let d = 0; d < 3; d++) Pv[k * 3 + d] = (verts[vi][d] - c[d]) / s; });
const tv = rigTrunk(Pv, sub.length, g);
const sk = softmaxRows(linearCols(tv.h, sub.length, 128, R.hsw, R.hsb, TOT, a, b), sub.length, nj);
const subW = sub.map((_, k) => Array.from(sk.subarray(k * nj, k * nj + nj)));
const Wv = new Array(nv);
if (step === 1) sub.forEach((vi, k) => Wv[vi] = subW[k]);
else {
const cell = s / 40, grid = new Map(), key = (p) => Math.floor(p[0] / cell) + "," + Math.floor(p[1] / cell) + "," + Math.floor(p[2] / cell);
sub.forEach((vi, k) => { const kk = key(verts[vi]); if (!grid.has(kk)) grid.set(kk, []); grid.get(kk).push(k); });
for (let v = 0; v < nv; v++) {
const p = verts[v], cx = Math.floor(p[0] / cell), cy = Math.floor(p[1] / cell), cz = Math.floor(p[2] / cell);
let best = -1, bd = 1e9;
for (let rad = 1; rad < 6 && best < 0; rad++) for (let x = -rad; x <= rad; x++) for (let y = -rad; y <= rad; y++) for (let z = -rad; z <= rad; z++) {
const L = grid.get((cx + x) + "," + (cy + y) + "," + (cz + z)); if (!L) continue;
for (const k of L) { const q = verts[sub[k]], d = (q[0] - p[0]) ** 2 + (q[1] - p[1]) ** 2 + (q[2] - p[2]) ** 2; if (d < bd) { bd = d; best = k; } }
}
Wv[v] = subW[Math.max(0, best)];
}
}
return { family: fam, probs: Array.from(probs), joints: J, weights: Wv.map(w => sparsify(w)) };
}
function sparsify(w, k = 4) {
const idx = w.map((v, i) => [v, i]).sort((x, y) => y[0] - x[0]).slice(0, k).filter(e => e[0] > 0.02);
const s = idx.reduce((a, e) => a + e[0], 0) || 1;
return idx.map(e => [e[1], e[0] / s]);
}
function generatorRig(cr) {
const { s } = S.normalizeFrame(cr.verts);
const Wd = S.gtWeights(cr.family, cr.joints, cr.ext, cr.verts, s);
return { family: cr.family, joints: cr.joints, weights: Wd.map(w => sparsify(w)) };
}
function compareRigs(learned, gen, verts) {
if (learned.family !== gen.family) return { familyOk: false, jointErr: null, skinAgree: null };
const { s } = S.normalizeFrame(verts);
let e = 0; gen.joints.forEach((j, i) => e += S.V.len(S.V.sub(j, learned.joints[i])));
let agree = 0; for (let v = 0; v < verts.length; v++) if (learned.weights[v][0] && gen.weights[v][0] && learned.weights[v][0][0] === gen.weights[v][0][0]) agree++;
return { familyOk: true, jointErr: e / gen.joints.length / s, skinAgree: agree / verts.length };
}
// ------------------------------------------------------------------ MotionGPT v2 (with KV cache)
function gelu(x) { return 0.5 * x * (1 + Math.tanh(0.7978845608 * (x + 0.044715 * x * x * x))); }
function layernorm(x, w, b) { const n = x.length; let m = 0; for (let i = 0; i < n; i++) m += x[i]; m /= n; let v = 0; for (let i = 0; i < n; i++) v += (x[i] - m) ** 2; v /= n; const inv = 1 / Math.sqrt(v + 1e-5); const y = new Float32Array(n); for (let i = 0; i < n; i++) y[i] = (x[i] - m) * inv * w[i] + b[i]; return y; }
class GPTRun {
constructor() { const c = W.cfg.gpt; this.d = c.d; this.h = c.h; this.L = c.layers; this.cache = []; for (let l = 0; l < this.L; l++) this.cache.push({ k: [], v: [] }); this.t = 0; }
step(tok) { // feed one token, return logits for next
const G = W.gpt, d = this.d, H = this.h, dh = d / H, pos = this.t++;
let x = new Float32Array(d); for (let i = 0; i < d; i++) x[i] = G.tok[tok * d + i] + G.pos[pos * d + i];
for (let l = 0; l < this.L; l++) {
const p = "b" + l + "_";
const a = layernorm(x, G[p + "l1w"], G[p + "l1b"]);
const q = linear(a, 1, d, G[p + "qw"], G[p + "qb"], d), k = linear(a, 1, d, G[p + "kw"], G[p + "kb"], d), v = linear(a, 1, d, G[p + "vw"], G[p + "vb"], d);
const C = this.cache[l]; C.k.push(k); C.v.push(v);
const y = new Float32Array(d), T = C.k.length, sc = 1 / Math.sqrt(dh);
for (let hh = 0; hh < H; hh++) {
const att = new Float32Array(T); let mx = -1e9;
for (let t = 0; t < T; t++) { let s = 0; for (let i = 0; i < dh; i++) s += q[hh * dh + i] * C.k[t][hh * dh + i]; att[t] = s * sc; mx = Math.max(mx, att[t]); }
let ss = 0; for (let t = 0; t < T; t++) { att[t] = Math.exp(att[t] - mx); ss += att[t]; }
for (let t = 0; t < T; t++) { const w = att[t] / ss; for (let i = 0; i < dh; i++) y[hh * dh + i] += w * C.v[t][hh * dh + i]; }
}
const o = linear(y, 1, d, G[p + "ow"], G[p + "ob"], d);
for (let i = 0; i < d; i++) x[i] += o[i];
const m = layernorm(x, G[p + "l2w"], G[p + "l2b"]);
const f1 = linear(m, 1, d, G[p + "f1w"], G[p + "f1b"], 4 * d); for (let i = 0; i < 4 * d; i++) f1[i] = gelu(f1[i]);
const f2 = linear(f1, 1, 4 * d, G[p + "f2w"], G[p + "f2b"], d);
for (let i = 0; i < d; i++) x[i] += f2[i];
}
return linear(layernorm(x, G.lnw, G.lnb), 1, d, G.headw, G.headb, VOCAB);
}
}
function sampleTok(logits, lo, hi, rng, temp, topk) {
const c = []; for (let i = lo; i < hi; i++) c.push([logits[i] / temp, i]);
c.sort((a, b) => b[0] - a[0]); const top = c.slice(0, topk); const mx = top[0][0];
let s = 0; const p = top.map(e => { const w = Math.exp(e[0] - mx); s += w; return w; });
let r = rng() * s; for (let i = 0; i < top.length; i++) { r -= p[i]; if (r <= 0) return top[i][1]; } return top[top.length - 1][1];
}
// Write n pose tokens for "family:action" (continues across 64-token windows)
function writeMotion(fam, action, n, rng, opts = {}) {
const pid = K * FAMS.length + PROMPTS.indexOf(fam + ":" + action);
if (pid < K * FAMS.length) throw new Error("unknown prompt " + fam + ":" + action);
const fi = FAMS.indexOf(fam), lo = fi * K, hi = lo + K;
const out = [];
while (out.length < n) {
const run = new GPTRun();
const ctx = out.slice(-31);
let logits = run.step(pid);
for (const t of ctx) logits = run.step(t);
const room = CLIP - 1 - ctx.length;
for (let i = 0; i < room && out.length < n; i++) { const t = sampleTok(logits, lo, hi, rng, opts.temp || 0.8, opts.topk || 8); out.push(t); logits = run.step(t); }
}
return out;
}
function decodeTokens(fam, toks) {
const C = W.tok[fam + "_C"], mu = W.tok[fam + "_mu"], sd = W.tok[fam + "_sd"], D = mu.length;
return toks.map(t => { const f = new Float32Array(D); for (let i = 0; i < D; i++) f[i] = C[(t - FAMS.indexOf(fam) * K) * D + i] * sd[i] + mu[i]; return f; });
}
// 15 fps tokens -> 30 fps smooth frames
function upsample(frames, nj) {
const D = frames[0].length, n = frames.length, m = (n - 1) * 2 + 1, Y = [];
for (let i = 0; i < m; i++) { const t = i / 2, a = Math.floor(t), b = Math.min(n - 1, a + 1), u = t - a; const f = new Float32Array(D); for (let d = 0; d < D; d++) f[d] = frames[a][d] * (1 - u) + frames[b][d] * u; Y.push(f); }
const k = [-4, -3, -2, -1, 0, 1, 2, 3, 4].map(x => Math.exp(-0.5 * (x / 1.6) ** 2)); const ks = k.reduce((a, b) => a + b, 0);
const Z = Y.map((_, i) => { const f = new Float32Array(D); for (let j = -4; j <= 4; j++) { const q = Y[Math.min(m - 1, Math.max(0, i + j))]; for (let d = 0; d < D; d++) f[d] += q[d] * k[j + 4] / ks; } return f; });
for (const f of Z) { f[nj * 3 + 2] *= 0.5; f[nj * 3 + 3] *= 0.5; }
return Z;
}
// ------------------------------------------------------------------ kinematics
function euler(e0, e1, e2) { return S.mm(S.rotY(e1), S.mm(S.rotX(e0), S.rotZ(e2))); }
function dirRot(a, b) {
a = S.V.norm(a); b = S.V.norm(b); const v = [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]], c = S.V.dot(a, b);
if (S.V.len(v) < 1e-8) return [1, 0, 0, 0, 1, 0, 0, 0, 1];
const vx = [0, -v[2], v[1], v[2], 0, -v[0], -v[1], v[0], 0], vx2 = S.mm(vx, vx), f = 1 / (1 + c);
return [1, 0, 0, 0, 1, 0, 0, 0, 1].map((x, i) => x + vx[i] + vx2[i] * f);
}
function corrections(fam, J) {
const par = S.FAMILIES[fam].parent, canon = S.FAMILIES[fam].canon, out = J.map(() => [1, 0, 0, 0, 1, 0, 0, 0, 1]);
for (const k in canon) { const kid = par.indexOf(+k); if (kid >= 0) out[k] = dirRot(S.V.sub(J[kid], J[k]), canon[k]); }
return out;
}
// local rotations (model space, root yaw excluded) + world joint transforms
function pose(fam, J, corr, f) {
const par = S.FAMILIES[fam].parent, n = J.length, L = [], Rw = [], pw = [];
for (let i = 0; i < n; i++) {
L[i] = S.mm(euler(f[i * 3], f[i * 3 + 1], f[i * 3 + 2]), corr[i]);
if (par[i] < 0) { Rw[i] = L[i]; pw[i] = J[i].slice(); }
else { Rw[i] = S.mm(Rw[par[i]], L[i]); pw[i] = S.V.add(pw[par[i]], S.mv(Rw[par[i]], S.V.sub(J[i], J[par[i]]))); }
}
return { L, Rw, pw };
}
// ------------------------------------------------------------------ scene runtime
const SECONDS_DEFAULT = 6;
const MOTION_CACHE = new Map(); // same body plan + action share up to 3 written takes
class Actor {
constructor(spec, cr, rig, idx, rng, world) {
this.spec = spec; this.cr = cr; this.rig = rig; this.idx = idx; this.rng = rng; this.world = world;
this.fam = rig.family; this.J = rig.joints; this.corr = corrections(this.fam, this.J);
this.unit = cr.unit; this.feet = S.FAMILIES[this.fam].feet;
this.ground = this.feet.length ? Math.min(...this.feet.map(i => this.J[i][1])) : 0;
this.pos = spec._start.slice(); this.yaw = spec._yaw; this.name = spec._name;
const plan = (spec.script && spec.script.length ? spec.script : [{ action: ACTIONS[this.fam].includes("walk") ? "walk" : ACTIONS[this.fam][1], seconds: SECONDS_DEFAULT, path: "wander" }]);
this.plan = plan.map(p => Object.assign({}, p, { action: fixAction(this.fam, p.action), seconds: Math.max(1, Math.min(30, p.seconds || SECONDS_DEFAULT)) }));
this.frames = []; this.segOf = [];
const nj = this.J.length;
for (let si = 0; si < this.plan.length; si++) {
const p = this.plan[si];
const nt = Math.ceil(p.seconds * FPS) + 2;
const ck = this.fam + ":" + p.action + ":" + nt + ":" + (spec._variant || 0);
if (!MOTION_CACHE.has(ck)) MOTION_CACHE.set(ck, writeMotion(this.fam, p.action, nt, rng));
const toks = MOTION_CACHE.get(ck);
const fr = upsample(decodeTokens(this.fam, toks), nj).slice(0, Math.round(p.seconds * 30));
// crossfade 12 frames from previous segment
const prev = this.frames.length ? this.frames[this.frames.length - 1] : null;
fr.forEach((f, i) => { if (prev && i < 12) { const u = (i + 1) / 13; for (let d = 0; d < f.length; d++) f[d] = prev[d] * (1 - u) + f[d] * u; } this.frames.push(f); this.segOf.push(si); });
if (si === 0) this.tokens = toks;
}
this.n = this.frames.length;
this.alt = spec.altitude !== undefined ? spec.altitude : (this.fam === "fish" ? world.waterDepth * 0.5 : 0);
this.state = { pos: this.pos.slice(), yaw: this.yaw, wp: null };
}
reset() { this.state = { pos: this.pos.slice(), yaw: this.yaw, wp: null }; }
// advance one 30fps frame at global frame index t; returns transforms
tick(t, actors) {
const nj = this.J.length, fi = t % this.n, f = this.frames[fi], seg = this.plan[this.segOf[fi]], st = this.state;
if (fi === 0 && t > 0 && this.spec.loop === false) { /* hold */ }
let speed = f[nj * 3 + 2] * this.unit * 30; // world units / second
const path = seg.path || "wander", dt = 1 / 30, maxTurn = (this.fam === "bird" ? 1.2 : 2.0) * dt;
let desired = null;
if (path === "stay") speed = 0;
else if (path === "circle") { const c = seg.center || this.spec._center, R = seg.radius || 4; const d = [st.pos[0] - c[0], st.pos[1] - c[1]]; const a = Math.atan2(d[1], d[0]); const tgt = [c[0] + Math.cos(a + 0.35) * R, c[1] + Math.sin(a + 0.35) * R]; desired = Math.atan2(tgt[0] - st.pos[0], tgt[1] - st.pos[1]); }
else if (path === "toward" && seg.target) { const dx = seg.target[0] - st.pos[0], dz = seg.target[1] - st.pos[1]; if (Math.hypot(dx, dz) < 0.6) speed = 0; else desired = Math.atan2(dx, dz); }
else if (path === "follow" || path === "flee") {
const o = actors.find(a => a.name === seg.follow) || actors.find(a => a !== this);
if (o) { const dx = o.state.pos[0] - st.pos[0], dz = o.state.pos[1] - st.pos[1]; desired = Math.atan2(dx, dz) + (path === "flee" ? Math.PI : 0); if (path === "follow" && Math.hypot(dx, dz) < (seg.gap || 1.5)) speed *= 0.2; }
} else { // wander inside the area
const c = this.spec._center, R = this.spec._radius;
if (!st.wp || Math.hypot(st.wp[0] - st.pos[0], st.wp[1] - st.pos[1]) < 1) { const a = this.rng() * 6.283, r = Math.sqrt(this.rng()) * R; st.wp = [c[0] + Math.cos(a) * r, c[1] + Math.sin(a) * r]; }
desired = Math.atan2(st.wp[0] - st.pos[0], st.wp[1] - st.pos[1]);
}
if (desired !== null && speed > 0.01) { let d = desired - st.yaw; while (d > Math.PI) d -= 6.283; while (d < -Math.PI) d += 6.283; st.yaw += Math.max(-maxTurn, Math.min(maxTurn, d)); }
st.yaw += f[nj * 3 + 3];
// keep inside world
const lim = this.world.size * 0.48; st.pos[0] = Math.max(-lim, Math.min(lim, st.pos[0])); st.pos[1] = Math.max(-lim, Math.min(lim, st.pos[1]));
st.pos[0] += Math.sin(st.yaw) * speed * dt; st.pos[1] += Math.cos(st.yaw) * speed * dt;
// soft separation from others
for (const o of actors) if (o !== this && o.fam !== "bird") { const dx = st.pos[0] - o.state.pos[0], dz = st.pos[1] - o.state.pos[1], d = Math.hypot(dx, dz), m = (this.cr.radius + o.cr.radius) * 0.8; if (d > 1e-3 && d < m) { st.pos[0] += dx / d * (m - d) * 0.3; st.pos[1] += dz / d * (m - d) * 0.3; } }
const P = pose(this.fam, this.J, this.corr, f);
let dy = f[nj * 3 + 1] * this.unit;
if (this.feet.length) dy = Math.max(dy, this.ground - Math.min(...this.feet.map(i => P.pw[i][1])));
dy += this.alt;
const sway = f[nj * 3] * this.unit;
return { L: P.L, Rw: P.Rw, pw: P.pw, root: [st.pos[0] + Math.cos(st.yaw) * sway, dy, st.pos[1] - Math.sin(st.yaw) * sway], yaw: st.yaw, action: seg.action };
}
}
function fixAction(fam, a) {
a = (a || "").toLowerCase();
const A = ACTIONS[fam]; if (A.includes(a)) return a;
const alias = { walk: { bird: "hop", fish: "swim", snake: "slither", insect: "crawl" }, run: { bird: "fly", fish: "dart", snake: "slither" }, fly: { biped: "jump", quadruped: "run", fish: "swim", snake: "slither", insect: "run" }, swim: { biped: "walk", quadruped: "walk", bird: "glide", snake: "slither", insect: "crawl" }, crawl: { biped: "walk", quadruped: "walk", bird: "hop", fish: "swim", snake: "slither" }, slither: { biped: "walk", quadruped: "walk", bird: "hop", fish: "swim", insect: "crawl" }, eat: { bird: "peck", biped: "idle", fish: "idle", snake: "idle", insect: "idle" }, sit: { biped: "idle", bird: "idle" }, dance: { quadruped: "jump", bird: "hop", fish: "swim", snake: "slither", insect: "run" }, wave: { quadruped: "idle", bird: "idle" }, jump: { bird: "hop", fish: "dart", snake: "slither", insect: "run" } };
if (alias[a] && alias[a][fam]) return alias[a][fam];
if (["chase", "hunt", "flee", "gallop", "sprint"].includes(a)) return A.includes("run") ? "run" : A[A.length - 1];
if (["stroll", "roam", "wander", "patrol", "graze"].includes(a)) return fam === "quadruped" && a === "graze" ? "eat" : (A.includes("walk") ? "walk" : A[1]);
if (["sleep", "rest", "stand", "look", "watch"].includes(a)) return fam === "quadruped" ? "sit" : "idle";
if (["play", "celebrate", "party"].includes(a)) return A.includes("dance") ? "dance" : A.includes("jump") ? "jump" : A[1];
return A.includes("walk") ? "walk" : A[1];
}
// Lay out a scene script into concrete specs (positions, names) — deterministic per seed
const hashS = (x) => S.hashStr(String(x)) % 100000;
function layout(script, seed) {
const rng = S.RNG(seed || 7), size = Math.max(20, Math.min(120, (script.environment && script.environment.size) || 40));
const objs = [], crs = [];
const area = (a) => ({ c: a && a.x !== undefined ? [a.x, a.z] : [0, 0], r: a && a.r ? a.r : size * 0.4 });
for (const o of script.objects || []) {
const n = Math.min(60, o.count || 1), A = area(o.area);
for (let i = 0; i < n; i++) { const a = rng() * 6.283, r = n === 1 && o.area && !o.area.r ? 0 : Math.sqrt(rng()) * A.r; objs.push({ type: o.type, size: o.size || 1, scale: 0.85 + 0.3 * rng(), color: o.color, colors: o.colors, pos: [A.c[0] + Math.cos(a) * r, A.c[1] + Math.sin(a) * r], yaw: o.yaw !== undefined ? o.yaw : rng() * 6.283, seed: (seed * 31 + (i % 2) * 7 + hashS(o.type)) | 0 }); }
}
let k = 0;
for (const c of script.creatures || []) {
const n = Math.min(30, c.count || 1), A = area(c.area || { r: size * 0.25 });
for (let i = 0; i < n; i++) {
const a = rng() * 6.283, r = Math.sqrt(rng()) * Math.min(A.r, 2 + n);
crs.push(Object.assign({}, c, { _start: [A.c[0] + Math.cos(a) * r, A.c[1] + Math.sin(a) * r], _yaw: c.facing !== undefined ? c.facing : rng() * 6.283, _center: A.c, _radius: A.r, _name: (c.name || c.species || c.family) + (n > 1 ? "#" + (i + 1) : ""), _variant: i % 2, _group: k - i, _seed: (seed * 131 + k * 17) | 0 }));
k++;
}
}
return { size, objs, crs };
}
// Build everything that doesn't need three.js. progress(msg) is called between steps (may be async).
async function buildScene(script, opts = {}) {
const seed = opts.seed || 7, L = layout(script, seed), env = script.environment || {};
MOTION_CACHE.clear();
const world = { size: L.size, waterDepth: env.ground === "water" ? 3 : 0 };
const objects = [], actors = [], stats = [], ocache = new Map(), ccache = new Map();
const yieldUI = opts.yield || (async () => {});
for (const o of L.objs) {
if (!root.RigObjects.OBJECTS[o.type]) continue;
const key = JSON.stringify([o.type, o.size, o.color, o.colors, o.seed]);
if (!ocache.has(key)) { ocache.set(key, root.RigObjects.makeObject({ type: o.type, size: o.size, color: o.color, colors: o.colors, seed: o.seed })); await yieldUI(`sculpting ${o.type}`); }
objects.push(Object.assign({}, ocache.get(key), { pos: o.pos, yaw: o.yaw, scale: o.scale, key }));
}
for (const c of L.crs) {
const sp = c.species && root.RigSpecies.SPECIES[c.species];
const fam = (sp && sp.family) || c.family;
if (!fam || !S.FAMILIES[fam]) continue;
// members of one group share up to 3 sculpted variants (and their rigs)
const key = JSON.stringify([fam, c.species, c.genome, c.colors, c.pattern, c.size, c._variant, c._group]);
if (!ccache.has(key)) {
const cr = S.makeCreature({ family: fam, species: sp ? c.species : undefined, genome: c.genome, colors: c.colors, pattern: c.pattern, size: c.size, seed: (seed * 7 + hashS(key)) | 0 });
let lo = [1e9, 1e9], hi = [-1e9, -1e9]; for (const v of cr.verts) { lo[0] = Math.min(lo[0], v[0]); hi[0] = Math.max(hi[0], v[0]); lo[1] = Math.min(lo[1], v[2]); hi[1] = Math.max(hi[1], v[2]); }
cr.radius = Math.max(hi[0] - lo[0], hi[1] - lo[1]) * 0.5;
await yieldUI(`sculpting ${c._name}`);
const gen = generatorRig(cr);
const learned = learnedRig(cr.verts, cr.faces, c._seed);
ccache.set(key, { cr, gen, learned, cmp: compareRigs(learned, gen, cr.verts) });
await yieldUI(`rigging ${c._name}`);
}
const { cr, gen, learned, cmp } = ccache.get(key);
stats.push(Object.assign({ name: c._name, family: fam, guessed: learned.family, probs: learned.probs }, cmp));
const useLearned = opts.rig !== "generator" && cmp.familyOk;
const rng = S.RNG(c._seed + 5);
const actor = new Actor(c, cr, useLearned ? learned : gen, actors.length, rng, world);
actor.learned = learned; actor.gen = gen; actor.rigSource = useLearned ? "learned" : "generator";
actors.push(actor); await yieldUI(`animating ${c._name}`);
}
return { env, world, objects, actors, stats, length: Math.max(1, ...actors.map(a => a.n)) };
}
root.RigBrain = { GPTRun, FAMS, ACTIONS, PROMPTS, loadWeights, learnedRig, generatorRig, compareRigs, writeMotion, decodeTokens, upsample, pose, corrections, buildScene, layout, fixAction, Actor, get W() { return W; } };
})(typeof globalThis !== "undefined" ? globalThis : this);