Spaces:
Running
Running
| // engine/anim/skeleton-pose.js - written by Muse Glimmer (Phase 31, part B, 27 Sep 2026; raw output in game/muse-authored/phase31/raw/), | |
| // reviewed by Grok Bot (coach) with game/muse-authored/phase31/harness/. Coach fixes are marked [coach fix P31-n], see FIXES-P31.md. | |
| window.MuseSkeletonPose = (function () { | |
| function createPose(N) { | |
| var t = new Float32Array(3 * N); | |
| var r = new Float32Array(4 * N); | |
| var s = new Float32Array(3 * N); | |
| for (var i = 0; i < N; i++) { | |
| r[4 * i + 3] = 1; | |
| s[3 * i] = 1; | |
| s[3 * i + 1] = 1; | |
| s[3 * i + 2] = 1; | |
| } | |
| return { t: t, r: r, s: s }; | |
| } | |
| function restPose(skeleton, out) { | |
| var n = skeleton.nodes; | |
| var N = n.length; | |
| var t = out.t, | |
| r = out.r, | |
| s = out.s; | |
| for (var i = 0; i < N; i++) { | |
| var nd = n[i]; | |
| t[3 * i] = nd.t[0]; | |
| t[3 * i + 1] = nd.t[1]; | |
| t[3 * i + 2] = nd.t[2]; | |
| r[4 * i] = nd.r[0]; | |
| r[4 * i + 1] = nd.r[1]; | |
| r[4 * i + 2] = nd.r[2]; | |
| r[4 * i + 3] = nd.r[3]; | |
| s[3 * i] = nd.s[0]; | |
| s[3 * i + 1] = nd.s[1]; | |
| s[3 * i + 2] = nd.s[2]; | |
| } | |
| } | |
| function lerp(a, b, u) { | |
| return a + (b - a) * u; | |
| } | |
| function slerp(qa, qb, u) { | |
| var x1 = qa[0], | |
| y1 = qa[1], | |
| z1 = qa[2], | |
| w1 = qa[3]; | |
| var x2 = qb[0], | |
| y2 = qb[1], | |
| z2 = qb[2], | |
| w2 = qb[3]; | |
| var dot = x1 * x2 + y1 * y2 + z1 * z2 + w1 * w2; | |
| if (dot < 0) { | |
| x2 = -x2; | |
| y2 = -y2; | |
| z2 = -z2; | |
| w2 = -w2; | |
| dot = -dot; | |
| } | |
| if (dot > 0.9995) { | |
| var ix = x1 + (x2 - x1) * u, | |
| iy = y1 + (y2 - y1) * u, | |
| iz = z1 + (z2 - z1) * u, | |
| iw = w1 + (w2 - w1) * u; | |
| var len = Math.sqrt(ix * ix + iy * iy + iz * iz + iw * iw) || 1; | |
| return [ix / len, iy / len, iz / len, iw / len]; | |
| } | |
| var theta = Math.acos(Math.min(1, Math.max(-1, dot))); | |
| var sinTheta = Math.sin(theta); | |
| var s0 = Math.sin((1 - u) * theta) / sinTheta; | |
| var s1 = Math.sin(u * theta) / sinTheta; | |
| return [x1 * s0 + x2 * s1, y1 * s0 + y2 * s1, z1 * s0 + z2 * s1, w1 * s0 + w2 * s1]; | |
| } | |
| function binarySearch(times, t) { | |
| var lo = 0, | |
| hi = times.length - 1; | |
| while (lo <= hi) { | |
| var mid = (lo + hi) >> 1; | |
| if (times[mid] <= t) lo = mid + 1; | |
| else hi = mid - 1; | |
| } | |
| return hi; | |
| } | |
| function sampleClip(skeleton, clip, time, loop, out) { | |
| restPose(skeleton, out); | |
| var dur = clip.duration; | |
| if (loop) { | |
| time = ((time % dur) + dur) % dur; | |
| } else { | |
| if (time < 0) time = 0; | |
| if (time > dur) time = dur; | |
| } | |
| var N = skeleton.nodes.length; | |
| var t = out.t, | |
| r = out.r, | |
| s = out.s; | |
| for (var i = 0; i < clip.tracks.length; i++) { | |
| var tr = clip.tracks[i]; | |
| var node = tr.node; | |
| if (node < 0 || node >= N) continue; | |
| var times = tr.times; | |
| var vals = tr.values; | |
| var path = tr.path; | |
| var interp = tr.interp; | |
| var stride = path === "rotation" ? 4 : 3; | |
| var k = times.length; | |
| if (k === 0) continue; | |
| var idx = binarySearch(times, time); | |
| if (idx < 0) { | |
| idx = 0; | |
| } | |
| if (idx >= k - 1) { | |
| idx = k - 1; | |
| } | |
| var t0 = times[idx]; | |
| var t1 = times[Math.min(idx + 1, k - 1)]; | |
| var u = 0; | |
| if (t1 > t0) u = (time - t0) / (t1 - t0); | |
| if (u < 0) u = 0; // [coach fix P31-7] before the first key use the first key (was: extrapolated from keys 0-1) | |
| if (u > 1) u = 1; | |
| var base = idx * stride; | |
| var base1 = Math.min(idx + 1, k - 1) * stride; | |
| var off = 3 * node; | |
| if (path === "translation") { | |
| if (interp === "STEP") { | |
| t[off] = vals[base]; | |
| t[off + 1] = vals[base + 1]; | |
| t[off + 2] = vals[base + 2]; | |
| } else { | |
| t[off] = lerp(vals[base], vals[base1], u); | |
| t[off + 1] = lerp(vals[base + 1], vals[base1 + 1], u); | |
| t[off + 2] = lerp(vals[base + 2], vals[base1 + 2], u); | |
| } | |
| } else if (path === "scale") { | |
| if (interp === "STEP") { | |
| s[off] = vals[base]; | |
| s[off + 1] = vals[base + 1]; | |
| s[off + 2] = vals[base + 2]; | |
| } else { | |
| s[off] = lerp(vals[base], vals[base1], u); | |
| s[off + 1] = lerp(vals[base + 1], vals[base1 + 1], u); | |
| s[off + 2] = lerp(vals[base + 2], vals[base1 + 2], u); | |
| } | |
| } else { | |
| var qa = [vals[base], vals[base + 1], vals[base + 2], vals[base + 3]]; | |
| var qb = [vals[base1], vals[base1 + 1], vals[base1 + 2], vals[base1 + 3]]; | |
| if (interp === "STEP") { | |
| r[4 * node] = qa[0]; | |
| r[4 * node + 1] = qa[1]; | |
| r[4 * node + 2] = qa[2]; | |
| r[4 * node + 3] = qa[3]; | |
| } else { | |
| var q = slerp(qa, qb, u); | |
| r[4 * node] = q[0]; | |
| r[4 * node + 1] = q[1]; | |
| r[4 * node + 2] = q[2]; | |
| r[4 * node + 3] = q[3]; | |
| } | |
| } | |
| } | |
| } | |
| function blendPoses(a, b, w, out) { | |
| var N = a.t.length / 3; | |
| var ta = a.t, | |
| tb = b.t, | |
| oa = out.t; | |
| var sa = a.s, | |
| sb = b.s, | |
| os = out.s; | |
| var ra = a.r, | |
| rb = b.r, | |
| or = out.r; | |
| var iw = 1 - w; | |
| for (var i = 0; i < N; i++) { | |
| var i3 = i * 3, | |
| i4 = i * 4; | |
| oa[i3] = ta[i3] * iw + tb[i3] * w; | |
| oa[i3 + 1] = ta[i3 + 1] * iw + tb[i3 + 1] * w; | |
| oa[i3 + 2] = ta[i3 + 2] * iw + tb[i3 + 2] * w; | |
| os[i3] = sa[i3] * iw + sb[i3] * w; | |
| os[i3 + 1] = sa[i3 + 1] * iw + sb[i3 + 1] * w; | |
| os[i3 + 2] = sa[i3 + 2] * iw + sb[i3 + 2] * w; | |
| var qa = [ra[i4], ra[i4 + 1], ra[i4 + 2], ra[i4 + 3]]; | |
| var qb = [rb[i4], rb[i4 + 1], rb[i4 + 2], rb[i4 + 3]]; | |
| var q = slerp(qa, qb, w); | |
| or[i4] = q[0]; | |
| or[i4 + 1] = q[1]; | |
| or[i4 + 2] = q[2]; | |
| or[i4 + 3] = q[3]; | |
| } | |
| } | |
| function quatToMat3(q, s) { | |
| var x = q[0], | |
| y = q[1], | |
| z = q[2], | |
| w = q[3]; | |
| var xx = x * x, | |
| yy = y * y, | |
| zz = z * z; | |
| var xy = x * y, | |
| xz = x * z, | |
| yz = y * z; | |
| var wx = w * x, | |
| wy = w * y, | |
| wz = w * z; | |
| var sx = s[0], | |
| sy = s[1], | |
| sz = s[2]; | |
| return [ | |
| (1 - 2 * (yy + zz)) * sx, | |
| 2 * (xy - wz) * sy, | |
| 2 * (xz + wy) * sz, | |
| 2 * (xy + wz) * sx, | |
| (1 - 2 * (xx + zz)) * sy, | |
| 2 * (yz - wx) * sz, | |
| 2 * (xz - wy) * sx, | |
| 2 * (yz + wx) * sy, | |
| (1 - 2 * (xx + yy)) * sz, | |
| ]; | |
| } | |
| var _m = new Float32Array(16), _res = new Float32Array(16); // [coach fix P31-8] scratch (was 2 new Float32Array per node per frame) | |
| function worldMatrices(skeleton, pose, rootMatrix, out) { | |
| var N = skeleton.nodes.length; | |
| var nodes = skeleton.nodes; | |
| var t = pose.t, | |
| r = pose.r, | |
| s = pose.s; | |
| for (var i = 0; i < N; i++) { | |
| var parent = nodes[i].parent; | |
| var m = _m; | |
| var ti = t[3 * i], | |
| tj = t[3 * i + 1], | |
| tk = t[3 * i + 2]; | |
| var si = s[3 * i], | |
| sj = s[3 * i + 1], | |
| sk = s[3 * i + 2]; | |
| var q = [r[4 * i], r[4 * i + 1], r[4 * i + 2], r[4 * i + 3]]; | |
| var m3 = quatToMat3(q, [si, sj, sk]); | |
| m[0] = m3[0]; | |
| m[1] = m3[3]; | |
| m[2] = m3[6]; | |
| m[3] = 0; | |
| m[4] = m3[1]; | |
| m[5] = m3[4]; | |
| m[6] = m3[7]; | |
| m[7] = 0; | |
| m[8] = m3[2]; | |
| m[9] = m3[5]; | |
| m[10] = m3[8]; | |
| m[11] = 0; | |
| m[12] = ti; | |
| m[13] = tj; | |
| m[14] = tk; | |
| m[15] = 1; | |
| if (parent === -1) { | |
| var rm = rootMatrix; | |
| var res = _res; | |
| for (var row = 0; row < 4; row++) | |
| for (var col = 0; col < 4; col++) { | |
| var sum = 0; | |
| for (var k = 0; k < 4; k++) sum += rm[k * 4 + row] * m[col * 4 + k]; | |
| res[col * 4 + row] = sum; | |
| } | |
| out.set(res, i * 16); | |
| } else { | |
| var p = out.subarray(parent * 16, parent * 16 + 16); | |
| var res = _res; | |
| for (var row = 0; row < 4; row++) | |
| for (var col = 0; col < 4; col++) { | |
| var sum = 0; | |
| for (var k = 0; k < 4; k++) sum += p[k * 4 + row] * m[col * 4 + k]; | |
| res[col * 4 + row] = sum; | |
| } | |
| out.set(res, i * 16); | |
| } | |
| } | |
| } | |
| function skinPalette(world, boneNodes, inverseBind, bindShape, out) { | |
| var J = boneNodes.length; | |
| var tmp = new Float32Array(16); | |
| for (var j = 0; j < J; j++) { | |
| var node = boneNodes[j]; | |
| var w = world.subarray(node * 16, node * 16 + 16); | |
| var ib = inverseBind.subarray(j * 16, j * 16 + 16); | |
| for (var row = 0; row < 4; row++) { | |
| for (var col = 0; col < 4; col++) { | |
| var sum = 0; | |
| for (var k = 0; k < 4; k++) sum += w[k * 4 + row] * ib[col * 4 + k]; | |
| tmp[col * 4 + row] = sum; | |
| } | |
| } | |
| var off = 12 * j; | |
| out[off] = tmp[0]; | |
| out[off + 1] = tmp[4]; | |
| out[off + 2] = tmp[8]; | |
| out[off + 3] = tmp[12]; | |
| out[off + 4] = tmp[1]; | |
| out[off + 5] = tmp[5]; | |
| out[off + 6] = tmp[9]; | |
| out[off + 7] = tmp[13]; | |
| out[off + 8] = tmp[2]; | |
| out[off + 9] = tmp[6]; | |
| out[off + 10] = tmp[10]; | |
| out[off + 11] = tmp[14]; | |
| } | |
| } | |
| // [coach fix P31-9] Fader rewritten around Muse's two-layer design. Muse's version: (a) at the end of a fade did | |
| // `cur = nxt; nxt.idx = -1`, aliasing both layers so the character froze after every crossfade; (b) play() with the | |
| // clip already playing started a fade to itself; (c) a new play() during a fade dropped the blended pose (a visible | |
| // pop); (d) state().done read a non-existent field and was never true; (e) allocated two poses per update. | |
| // Now: layer `to` (target) and `from` (a live clip, or a frozen snapshot when a play interrupts a fade). | |
| function Fader(skeleton) { | |
| var N = skeleton.nodes.length; | |
| this.skeleton = skeleton; | |
| this.to = null; // { idx, time, speed, loop, dur } | |
| this.from = null; // { idx, time, speed, loop, dur } or { frozen: true } | |
| this.fadeDur = 0; | |
| this.fadeEl = 0; | |
| this.pa = createPose(N); | |
| this.pb = createPose(N); | |
| this.snap = createPose(N); | |
| this.last = createPose(N); | |
| this.hasLast = false; | |
| } | |
| Fader.prototype.play = function (clipIndex, fadeSeconds, opts) { | |
| opts = opts || {}; | |
| if (this.to && this.to.idx === clipIndex) return; // already the target: keep its time | |
| var layer = { idx: clipIndex, time: 0, speed: opts.speed !== undefined ? opts.speed : 1, loop: opts.loop !== undefined ? opts.loop : true, dur: 0 }; | |
| var fade = fadeSeconds > 0 ? fadeSeconds : 0; | |
| if (fade > 0 && this.to) { | |
| if (this.from && this.fadeEl < this.fadeDur && this.hasLast) { | |
| // interrupting a fade: the current blended result becomes a frozen source | |
| this.snap.t.set(this.last.t); | |
| this.snap.r.set(this.last.r); | |
| this.snap.s.set(this.last.s); | |
| this.from = { frozen: true }; | |
| } else this.from = this.to; | |
| } else this.from = null; | |
| this.to = layer; | |
| this.fadeDur = fade; | |
| this.fadeEl = 0; | |
| }; | |
| function advance(l, clips) { | |
| var c = clips[l.idx]; | |
| l.dur = c.duration; | |
| l.time += l.dt; | |
| if (!l.loop && l.time > c.duration) l.time = c.duration; | |
| } | |
| Fader.prototype.update = function (dt, clips, outPose) { | |
| if (!this.to) { | |
| restPose(this.skeleton, outPose); | |
| return; | |
| } | |
| this.to.dt = dt * this.to.speed; | |
| advance(this.to, clips); | |
| sampleClip(this.skeleton, clips[this.to.idx], this.to.time, this.to.loop, this.pb); | |
| var w = 1; | |
| if (this.from && this.fadeDur > 0) { | |
| this.fadeEl += dt; | |
| w = Math.min(1, this.fadeEl / this.fadeDur); | |
| } | |
| if (this.from && w < 1) { | |
| var src = this.snap; | |
| if (!this.from.frozen) { | |
| this.from.dt = dt * this.from.speed; | |
| advance(this.from, clips); | |
| sampleClip(this.skeleton, clips[this.from.idx], this.from.time, this.from.loop, this.pa); | |
| src = this.pa; | |
| } | |
| blendPoses(src, this.pb, w, outPose); | |
| } else { | |
| this.from = null; | |
| outPose.t.set(this.pb.t); | |
| outPose.r.set(this.pb.r); | |
| outPose.s.set(this.pb.s); | |
| } | |
| this.last.t.set(outPose.t); | |
| this.last.r.set(outPose.r); | |
| this.last.s.set(outPose.s); | |
| this.hasLast = true; | |
| this.w = w; | |
| }; | |
| Fader.prototype.state = function () { | |
| var l = this.to; | |
| return { | |
| clip: l ? l.idx : -1, | |
| time: l ? l.time : 0, | |
| weight: this.from && this.fadeDur > 0 ? Math.min(1, this.fadeEl / this.fadeDur) : 1, | |
| fading: !!(this.from && this.fadeDur > 0 && this.fadeEl < this.fadeDur), | |
| done: !!(l && !l.loop && l.dur > 0 && l.time >= l.dur), | |
| }; | |
| }; | |
| return { | |
| createPose: createPose, | |
| restPose: restPose, | |
| sampleClip: sampleClip, | |
| blendPoses: blendPoses, | |
| worldMatrices: worldMatrices, | |
| skinPalette: skinPalette, | |
| Fader: Fader, | |
| }; | |
| })(); | |