reze-engine 0.16.2 → 0.17.0

package/dist/physics/body.js

@@ -17,10 +17,12 @@ export class RigidBodyStore {
         this.linearVelocities = new Float32Array(N * 3);
         this.angularVelocities = new Float32Array(N * 3);
         this.invMass = new Float32Array(N);
-        this.invInertia = new Float32Array(N);
+        this.invInertiaLocal = new Float32Array(N * 3);
+        this.invInertiaWorld = new Float32Array(N * 9);
         this.linearDamping = new Float32Array(N);
         this.angularDamping = new Float32Array(N);
         this.type = new Uint8Array(N);
+        this.aligned = new Uint8Array(N);
         this.boneIndex = new Int32Array(N);
         this.bodyOffsetMatrix = new Float32Array(N * 16);
         this.bodyOffsetInverse = new Float32Array(N * 16);
@@ -46,10 +48,12 @@ export class RigidBodyStore {
             this.orientations[i4 + 3] = q.w;
             const dynamic = rb.type === RigidbodyType.Dynamic && rb.mass > 0;
             this.invMass[i] = dynamic ? 1 / rb.mass : 0;
-            this.invInertia[i] = dynamic ? computeInvInertia(rb) : 0;
+            if (dynamic)
+                computeLocalInvInertia(rb, this.invInertiaLocal, i * 3);
             this.linearDamping[i] = rb.linearDamping;
             this.angularDamping[i] = rb.angularDamping;
             this.type[i] = rb.type;
+            this.aligned[i] = rb.aligned ? 1 : 0;
             this.boneIndex[i] = rb.boneIndex;
             this.friction[i] = rb.friction;
             this.restitution[i] = rb.restitution;
@@ -61,6 +65,52 @@ export class RigidBodyStore {
             this.size[i * 3 + 2] = rb.size.z;
         }
     }
+    // Refresh I⁻¹_world = R·diag(invInertiaLocal)·Rᵀ for every dynamic body.
+    // Called once per substep before constraint setup (orientations are
+    // constant during a solve).
+    updateInvInertiaWorld() {
+        const N = this.count;
+        const ori = this.orientations;
+        const local = this.invInertiaLocal;
+        const W = this.invInertiaWorld;
+        const invMass = this.invMass;
+        for (let i = 0; i < N; i++) {
+            if (invMass[i] <= 0)
+                continue;
+            const i3 = i * 3;
+            const i4 = i * 4;
+            const i9 = i * 9;
+            const qx = ori[i4 + 0], qy = ori[i4 + 1], qz = ori[i4 + 2], qw = ori[i4 + 3];
+            const x2 = qx + qx, y2 = qy + qy, z2 = qz + qz;
+            const xx = qx * x2, yy = qy * y2, zz = qz * z2;
+            const xy = qx * y2, xz = qx * z2, yz = qy * z2;
+            const wx = qw * x2, wy = qw * y2, wz = qw * z2;
+            // R columns (column-major rotation matrix)
+            const r00 = 1 - (yy + zz), r01 = xy - wz, r02 = xz + wy;
+            const r10 = xy + wz, r11 = 1 - (xx + zz), r12 = yz - wx;
+            const r20 = xz - wy, r21 = yz + wx, r22 = 1 - (xx + yy);
+            const d0 = local[i3 + 0], d1 = local[i3 + 1], d2 = local[i3 + 2];
+            // W = R·diag·Rᵀ (symmetric)
+            const a0 = r00 * d0, a1 = r01 * d1, a2 = r02 * d2;
+            const b0 = r10 * d0, b1 = r11 * d1, b2 = r12 * d2;
+            const c0 = r20 * d0, c1 = r21 * d1, c2 = r22 * d2;
+            const w00 = a0 * r00 + a1 * r01 + a2 * r02;
+            const w01 = a0 * r10 + a1 * r11 + a2 * r12;
+            const w02 = a0 * r20 + a1 * r21 + a2 * r22;
+            const w11 = b0 * r10 + b1 * r11 + b2 * r12;
+            const w12 = b0 * r20 + b1 * r21 + b2 * r22;
+            const w22 = c0 * r20 + c1 * r21 + c2 * r22;
+            W[i9 + 0] = w00;
+            W[i9 + 1] = w01;
+            W[i9 + 2] = w02;
+            W[i9 + 3] = w01;
+            W[i9 + 4] = w11;
+            W[i9 + 5] = w12;
+            W[i9 + 6] = w02;
+            W[i9 + 7] = w12;
+            W[i9 + 8] = w22;
+        }
+    }
     // World-space AABBs for every body. Inflated by margin so contacts stay
     // paired across small velocity jitter without recomputing per iteration.
     updateAabbs(margin = 0.5) {
@@ -193,37 +243,53 @@ export class RigidBodyStore {
 const _scratchA = new Float32Array(16);
 const _scratchB = new Float32Array(16);
 const _scratchC = new Float32Array(16);
-// Scalar isotropic inverse inertia. Returns 0 for static bodies (mass = 0).
-//   Sphere:  I = (2/5)·m·r²
-//   Box:     I = (1/3)·m·max(a,b,c)²
-//   Capsule: I = (1/12)·m·(3r² + h²)  (cylinder transverse axis)
-function computeInvInertia(rb) {
+// Diagonal local inverse inertia, matching Bullet's calculateLocalInertia
+// per shape (so behavior tracks Ammo-based MMD engines):
+//   Sphere:  I = (2/5)·m·r² on every axis
+//   Box:     Ix = m/12·(ly²+lz²), … with l = full extents (2·half)
+//   Capsule: Bullet's bounding-box approximation of the Y-axis capsule
+//            (lx = lz = 2r, ly = h + 2r)
+function computeLocalInvInertia(rb, out, o) {
     const m = rb.mass;
     if (m <= 0)
-        return 0;
-    let I;
+        return;
+    let Ix, Iy, Iz;
     switch (rb.shape) {
         case RigidbodyShape.Sphere: {
-            const r = rb.size.x;
-            I = 0.4 * m * r * r;
+            const I = 0.4 * m * rb.size.x * rb.size.x;
+            Ix = I;
+            Iy = I;
+            Iz = I;
             break;
         }
         case RigidbodyShape.Box: {
-            // Largest half-extent so the long axis isn't under-rotated.
-            const a = Math.max(rb.size.x, rb.size.y, rb.size.z);
-            I = (1 / 3) * m * a * a;
+            const lx2 = 4 * rb.size.x * rb.size.x;
+            const ly2 = 4 * rb.size.y * rb.size.y;
+            const lz2 = 4 * rb.size.z * rb.size.z;
+            Ix = (m / 12) * (ly2 + lz2);
+            Iy = (m / 12) * (lx2 + lz2);
+            Iz = (m / 12) * (lx2 + ly2);
             break;
         }
         case RigidbodyShape.Capsule: {
-            const r = rb.size.x;
-            const h = rb.size.y;
-            I = (1 / 12) * m * (3 * r * r + h * h);
+            const lx = 2 * rb.size.x;
+            const ly = rb.size.y + 2 * rb.size.x;
+            const lx2 = lx * lx;
+            const ly2 = ly * ly;
+            Ix = (m / 12) * (ly2 + lx2);
+            Iy = (m / 12) * (lx2 + lx2);
+            Iz = (m / 12) * (lx2 + ly2);
             break;
         }
-        default:
-            I = m;
+        default: {
+            Ix = m;
+            Iy = m;
+            Iz = m;
+        }
     }
-    return I > 0 ? 1 / I : 0;
+    out[o + 0] = Ix > 0 ? 1 / Ix : 0;
+    out[o + 1] = Iy > 0 ? 1 / Iy : 0;
+    out[o + 2] = Iz > 0 ? 1 / Iz : 0;
 }
 function identity16(out, offset) {
     out[offset + 0] = 1;

package/dist/physics/constraint.d.ts

@@ -11,6 +11,7 @@ export interface SixDofSpringConstraint {
     springEnabled: Uint8Array;
     springStiffness: Float32Array;
     equilibriumPoint: Float32Array;
+    isLoop: boolean;
     cacheSkip: boolean;
     cacheLeverA: Float32Array;
     cacheLeverB: Float32Array;
@@ -22,16 +23,28 @@ export interface SixDofSpringConstraint {
     cacheLinActive: Uint8Array;
     cacheLinLimitImp: Float32Array;
     cacheLinSpringTarget: Float32Array;
+    cacheLinSpringMaxImp: Float32Array;
+    cacheLinSpringImp: Float32Array;
     cacheLinSpringActive: Uint8Array;
     cacheAngAxes: Float32Array;
     cacheAngTargetVel: Float32Array;
     cacheAngActive: Uint8Array;
-    cacheAngJacInv: number;
+    cacheAngJacInv: Float32Array;
+    cacheAngSpringMaxImp: Float32Array;
+    cacheAngSpringImp: Float32Array;
+    cacheAngWA: Float32Array;
+    cacheAngWB: Float32Array;
     cacheAngLimAxis: Float32Array;
+    cacheAngLimWA: Float32Array;
+    cacheAngLimWB: Float32Array;
+    cacheAngLimJacInv: number;
     cacheAngLimTarget: number;
     cacheAngLimActive: number;
     cacheAngLimImp: number;
+    cacheAngPATarget: Float32Array;
+    cacheAngPAActive: Uint8Array;
+    cacheAngPAImp: Float32Array;
 }
-export declare const STOP_ERP = 0.475;
+export declare const STOP_ERP = 0.45;
 export declare function buildConstraints(rigidbodies: Rigidbody[], joints: Joint[]): SixDofSpringConstraint[];
 //# sourceMappingURL=constraint.d.ts.map

package/dist/physics/constraint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constraint.d.ts","sourceRoot":"","sources":["../../src/physics/constraint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAW/C,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,YAAY,CAAA;IAGpB,SAAS,EAAE,YAAY,CAAA;IACvB,SAAS,EAAE,YAAY,CAAA;IACvB,UAAU,EAAE,YAAY,CAAA;IACxB,UAAU,EAAE,YAAY,CAAA;IAExB,aAAa,EAAE,UAAU,CAAA;IACzB,eAAe,EAAE,YAAY,CAAA;IAC7B,gBAAgB,EAAE,YAAY,CAAA;IAK9B,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,YAAY,CAAA;IACzB,WAAW,EAAE,YAAY,CAAA;IACzB,YAAY,EAAE,YAAY,CAAA;IAC1B,cAAc,EAAE,YAAY,CAAA;IAC5B,cAAc,EAAE,YAAY,CAAA;IAC5B,cAAc,EAAE,YAAY,CAAA;IAK5B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,cAAc,EAAE,UAAU,CAAA;IAC1B,gBAAgB,EAAE,YAAY,CAAA;IAG9B,oBAAoB,EAAE,YAAY,CAAA;IAClC,oBAAoB,EAAE,UAAU,CAAA;IAChC,YAAY,EAAE,YAAY,CAAA;IAC1B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,cAAc,EAAE,UAAU,CAAA;IAC1B,cAAc,EAAE,MAAM,CAAA;IAKtB,eAAe,EAAE,YAAY,CAAA;IAC7B,iBAAiB,EAAE,MAAM,CAAA;IACzB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;CACvB;AAED,eAAO,MAAM,QAAQ,QAAQ,CAAA;AAM7B,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,SAAS,EAAE,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,sBAAsB,EAAE,CAyF1B"}
+{"version":3,"file":"constraint.d.ts","sourceRoot":"","sources":["../../src/physics/constraint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAY/C,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IAEb,MAAM,EAAE,YAAY,CAAA;IACpB,MAAM,EAAE,YAAY,CAAA;IAGpB,SAAS,EAAE,YAAY,CAAA;IACvB,SAAS,EAAE,YAAY,CAAA;IACvB,UAAU,EAAE,YAAY,CAAA;IACxB,UAAU,EAAE,YAAY,CAAA;IAExB,aAAa,EAAE,UAAU,CAAA;IACzB,eAAe,EAAE,YAAY,CAAA;IAC7B,gBAAgB,EAAE,YAAY,CAAA;IAK9B,MAAM,EAAE,OAAO,CAAA;IAKf,SAAS,EAAE,OAAO,CAAA;IAClB,WAAW,EAAE,YAAY,CAAA;IACzB,WAAW,EAAE,YAAY,CAAA;IACzB,YAAY,EAAE,YAAY,CAAA;IAC1B,cAAc,EAAE,YAAY,CAAA;IAC5B,cAAc,EAAE,YAAY,CAAA;IAC5B,cAAc,EAAE,YAAY,CAAA;IAK5B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,cAAc,EAAE,UAAU,CAAA;IAC1B,gBAAgB,EAAE,YAAY,CAAA;IAK9B,oBAAoB,EAAE,YAAY,CAAA;IAClC,oBAAoB,EAAE,YAAY,CAAA;IAClC,iBAAiB,EAAE,YAAY,CAAA;IAC/B,oBAAoB,EAAE,UAAU,CAAA;IAChC,YAAY,EAAE,YAAY,CAAA;IAC1B,iBAAiB,EAAE,YAAY,CAAA;IAC/B,cAAc,EAAE,UAAU,CAAA;IAI1B,cAAc,EAAE,YAAY,CAAA;IAK5B,oBAAoB,EAAE,YAAY,CAAA;IAClC,iBAAiB,EAAE,YAAY,CAAA;IAC/B,UAAU,EAAE,YAAY,CAAA;IACxB,UAAU,EAAE,YAAY,CAAA;IAKxB,eAAe,EAAE,YAAY,CAAA;IAC7B,aAAa,EAAE,YAAY,CAAA;IAC3B,aAAa,EAAE,YAAY,CAAA;IAC3B,iBAAiB,EAAE,MAAM,CAAA;IACzB,iBAAiB,EAAE,MAAM,CAAA;IACzB,iBAAiB,EAAE,MAAM,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IAKtB,gBAAgB,EAAE,YAAY,CAAA;IAC9B,gBAAgB,EAAE,UAAU,CAAA;IAC5B,aAAa,EAAE,YAAY,CAAA;CAC5B;AAOD,eAAO,MAAM,QAAQ,OAAO,CAAA;AAM5B,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,SAAS,EAAE,EACxB,MAAM,EAAE,KAAK,EAAE,GACd,sBAAsB,EAAE,CA+H1B"}

package/dist/physics/constraint.js

@@ -1,5 +1,11 @@
 import { Mat4 } from "../math";
-export const STOP_ERP = 0.475;
+import { RigidbodyType } from "./types";
+// Stop-limit ERP. PMX rigs are tuned against MMD's stiff limit response;
+// lowering this makes cloth resting against its limits sink visibly deeper
+// (equilibrium penetration scales with 1/ERP). Rest chatter at this
+// stiffness was fixed at the source (spring double-drive, unilateral
+// stops) — don't lower ERP to paper over jitter.
+export const STOP_ERP = 0.45;
 // Build per-joint constraints from PMX data:
 //   frameA = (bodyA_worldBind)^-1 · jointWorldBind
 //   frameB = (bodyB_worldBind)^-1 · jointWorldBind
@@ -64,6 +70,7 @@ export function buildConstraints(rigidbodies, joints) {
             springEnabled,
             springStiffness,
             equilibriumPoint: new Float32Array(6),
+            isLoop: false,
             cacheSkip: false,
             cacheLeverA: new Float32Array(3),
             cacheLeverB: new Float32Array(3),
@@ -75,17 +82,57 @@ export function buildConstraints(rigidbodies, joints) {
             cacheLinActive: new Uint8Array(3),
             cacheLinLimitImp: new Float32Array(3),
             cacheLinSpringTarget: new Float32Array(3),
+            cacheLinSpringMaxImp: new Float32Array(3),
+            cacheLinSpringImp: new Float32Array(3),
             cacheLinSpringActive: new Uint8Array(3),
             cacheAngAxes: new Float32Array(9),
             cacheAngTargetVel: new Float32Array(3),
             cacheAngActive: new Uint8Array(3),
-            cacheAngJacInv: 0,
+            cacheAngJacInv: new Float32Array(3),
+            cacheAngSpringMaxImp: new Float32Array(3),
+            cacheAngSpringImp: new Float32Array(3),
+            cacheAngWA: new Float32Array(9),
+            cacheAngWB: new Float32Array(9),
             cacheAngLimAxis: new Float32Array(3),
+            cacheAngLimWA: new Float32Array(3),
+            cacheAngLimWB: new Float32Array(3),
+            cacheAngLimJacInv: 0,
             cacheAngLimTarget: 0,
             cacheAngLimActive: 0,
             cacheAngLimImp: 0,
+            cacheAngPATarget: new Float32Array(3),
+            cacheAngPAActive: new Uint8Array(3),
+            cacheAngPAImp: new Float32Array(3),
         });
     }
+    // Mark loop-closing joints via union-find over the joint graph. All
+    // bone-follow bodies count as one "world" component (they're each anchored
+    // to the skeleton), so a joint bridging two separately anchored subtrees
+    // also closes a kinematic cycle. One edge per cycle gets softened, which
+    // releases the over-determination regardless of which edge it is.
+    const parent = new Int32Array(rigidbodies.length + 1);
+    for (let i = 0; i < parent.length; i++)
+        parent[i] = i;
+    const find = (x) => {
+        while (parent[x] !== x) {
+            parent[x] = parent[parent[x]];
+            x = parent[x];
+        }
+        return x;
+    };
+    const world = rigidbodies.length;
+    for (let i = 0; i < rigidbodies.length; i++) {
+        if (rigidbodies[i].type !== RigidbodyType.Dynamic)
+            parent[find(i)] = find(world);
+    }
+    for (const con of out) {
+        const ra = find(con.bodyA);
+        const rb = find(con.bodyB);
+        if (ra === rb)
+            con.isLoop = true;
+        else
+            parent[ra] = rb;
+    }
     return out;
 }
 // frame = bodyWorldBind^-1 · jointWorld. False if bodyWorldBind is singular.

package/dist/physics/physics.d.ts

@@ -20,6 +20,8 @@ export declare class RezePhysics {
     private kinTargetAngVel;
     private kinRoot;
     private teleportFlags;
+    private alignPinned;
+    teleportCount: number;
     constructor(rigidbodies: Rigidbody[], joints?: Joint[]);
     private buildKinematicRoots;
     private savePrevState;
@@ -39,6 +41,7 @@ export declare class RezePhysics {
     private advanceKinematicToTargets;
     private snapKinematicToTargets;
     private carryDynamicThroughTeleport;
+    private alignPinnedBodiesToBones;
     private restoreNonFiniteBodies;
     private applyDynamicsToBones;
 }

package/dist/physics/physics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAYvC,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAMhC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,gBAAgB,CAAc;IAQtC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,eAAe,CAAc;IAMrC,OAAO,CAAC,OAAO,CAAY;IAE3B,OAAO,CAAC,aAAa,CAAY;gBAErB,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IAmB1D,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,aAAa;IAKrB,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IAOtC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IA4DxF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,uBAAuB;IAqF/B,OAAO,CAAC,yBAAyB;IAgEjC,OAAO,CAAC,sBAAsB;IAmC9B,OAAO,CAAC,2BAA2B;IA8EnC,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,oBAAoB;CAoD7B"}
+{"version":3,"file":"physics.d.ts","sourceRoot":"","sources":["../../src/physics/physics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAYvC,qBAAa,WAAW;IACtB,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA0B;IAC7C,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAI;IAMhC,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,gBAAgB,CAAc;IAQtC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,eAAe,CAAc;IAMrC,OAAO,CAAC,OAAO,CAAY;IAE3B,OAAO,CAAC,aAAa,CAAY;IAMjC,OAAO,CAAC,WAAW,CAAY;IAG/B,aAAa,SAAI;gBAEL,WAAW,EAAE,SAAS,EAAE,EAAE,MAAM,GAAE,KAAK,EAAO;IA8B1D,OAAO,CAAC,mBAAmB;IA4B3B,OAAO,CAAC,aAAa;IAKrB,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAG/B,UAAU,IAAI,IAAI;IAGlB,cAAc,IAAI,SAAS,EAAE;IAG7B,SAAS,IAAI,KAAK,EAAE;IAGpB,QAAQ,IAAI,cAAc;IAI1B,sBAAsB,IAAI,KAAK,CAAC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,QAAQ,EAAE,IAAI,CAAA;KAAE,CAAC;IAiBnE,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE,GAAG,IAAI;IActC,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,EAAE,uBAAuB,EAAE,YAAY,GAAG,IAAI;IAiExF,OAAO,CAAC,iBAAiB;IAuCzB,OAAO,CAAC,uBAAuB;IAqF/B,OAAO,CAAC,yBAAyB;IAgEjC,OAAO,CAAC,sBAAsB;IAmC9B,OAAO,CAAC,2BAA2B;IA6EnC,OAAO,CAAC,wBAAwB;IA2BhC,OAAO,CAAC,sBAAsB;IAqC9B,OAAO,CAAC,oBAAoB;CA6D7B"}

package/dist/physics/physics.js

@@ -16,6 +16,9 @@ export class RezePhysics {
         this.timeAccum = 0;
         this.fixedTimeStep = 1 / 60;
         this.maxSubSteps = 6;
+        // Debug counter: frames on which a teleport (scrub/jump discontinuity)
+        // was detected and settled.
+        this.teleportCount = 0;
         this.rigidbodies = rigidbodies;
         this.joints = joints;
         this.store = new RigidBodyStore(rigidbodies);
@@ -30,6 +33,18 @@ export class RezePhysics {
         this.kinTargetAngVel = new Float32Array(this.store.count * 3);
         this.kinRoot = this.buildKinematicRoots();
         this.teleportFlags = new Uint8Array(this.store.count);
+        this.alignPinned = new Uint8Array(this.store.count);
+        const types = this.store.type;
+        for (const c of this.constraints) {
+            const tA = types[c.bodyA];
+            const tB = types[c.bodyB];
+            const aFollows = tA === RigidbodyType.Static || tA === RigidbodyType.Kinematic;
+            const bFollows = tB === RigidbodyType.Static || tB === RigidbodyType.Kinematic;
+            if (aFollows && this.store.aligned[c.bodyB])
+                this.alignPinned[c.bodyB] = 1;
+            if (bFollows && this.store.aligned[c.bodyA])
+                this.alignPinned[c.bodyA] = 1;
+        }
     }
     // BFS over the joint graph from every kinematic body, assigning each
     // reachable dynamic body the kinematic body it (transitively) hangs off.
@@ -101,6 +116,13 @@ export class RezePhysics {
             return;
         this.snapBodiesToBones(boneWorldMatrices);
         this.savePrevState(); // prev == curr after a snap, so no interpolation jump
+        // Reseed kinematic targets from the snapped pose — otherwise the next
+        // step derives the target-trajectory velocity against the pre-reset
+        // targets and feeds one frame of enormous anchor velocity to the solver.
+        this.kinTargetPos.set(this.store.positions);
+        this.kinTargetOri.set(this.store.orientations);
+        this.kinTargetVel.fill(0);
+        this.kinTargetAngVel.fill(0);
         this.timeAccum = 0;
     }
     step(dt, boneWorldMatrices, boneInverseBindMatrices) {
@@ -124,6 +146,7 @@ export class RezePhysics {
         // raw derived velocity is what used to explode the solver. Chains under
         // unaffected roots keep their momentum untouched.
         if (this.computeKinematicTargets(boneWorldMatrices, dt)) {
+            this.teleportCount++;
             this.carryDynamicThroughTeleport();
             this.snapKinematicToTargets(true);
             this.savePrevState(); // prev == curr so interpolation doesn't streak
@@ -155,6 +178,9 @@ export class RezePhysics {
             this.timeAccum = 0;
             this.snapKinematicToTargets(false);
         }
+        // MMD mode-2 bone alignment for pinned (depth-1) bodies: position
+        // re-pins to the animated bone, rotation stays simulated.
+        this.alignPinnedBodiesToBones(boneWorldMatrices);
         // Fraction into the next (not-yet-taken) step; always in [0, 1).
         const alpha = this.fixedTimeStep > 0 ? this.timeAccum / this.fixedTimeStep : 0;
         this.applyDynamicsToBones(boneWorldMatrices, alpha);
@@ -452,6 +478,32 @@ export class RezePhysics {
             av[i3 + 2] = 0;
         }
     }
+    // Overwrite pinned mode-2 bodies' positions with boneWorld × bodyOffset
+    // from the animated bone pose, keeping simulated orientation and
+    // velocities. prevPositions follows so interpolation doesn't streak.
+    alignPinnedBodiesToBones(boneWorldMatrices) {
+        const N = this.store.count;
+        const pinned = this.alignPinned;
+        const boneIdx = this.store.boneIndex;
+        const offsets = this.store.bodyOffsetMatrix;
+        const positions = this.store.positions;
+        const prevPos = this.prevPositions;
+        for (let i = 0; i < N; i++) {
+            if (!pinned[i])
+                continue;
+            const b = boneIdx[i];
+            if (b < 0 || b >= boneWorldMatrices.length)
+                continue;
+            Mat4.multiplyArrays(boneWorldMatrices[b].values, 0, offsets, i * 16, _bodyMat, 0);
+            const i3 = i * 3;
+            positions[i3 + 0] = _bodyMat[12];
+            positions[i3 + 1] = _bodyMat[13];
+            positions[i3 + 2] = _bodyMat[14];
+            prevPos[i3 + 0] = _bodyMat[12];
+            prevPos[i3 + 1] = _bodyMat[13];
+            prevPos[i3 + 2] = _bodyMat[14];
+        }
+    }
     // Backstop: if a dynamic body's state went non-finite despite the velocity
     // caps, restore its previous-substep pose with zero velocity instead of
     // letting NaNs spread through constraints and contacts. Runs after every
@@ -550,7 +602,23 @@ export class RezePhysics {
             Mat4.multiplyArrays(_bodyMat, 0, inv, i * 16, _boneMat, 0);
             // Sanity gate against NaN / extreme values — silently drop the update.
             if (Number.isFinite(_boneMat[0]) && Math.abs(_boneMat[0]) < 1e6) {
-                boneWorldMatrices[b].values.set(_boneMat);
+                const v = boneWorldMatrices[b].values;
+                if (this.alignPinned[i]) {
+                    // Pinned mode-2: the bone keeps its animated position, physics
+                    // drives rotation only.
+                    v[0] = _boneMat[0];
+                    v[1] = _boneMat[1];
+                    v[2] = _boneMat[2];
+                    v[4] = _boneMat[4];
+                    v[5] = _boneMat[5];
+                    v[6] = _boneMat[6];
+                    v[8] = _boneMat[8];
+                    v[9] = _boneMat[9];
+                    v[10] = _boneMat[10];
+                }
+                else {
+                    v.set(_boneMat);
+                }
             }
         }
     }

package/dist/physics/solver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/physics/solver.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,WAAW,CAAA;AA6BrD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,GACjB,IAAI,CAyBN"}
+{"version":3,"file":"solver.d.ts","sourceRoot":"","sources":["../../src/physics/solver.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA;AAE1D,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,WAAW,CAAA;AAyDrD,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,WAAW,EAAE,sBAAsB,EAAE,EACrC,QAAQ,EAAE,WAAW,EACrB,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,GACjB,IAAI,CA4BN"}