reze-engine 0.16.1 → 0.16.3

package/src/model.ts

@@ -235,6 +235,9 @@ export class Model {
   private rigidbodies: Rigidbody[] = []
   private joints: Joint[] = []
 
+  // Non-fatal problems collected while parsing the PMX (see PmxLoader.warn).
+  private loadWarnings: string[] = []
+
   // Runtime skeleton pose state (updated each frame)
   private runtimeSkeleton!: SkeletonRuntime
 
@@ -293,7 +296,8 @@ export class Model {
     skinning: Skinning,
     morphing: Morphing,
     rigidbodies: Rigidbody[] = [],
-    joints: Joint[] = []
+    joints: Joint[] = [],
+    loadWarnings: string[] = []
   ) {
     // Store base vertex data (original positions before morphing)
     this.baseVertexData = new Float32Array(vertexData)
@@ -307,6 +311,7 @@ export class Model {
     this.morphing = morphing
     this.rigidbodies = rigidbodies
     this.joints = joints
+    this.loadWarnings = loadWarnings
 
     if (this.skeleton.bones.length == 0) {
       throw new Error("Model has no bones")
@@ -631,6 +636,18 @@ export class Model {
     return this.skinning
   }
 
+  // True when the PMX carried a usable rigidbody section. False means the
+  // model renders but has no physics — surface this in the UI instead of
+  // letting it read as "physics silently broken".
+  hasPhysicsData(): boolean {
+    return this.rigidbodies.length > 0
+  }
+
+  // Non-fatal PMX parse problems (truncated sections, suspicious counts…).
+  getLoadWarnings(): readonly string[] {
+    return this.loadWarnings
+  }
+
   getRigidbodies(): Rigidbody[] {
     return this.rigidbodies
   }

package/src/physics/body.ts

@@ -19,6 +19,9 @@ export class RigidBodyStore {
   readonly linearDamping: Float32Array
   readonly angularDamping: Float32Array
   readonly type: Uint8Array
+  // PMX mode-2 bodies: dynamic, but the bone takes rotation only and the
+  // body position re-pins to the animated bone each frame.
+  readonly aligned: Uint8Array
   readonly boneIndex: Int32Array
   readonly friction: Float32Array
   readonly restitution: Float32Array
@@ -59,6 +62,7 @@ export class RigidBodyStore {
     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)
@@ -92,6 +96,7 @@ export class RigidBodyStore {
       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

package/src/physics/constraint.ts

@@ -37,15 +37,37 @@ export interface SixDofSpringConstraint {
   cacheLinCrossA: Float32Array    // 9: (rA × ax) per axis
   cacheLinCrossB: Float32Array    // 9
   cacheLinJacInv: Float32Array    // 3: 1/(im+im+cA²·ii+cB²·ii) per axis
-  cacheLinTargetVel: Float32Array // 3: limit ERP + spring drive, signed
+  // Limit rows are unilateral (Bullet-style): the per-substep accumulated
+  // impulse is clamped to the corrective sign, so a limit can push a body
+  // back into range but never pull it deeper / brake its natural recovery —
+  // bilateral limit rows act as motors and pump energy into swinging cloth.
+  cacheLinTargetVel: Float32Array // 3: limit ERP target, signed
   cacheLinActive: Uint8Array      // 3
-  cacheAngAxes: Float32Array      // 9
-  cacheAngTargetVel: Float32Array // 3
-  cacheAngActive: Uint8Array      // 3
-  cacheAngJacInv: number          // 1 — same for all 3 angular axes
+  cacheLinLimitImp: Float32Array  // 3: accumulated limit impulse (per substep)
+  // Spring rows are velocity-target drives; setup clamps k to the deadbeat
+  // stability bound so they cannot pump energy.
+  cacheLinSpringTarget: Float32Array // 3
+  cacheLinSpringActive: Uint8Array   // 3
+  cacheAngAxes: Float32Array      // 9 (spring rows)
+  cacheAngTargetVel: Float32Array // 3 (spring rows)
+  cacheAngActive: Uint8Array      // 3 (spring rows)
+  cacheAngJacInv: number          // 1 — same for all angular rows
+  // Single geodesic limit row: shortest rotation from the current relative
+  // orientation to the euler-clamped target. Per-axis euler limit rows are
+  // geometrically inconsistent for large violations (asin singularity) and
+  // pump energy instead of converging. Unilateral like the linear limits.
+  cacheAngLimAxis: Float32Array   // 3, world-space unit axis
+  cacheAngLimTarget: number       // target relative angular velocity along axis
+  cacheAngLimActive: number
+  cacheAngLimImp: number          // accumulated impulse (per substep)
 }
 
-export const STOP_ERP = 0.475
+// 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
@@ -128,10 +150,17 @@ export function buildConstraints(
       cacheLinJacInv: new Float32Array(3),
       cacheLinTargetVel: new Float32Array(3),
       cacheLinActive: new Uint8Array(3),
+      cacheLinLimitImp: new Float32Array(3),
+      cacheLinSpringTarget: new Float32Array(3),
+      cacheLinSpringActive: new Uint8Array(3),
       cacheAngAxes: new Float32Array(9),
       cacheAngTargetVel: new Float32Array(3),
       cacheAngActive: new Uint8Array(3),
       cacheAngJacInv: 0,
+      cacheAngLimAxis: new Float32Array(3),
+      cacheAngLimTarget: 0,
+      cacheAngLimActive: 0,
+      cacheAngLimImp: 0,
     })
   }