reze-engine 0.16.1 → 0.16.3

package/src/physics/solver.ts

@@ -19,12 +19,30 @@ import type { Contact, ContactPool } from "./contact"
 
 const BOUNCE_THRESHOLD = 2.0
 
+// Ceilings on limit-correction velocity. In normal operation limit errors are
+// tiny; a large error only appears after a discontinuity (teleport, stall,
+// deep penetration), and feeding err·ERP/dt to the solver unclamped then
+// injects explosion-scale impulses into the chain.
+const MAX_LINEAR_CORRECTION_VEL = 120 // units/s
+const MAX_ANGULAR_CORRECTION_VEL = 30 // rad/s
+
+// Bullet's limit-motor softness defaults (0.7 translational, 0.5 rotational):
+// scale each iteration's limit impulse so the stop engages progressively
+// instead of as a hard velocity snap.
+const LIMIT_SOFTNESS_LINEAR = 0.7
+const LIMIT_SOFTNESS_ANGULAR = 0.5
+// Angular limit violations below this switch to per-axis euler rows; above
+// it, the single geodesic row takes over (see setupConstraint).
+const GEODESIC_THRESHOLD = 0.5 // rad
+
 // Module-level scratch (no per-iter allocations).
 const _TA = new Float32Array(16)
 const _TB = new Float32Array(16)
 const _bodyMatA = new Float32Array(16)
 const _bodyMatB = new Float32Array(16)
 const _angDiffScratch = new Float32Array(3)
+const _quatScratchA = new Float32Array(4)
+const _quatScratchB = new Float32Array(4)
 
 export function solveConstraints(
   store: RigidBodyStore,
@@ -82,21 +100,23 @@ function setupConstraint(
   Mat4.multiplyArrays(_bodyMatA, 0, con.frameA, 0, _TA, 0)
   Mat4.multiplyArrays(_bodyMatB, 0, con.frameB, 0, _TB, 0)
 
-  // Mass-weighted shared anchor (Bullet 2.75 m_AnchorPos).
+  // Per-body pivots at each body's own joint-frame origin (Spring2-style).
+  // Bullet 2.7x's shared mass-weighted anchor (m_AnchorPos) degenerates when
+  // the joint is violated by a large distance: the midpoint sits far from
+  // both bodies, the lever arms grow with the separation, the Jacobian
+  // denominator blows up as err²·invInertia, and the row applies torque
+  // instead of closing velocity — the joint "breaks" and the error runs
+  // away. Per-body pivots keep the levers bounded by the frame offsets, so
+  // the row stays effective no matter how large the violation is.
   const pos = store.positions
   const ai = a * 3
   const bi = b * 3
-  const weightA = imB === 0 ? 1 : imA / (imA + imB)
-  const weightB = 1 - weightA
-  const anchorX = _TA[12] * weightA + _TB[12] * weightB
-  const anchorY = _TA[13] * weightA + _TB[13] * weightB
-  const anchorZ = _TA[14] * weightA + _TB[14] * weightB
-  const rAx = anchorX - pos[ai + 0]
-  const rAy = anchorY - pos[ai + 1]
-  const rAz = anchorZ - pos[ai + 2]
-  const rBx = anchorX - pos[bi + 0]
-  const rBy = anchorY - pos[bi + 1]
-  const rBz = anchorZ - pos[bi + 2]
+  const rAx = _TA[12] - pos[ai + 0]
+  const rAy = _TA[13] - pos[ai + 1]
+  const rAz = _TA[14] - pos[ai + 2]
+  const rBx = _TB[12] - pos[bi + 0]
+  const rBy = _TB[13] - pos[bi + 1]
+  const rBz = _TB[14] - pos[bi + 2]
   const lA = con.cacheLeverA
   const lB = con.cacheLeverB
   lA[0] = rAx; lA[1] = rAy; lA[2] = rAz
@@ -143,23 +163,40 @@ function setupConstraint(
     const lo = con.linearMin[i]
     const hi = con.linearMax[i]
     const curr = i === 0 ? linDiff0 : i === 1 ? linDiff1 : linDiff2
+    // active: 1 = bilateral equality (locked axis — a joint, always on),
+    //         2 = unilateral stop (ranged axis in violation).
     let target = 0
     let active = 0
     if (lo <= hi) {
       let err = 0
       if (curr < lo) err = curr - lo
       else if (curr > hi) err = curr - hi
+      if (lo === hi) active = 1
+      else if (err !== 0) active = 2
       if (err !== 0) {
         target = -err * STOP_ERP * invDt
-        active = 1
+        if (target > MAX_LINEAR_CORRECTION_VEL) target = MAX_LINEAR_CORRECTION_VEL
+        else if (target < -MAX_LINEAR_CORRECTION_VEL) target = -MAX_LINEAR_CORRECTION_VEL
       }
     }
-    if (con.springEnabled[i]) {
-      target += -con.springStiffness[i] * (curr - con.equilibriumPoint[i]) * dt
-      active = 1
-    }
     tgt[i] = target
     act[i] = denom > 0 ? active : 0
+    con.cacheLinLimitImp[i] = 0
+    // A spring on a locked axis is redundant — the bilateral limit row
+    // already welds the DOF, and driving it twice overshoots every
+    // iteration (PMX rigs routinely put k=100000 springs on locked axes,
+    // which turned welded weight-bodies into energy pumps).
+    if (con.springEnabled[i] && denom > 0 && lo !== hi) {
+      // Clamp k to the deadbeat limit: an explicit spring with k·dt² > 1
+      // overshoots equilibrium every step and pumps energy — the classic
+      // pre-Spring2 Bullet 6dof instability this port inherited.
+      const k = Math.min(con.springStiffness[i], invDt * invDt)
+      const serr = curr - con.equilibriumPoint[i]
+      con.cacheLinSpringTarget[i] = -k * serr * dt
+      con.cacheLinSpringActive[i] = 1
+    } else {
+      con.cacheLinSpringActive[i] = 0
+    }
   }
 
   // Angular: TA^T · TB → Euler XYZ; axes from TA.col2 × TB.col0.
@@ -198,32 +235,93 @@ function setupConstraint(
   const angDenom = iiA + iiB
   con.cacheAngJacInv = angDenom > 0 ? 1 / angDenom : 0
 
+  // Per-axis rows carry only the springs. Sign flip vs linear:
+  // d(angDiff)/dt = −(ω_B − ω_A)·ax.
   const angTgt = con.cacheAngTargetVel
   const angAct = con.cacheAngActive
   for (let i = 0; i < 3; i++) {
     const idx = i + 3
-    const lo = con.angularMin[i]
-    const hi = con.angularMax[i]
-    const curr = _angDiffScratch[i]
-    let target = 0
-    let active = 0
-    if (lo <= hi) {
-      let err = 0
-      if (curr < lo) err = curr - lo
-      else if (curr > hi) err = curr - hi
-      // Sign flip vs linear: d(angDiff)/dt = −(ω_B − ω_A)·ax.
-      if (err !== 0) {
-        target = err * STOP_ERP * invDt
-        active = 1
-      }
+    // Springs on locked axes are skipped — the limit row welds those, and
+    // double-driving a DOF overshoots every iteration (see the linear loop).
+    if (con.springEnabled[idx] && angDenom > 0 && con.angularMin[i] !== con.angularMax[i]) {
+      // Same deadbeat clamp as the linear springs.
+      const k = Math.min(con.springStiffness[idx], invDt * invDt)
+      const serr = _angDiffScratch[i] - con.equilibriumPoint[idx]
+      angTgt[i] = k * serr * dt
+      angAct[i] = 1
+    } else {
+      angTgt[i] = 0
+      angAct[i] = 0
     }
-    if (con.springEnabled[idx]) {
-      target += con.springStiffness[idx] * (curr - con.equilibriumPoint[idx]) * dt
-      active = 1
+  }
+
+  // Angular limit handling is hybrid. Small violations (the resting-cloth
+  // regime) use per-axis euler rows — they converge cleanly and keep resting
+  // cloth dead still. Large violations switch to a single geodesic row toward
+  // the euler-clamped target: per-axis euler rows (the Bullet-2.7x approach
+  // this port used) become geometrically inconsistent for large errors — near
+  // the asin singularity they chase phantom errors and pump angular velocity
+  // into the chain instead of converging.
+  con.cacheAngLimActive = 0
+  if (angDenom > 0) {
+    const ex = _angDiffScratch[0], ey = _angDiffScratch[1], ez = _angDiffScratch[2]
+    // Free axes (min > max) follow the current angle, i.e. no correction.
+    let tx = ex, ty = ey, tz = ez
+    if (con.angularMin[0] <= con.angularMax[0]) tx = ex < con.angularMin[0] ? con.angularMin[0] : ex > con.angularMax[0] ? con.angularMax[0] : ex
+    if (con.angularMin[1] <= con.angularMax[1]) ty = ey < con.angularMin[1] ? con.angularMin[1] : ey > con.angularMax[1] ? con.angularMax[1] : ey
+    if (con.angularMin[2] <= con.angularMax[2]) tz = ez < con.angularMin[2] ? con.angularMin[2] : ez > con.angularMax[2] ? con.angularMax[2] : ez
+    const errX = ex - tx, errY = ey - ty, errZ = ez - tz
+    const maxErr = Math.max(Math.abs(errX), Math.abs(errY), Math.abs(errZ))
+    if (maxErr > 0 && maxErr < GEODESIC_THRESHOLD) {
+      // Per-axis euler limit rows, folded into the per-axis row set (the
+      // spring impulse clamp must not bound a limit row — lift it).
+      for (let i = 0; i < 3; i++) {
+        const err = i === 0 ? errX : i === 1 ? errY : errZ
+        if (err === 0) continue
+        let target = err * STOP_ERP * invDt
+        if (target > MAX_ANGULAR_CORRECTION_VEL) target = MAX_ANGULAR_CORRECTION_VEL
+        else if (target < -MAX_ANGULAR_CORRECTION_VEL) target = -MAX_ANGULAR_CORRECTION_VEL
+        angTgt[i] += target
+        angAct[i] = 1
+      }
+    } else if (maxErr > 0) {
+      // Bilateral (equality) if any violated axis is locked — a locked axis
+      // is a joint, not a stop. Unilateral otherwise.
+      const bilateral =
+        (tx !== ex && con.angularMin[0] === con.angularMax[0]) ||
+        (ty !== ey && con.angularMin[1] === con.angularMax[1]) ||
+        (tz !== ez && con.angularMin[2] === con.angularMax[2])
+      // The decomposition above satisfies R_rel^T = Rx(x)·Ry(y)·Rz(z), so
+      // u = qx·qy·qz is conj(q_rel) and the error rotation (current →
+      // clamped target, expressed in TA's frame) is q_E = conj(u_t) ⊗ u.
+      eulerXYZQuatInto(ex, ey, ez, _quatScratchA)
+      eulerXYZQuatInto(tx, ty, tz, _quatScratchB)
+      const ux = _quatScratchA[0], uy = _quatScratchA[1], uz = _quatScratchA[2], uw = _quatScratchA[3]
+      const vx = _quatScratchB[0], vy = _quatScratchB[1], vz = _quatScratchB[2], vw = _quatScratchB[3]
+      // q_E = conj(v) ⊗ u
+      let qex = vw * ux - vx * uw - vy * uz + vz * uy
+      let qey = vw * uy + vx * uz - vy * uw - vz * ux
+      let qez = vw * uz - vx * uy + vy * ux - vz * uw
+      let qew = vw * uw + vx * ux + vy * uy + vz * uz
+      if (qew < 0) { qex = -qex; qey = -qey; qez = -qez; qew = -qew }
+      const sinHalf = Math.sqrt(qex * qex + qey * qey + qez * qez)
+      if (sinHalf > 1e-6) {
+        const angle = 2 * Math.atan2(sinHalf, qew)
+        const invS = 1 / sinHalf
+        const axx = qex * invS, axy = qey * invS, axz = qez * invS
+        // Axis lives in TA's frame; TA's basis columns map it to world.
+        const lim = con.cacheAngLimAxis
+        lim[0] = _TA[0] * axx + _TA[4] * axy + _TA[8] * axz
+        lim[1] = _TA[1] * axx + _TA[5] * axy + _TA[9] * axz
+        lim[2] = _TA[2] * axx + _TA[6] * axy + _TA[10] * axz
+        let target = angle * STOP_ERP * invDt
+        if (target > MAX_ANGULAR_CORRECTION_VEL) target = MAX_ANGULAR_CORRECTION_VEL
+        con.cacheAngLimTarget = target
+        con.cacheAngLimActive = bilateral ? 1 : 2
+      }
     }
-    angTgt[i] = target
-    angAct[i] = angDenom > 0 ? active : 0
   }
+  con.cacheAngLimImp = 0
 }
 
 // ITER: read cache, compute relVel from current lv/av, apply impulse.
@@ -266,12 +364,43 @@ function iterateConstraint(
   const dvy = vBy - vAy
   const dvz = vBz - vAz
 
+  const sprAct = con.cacheLinSpringActive
+  const sprTgt = con.cacheLinSpringTarget
+  const limImp = con.cacheLinLimitImp
   for (let i = 0; i < 3; i++) {
-    if (!act[i]) continue
+    if (!act[i] && !sprAct[i]) continue
     const o = i * 3
     const axx = axes[o + 0], axy = axes[o + 1], axz = axes[o + 2]
     const relVel = dvx * axx + dvy * axy + dvz * axz
-    const j = (tgt[i] - relVel) * jac[i]
+    let j = 0
+
+    // Limit row. Locked axes (act 1) are bilateral equality joints; ranged
+    // axes in violation (act 2) are unilateral stops — accumulated impulse
+    // clamped to the corrective sign, so the stop pushes back into range but
+    // never pulls deeper or brakes natural recovery (a bilateral stop acts
+    // as a motor and pumps energy into swinging cloth).
+    if (act[i]) {
+      const target = tgt[i]
+      let dImp = LIMIT_SOFTNESS_LINEAR * (target - relVel) * jac[i]
+      if (act[i] === 2) {
+        const old = limImp[i]
+        let next = old + dImp
+        if (target > 0 ? next < 0 : next > 0) next = 0
+        dImp = next - old
+        limImp[i] = next
+      }
+      j += dImp
+    }
+
+    // Spring row: velocity-target drive; the deadbeat k-clamp at setup
+    // bounds its aggression. relVel is refreshed with the limit impulse
+    // applied just above (j·denom = j / jac) — driving the spring off the
+    // stale value double-corrects the DOF and overshoots every iteration.
+    if (sprAct[i]) {
+      const relVelNow = j !== 0 ? relVel + j / jac[i] : relVel
+      j += (sprTgt[i] - relVelNow) * jac[i]
+    }
+
     if (j === 0) continue
     if (imA > 0) {
       lv[ai + 0] -= j * imA * axx
@@ -305,6 +434,8 @@ function iterateConstraint(
     const o = i * 3
     const axx = angAxes[o + 0], axy = angAxes[o + 1], axz = angAxes[o + 2]
     const relAv = dax * axx + day * axy + daz * axz
+    // Spring drive (deadbeat-clamped at setup) plus, for small violations,
+    // the folded per-axis limit correction.
     const j = (angTgt[i] - relAv) * angJacInv
     if (j === 0) continue
     if (iiA > 0) {
@@ -318,6 +449,39 @@ function iterateConstraint(
       av[bi + 2] += j * iiB * axz
     }
   }
+
+  // Geodesic limit row: drive (ω_B − ω_A)·axis toward the correction target.
+  // Unilateral — the accumulated impulse can only push toward the legal
+  // region (target is always ≥ 0 along the corrective axis).
+  if (con.cacheAngLimActive) {
+    const lim = con.cacheAngLimAxis
+    const nx = lim[0], ny = lim[1], nz = lim[2]
+    // Re-read relAv — the spring rows above may have changed av.
+    const relAv =
+      (av[bi + 0] - av[ai + 0]) * nx +
+      (av[bi + 1] - av[ai + 1]) * ny +
+      (av[bi + 2] - av[ai + 2]) * nz
+    let j = LIMIT_SOFTNESS_ANGULAR * (con.cacheAngLimTarget - relAv) * angJacInv
+    if (con.cacheAngLimActive === 2) {
+      const old = con.cacheAngLimImp
+      let next = old + j
+      if (next < 0) next = 0
+      j = next - old
+      con.cacheAngLimImp = next
+    }
+    if (j !== 0) {
+      if (iiA > 0) {
+        av[ai + 0] -= j * iiA * nx
+        av[ai + 1] -= j * iiA * ny
+        av[ai + 2] -= j * iiA * nz
+      }
+      if (iiB > 0) {
+        av[bi + 0] += j * iiB * nx
+        av[bi + 1] += j * iiB * ny
+        av[bi + 2] += j * iiB * nz
+      }
+    }
+  }
 }
 
 // SETUP: pre-compute Jacobians, friction basis, and the bounce reference
@@ -552,6 +716,17 @@ function buildBodyMat(store: RigidBodyStore, i: number, out: Float32Array): void
   )
 }
 
+// Quaternion of qx(x) ⊗ qy(y) ⊗ qz(z) (three.js 'XYZ' order).
+function eulerXYZQuatInto(x: number, y: number, z: number, out: Float32Array): void {
+  const sx = Math.sin(x * 0.5), cx = Math.cos(x * 0.5)
+  const sy = Math.sin(y * 0.5), cy = Math.cos(y * 0.5)
+  const sz = Math.sin(z * 0.5), cz = Math.cos(z * 0.5)
+  out[0] = sx * cy * cz + cx * sy * sz
+  out[1] = cx * sy * cz - sx * cy * sz
+  out[2] = cx * cy * sz + sx * sy * cz
+  out[3] = cx * cy * cz - sx * sy * sz
+}
+
 // Euler XYZ from a 3×3 rotation matrix (row-major elements).
 function matrixToEulerXYZ(
   r00: number, r01: number,

package/src/physics/types.ts

@@ -6,10 +6,15 @@ export enum RigidbodyShape {
   Capsule = 2,
 }
 
+// PMX physics mode: 0 = follow bone, 1 = physics, 2 = physics + bone-position
+// alignment. Mode 2 is DYNAMIC — the loader maps it to Dynamic with
+// `aligned: true` (bone gets rotation only, body position re-pins to the
+// animated bone each frame). Mapping the raw byte 1:1 onto this enum froze
+// mode-2 bodies (most modern cloth rigs, and every 胸_回転 breast body).
 export enum RigidbodyType {
-  Static = 0,
+  Static = 0, // follows bone (anchor)
   Dynamic = 1,
-  Kinematic = 2,
+  Kinematic = 2, // follows bone (legacy alias; loader no longer emits it)
 }
 
 export interface Rigidbody {
@@ -28,6 +33,9 @@ export interface Rigidbody {
   restitution: number
   friction: number
   type: RigidbodyType
+  // PMX mode 2: dynamic body whose bone takes rotation only; the body's
+  // position re-pins to the animated bone each frame.
+  aligned?: boolean
   bodyOffsetMatrixInverse: Mat4 // Inverse of body offset matrix, used to sync rigidbody to bone
   bodyOffsetMatrix?: Mat4 // Cached non-inverse for performance (computed once during initialization)
 }

package/src/physics/world.ts

@@ -14,6 +14,12 @@ export class World {
   readonly gravity: Vec3
   solverIterations = 10
 
+  // Per-body damping factors pow(1−damping, dt), cached because damping and
+  // the fixed dt never change — two Math.pow per body per substep otherwise.
+  private dampCacheDt = -1
+  private linDampFactor: Float32Array | null = null
+  private angDampFactor: Float32Array | null = null
+
   constructor(gravity: Vec3) {
     this.gravity = new Vec3(gravity.x, gravity.y, gravity.z)
   }
@@ -43,15 +49,26 @@ export class World {
 
     // 1. Predict — gravity + damping. The pow form (vs the linear
     //    1−damping·dt approximation) stays stable at high PMX damping
-    //    values like 0.99.
+    //    values like 0.99. Factors are cached (damping and dt are constant).
+    if (this.dampCacheDt !== dt || !this.linDampFactor || this.linDampFactor.length !== N) {
+      this.dampCacheDt = dt
+      this.linDampFactor = new Float32Array(N)
+      this.angDampFactor = new Float32Array(N)
+      for (let i = 0; i < N; i++) {
+        this.linDampFactor[i] = Math.pow(Math.max(0, 1 - ldamp[i]), dt)
+        this.angDampFactor[i] = Math.pow(Math.max(0, 1 - adamp[i]), dt)
+      }
+    }
+    const linDamp = this.linDampFactor
+    const angDamp = this.angDampFactor!
     for (let i = 0; i < N; i++) {
       if (types[i] !== RigidbodyType.Dynamic || invMass[i] <= 0) continue
       const i3 = i * 3
       lv[i3 + 0] += gx * dt
       lv[i3 + 1] += gy * dt
       lv[i3 + 2] += gz * dt
-      const ld = Math.pow(Math.max(0, 1 - ldamp[i]), dt)
-      const ad = Math.pow(Math.max(0, 1 - adamp[i]), dt)
+      const ld = linDamp[i]
+      const ad = angDamp[i]
       lv[i3 + 0] *= ld; lv[i3 + 1] *= ld; lv[i3 + 2] *= ld
       av[i3 + 0] *= ad; av[i3 + 1] *= ad; av[i3 + 2] *= ad
     }
@@ -101,13 +118,25 @@ export class World {
 
     // 5. Integrate. Cap angular velocity at π/2 per step — a high-impulse
     //    contact spike on a low-inertia body would otherwise spin past π
-    //    in one step and trash the quaternion integration.
+    //    in one step and trash the quaternion integration. Linear velocity
+    //    is capped at 5 units per step for the same reason: an explosion
+    //    guard far above what legit cloth motion ever reaches.
     const MAX_ANGVEL_DT = Math.PI * 0.5
+    const MAX_LINVEL_DT = 5
     for (let i = 0; i < N; i++) {
       if (types[i] !== RigidbodyType.Dynamic || invMass[i] <= 0) continue
       const i3 = i * 3
       const i4 = i * 4
 
+      const vx = lv[i3 + 0], vy = lv[i3 + 1], vz = lv[i3 + 2]
+      const vmag = Math.sqrt(vx * vx + vy * vy + vz * vz)
+      if (vmag * dt > MAX_LINVEL_DT) {
+        const scale = MAX_LINVEL_DT / (vmag * dt)
+        lv[i3 + 0] = vx * scale
+        lv[i3 + 1] = vy * scale
+        lv[i3 + 2] = vz * scale
+      }
+
       pos[i3 + 0] += lv[i3 + 0] * dt
       pos[i3 + 1] += lv[i3 + 1] * dt
       pos[i3 + 2] += lv[i3 + 2] * dt

package/src/pmx-loader.ts

@@ -37,11 +37,22 @@ export class PmxLoader {
   private vertexCount: number = 0
   private rigidbodies: Rigidbody[] = []
   private joints: Joint[] = []
+  private warnings: string[] = []
 
   private constructor(buffer: ArrayBuffer) {
     this.view = new DataView(buffer)
   }
 
+  // Parse problems are non-fatal (the mesh may still render), but they must
+  // be queryable afterwards — a rig whose rigidbody section failed to parse
+  // silently loses physics, and console.warn alone drowns in browser log
+  // limits. Collected warnings ship on the Model (getLoadWarnings()).
+  private warn(message: string, error?: unknown): void {
+    const full = error instanceof Error ? `${message}: ${error.message}` : message
+    this.warnings.push(full)
+    console.warn(message, error ?? "")
+  }
+
   static async load(url: string): Promise<Model> {
     return PmxLoader.loadFromReader(createFetchAssetReader(), url)
   }
@@ -82,7 +93,7 @@ export class PmxLoader {
     const version = this.getFloat32()
     if (version < 2.0 || version > 2.2) {
       // Continue, but warn for unexpected version
-      console.warn(`PMX version ${version} may not be fully supported`)
+      this.warn(`PMX version ${version} may not be fully supported`)
     }
 
     // PMX: globals count (uint8) followed by that many bytes describing encoding and index sizes
@@ -472,7 +483,7 @@ export class PmxLoader {
       }
       this.bones = bones
     } catch (e) {
-      console.warn("Error parsing bones:", e)
+      this.warn("Error parsing bones:", e)
       this.bones = []
     }
   }
@@ -487,7 +498,7 @@ export class PmxLoader {
       const count = this.getInt32()
       if (count < 0 || count > 100000) {
         // Suspicious count, likely corrupted
-        console.warn(`Suspicious morph count: ${count}`)
+        this.warn(`Suspicious morph count: ${count}`)
         this.morphs = []
         return
       }
@@ -623,11 +634,11 @@ export class PmxLoader {
           this.morphs.push(morph)
         } catch (e) {
           // If we fail to read a morph, skip it
-          console.warn(`Error reading morph ${i}:`, e)
+          this.warn(`Error reading morph ${i}:`, e)
         }
       }
     } catch (e) {
-      console.warn("Error parsing morphs:", e)
+      this.warn("Error parsing morphs:", e)
       this.morphs = []
     }
   }
@@ -669,13 +680,13 @@ export class PmxLoader {
           }
         } catch (e) {
           // If we fail to read a frame, stop skipping
-          console.warn(`Error reading display frame ${i}:`, e)
+          this.warn(`Error reading display frame ${i}:`, e)
           return false
         }
       }
       return true
     } catch (e) {
-      console.warn("Error skipping display frames:", e)
+      this.warn("Error skipping display frames:", e)
       return false
     }
   }
@@ -685,7 +696,7 @@ export class PmxLoader {
       // Note: morphs and display frames are already skipped in parse() before calling this
       // Check bounds before reading rigidbody count
       if (this.offset + 4 > this.view.buffer.byteLength) {
-        console.warn("Not enough bytes for rigidbody count")
+        this.warn("Not enough bytes for rigidbody count")
         this.rigidbodies = []
         return
       }
@@ -693,7 +704,7 @@ export class PmxLoader {
       const count = this.getInt32()
       if (count < 0 || count > 10000) {
         // Suspicious count
-        console.warn(`Suspicious rigidbody count: ${count}`)
+        this.warn(`Suspicious rigidbody count: ${count}`)
         this.rigidbodies = []
         return
       }
@@ -704,7 +715,7 @@ export class PmxLoader {
         try {
           // Check bounds before reading each rigidbody
           if (this.offset >= this.view.buffer.byteLength) {
-            console.warn(`Reached end of buffer while reading rigidbody ${i} of ${count}`)
+            this.warn(`Reached end of buffer while reading rigidbody ${i} of ${count}`)
             break
           }
 
@@ -737,7 +748,12 @@ export class PmxLoader {
           const angularDamping = this.getFloat32()
           const restitution = this.getFloat32()
           const friction = this.getFloat32()
-          const type = this.getUint8() // 0=static, 1=dynamic, 2=kinematic
+          // PMX physics mode: 0 = follow bone, 1 = physics,
+          // 2 = physics + bone-position alignment. Mode 2 is dynamic — it
+          // must NOT be cast onto RigidbodyType (2 = Kinematic there, which
+          // freezes the body to its bone and kills physics for most modern
+          // cloth rigs and every 胸_回転 breast body).
+          const mode = this.getUint8()
 
           this.rigidbodies.push({
             name,
@@ -754,17 +770,18 @@ export class PmxLoader {
             angularDamping,
             restitution,
             friction,
-            type: type as RigidbodyType,
+            type: mode === 0 ? RigidbodyType.Static : RigidbodyType.Dynamic,
+            aligned: mode === 2,
             bodyOffsetMatrixInverse: Mat4.identity(),
           })
         } catch (e) {
-          console.warn(`Error reading rigidbody ${i} of ${count}:`, e)
+          this.warn(`Error reading rigidbody ${i} of ${count}:`, e)
           // Stop parsing if we encounter an error
           break
         }
       }
     } catch (e) {
-      console.warn("Error parsing rigidbodies:", e)
+      this.warn("Error parsing rigidbodies:", e)
       this.rigidbodies = []
     }
   }
@@ -773,14 +790,14 @@ export class PmxLoader {
     try {
       // Check bounds before reading joint count
       if (this.offset + 4 > this.view.buffer.byteLength) {
-        console.warn("Not enough bytes for joint count")
+        this.warn("Not enough bytes for joint count")
         this.joints = []
         return
       }
 
       const count = this.getInt32()
       if (count < 0 || count > 10000) {
-        console.warn(`Suspicious joint count: ${count}`)
+        this.warn(`Suspicious joint count: ${count}`)
         this.joints = []
         return
       }
@@ -791,7 +808,7 @@ export class PmxLoader {
         try {
           // Check bounds before reading each joint
           if (this.offset >= this.view.buffer.byteLength) {
-            console.warn(`Reached end of buffer while reading joint ${i} of ${count}`)
+            this.warn(`Reached end of buffer while reading joint ${i} of ${count}`)
             break
           }
 
@@ -857,13 +874,13 @@ export class PmxLoader {
             springRotation: new Vec3(springRotX, springRotY, springRotZ), // Store as Vec3 (stiffness values)
           })
         } catch (e) {
-          console.warn(`Error reading joint ${i} of ${count}:`, e)
+          this.warn(`Error reading joint ${i} of ${count}:`, e)
           // Stop parsing if we encounter an error
           break
         }
       }
     } catch (e) {
-      console.warn("Error parsing joints:", e)
+      this.warn("Error parsing joints:", e)
       this.joints = []
     }
   }
@@ -1044,7 +1061,8 @@ export class PmxLoader {
       skinning,
       morphing,
       this.rigidbodies,
-      this.joints
+      this.joints,
+      this.warnings
     )
   }