@woosh/meep-engine 3.55.0 → 3.57.0

package/src/engine/intelligence/resource/ResourceAllocationSolver.js

@@ -67,7 +67,7 @@ export class ResourceAllocationSolver {
         const existingResource = this.resources.get(type);
 
         if (existingResource === undefined) {
-            this.resources.set(type, resource);
+            this.resources.set(type, resource.clone());
         } else {
             existingResource.amount += resource.amount;
         }

package/src/engine/navigation/ecs/components/Path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/Path.js"],"names":[],"mappings":";AAyDA;IAycI,8BAMC;IA9cD;;;;OAIG;IACH,eAOE;IAEF;;;;OAIG;IACH,wBAAyC;IAEzC;;;OAGG;IACH,eAFU,iBAAiB,GAAC,MAAM,CAEO;IAEzC;;;;OAIG;IACH,iBAAc;IAEd;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAEC;IAED;;;OAGG;IACH,iBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAkBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAenB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,yBAWhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBACpD,MAAM,QAYhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,oBAMhB;IAED;;;OAGG;IACH,mCAFW,SAAS,QAYnB;IAED;;OAEG;IACH,gBAEC;IAED;;;OAGG;IACH,YAFW,IAAI,QAMd;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,+CAFa,MAAM,CA0ClB;IAED;;;;;;;OAOG;IACH,uCALW,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;OAKG;IACH,2CAJW,MAAM,EAAE,qBACR,MAAM,GACJ,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,4CAHW,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;;;;OAOG;IACH,gCALW,MAAM,kBACN,iBAAiB,GACf,OAAO,CAYnB;IAED,mBAEC;IAED;;;MAaC;IAUD;;;aAcC;IAED;;;OAGG;IACH,qBAYC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAsClB;CAEJ;;;;kCAtkBiC,wBAAwB"}
+{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/components/Path.js"],"names":[],"mappings":";AAyDA;IA0cI,8BAMC;IA/cD;;;;OAIG;IACH,eAOE;IAEF;;;;OAIG;IACH,wBAAyC;IAEzC;;;OAGG;IACH,eAFU,iBAAiB,GAAC,MAAM,CAEO;IAEzC;;;;OAIG;IACH,iBAAc;IAEd;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED,cAGC;IAED;;;OAGG;IACH,iBAFY,MAAM,CAIjB;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,QAkBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAenB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,yBAWhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBACpD,MAAM,QAYhB;IAED;;;;OAIG;IACH,6BAHW,MAAM,oBAMhB;IAED;;;OAGG;IACH,mCAFW,SAAS,QAYnB;IAED;;OAEG;IACH,gBAEC;IAED;;;OAGG;IACH,YAFW,IAAI,QAMd;IAED;;;OAGG;IACH,SAFY,IAAI,CAQf;IAED;;;;OAIG;IACH,+CAFa,MAAM,CA0ClB;IAED;;;;;;;OAOG;IACH,uCALW,MAAM,GACJ,OAAO,CA8BnB;IAED;;;;;OAKG;IACH,2CAJW,MAAM,EAAE,qBACR,MAAM,GACJ,OAAO,CAkDnB;IAED;;;;;OAKG;IACH,4CAHW,MAAM,GACJ,OAAO,CAwCnB;IAED;;;;;;;OAOG;IACH,gCALW,MAAM,kBACN,iBAAiB,GACf,OAAO,CAYnB;IAED,mBAEC;IAED;;;MAaC;IAUD;;;aAcC;IAED;;;OAGG;IACH,qBAYC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAsClB;CAEJ;;;;kCAvkBiC,wBAAwB"}

package/src/engine/navigation/ecs/components/Path.js

@@ -99,7 +99,8 @@ class Path {
     }
 
     clear() {
-        this.__data.clear();
+        this.__data.clear();
+        this.__length = -1;
     }
 
     /**

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AAyJA;;IACI,sCAA8B;IAC9B,mKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,WAAW,QACX,IAAI,UACJ,MAAM,QA4BhB;CAgBJ;uBApNsB,wBAAwB;yBAItB,mBAAmB;4BAFhB,uCAAuC;4CAHvB,uDAAuD;iBAIlF,uBAAuB"}
+{"version":3,"file":"PathFollowingSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowingSystem.js"],"names":[],"mappings":";AA4JA;;IACI,sCAA8B;IAC9B,mKAIE;IAEF;;;;OAIG;IACH,qBAAiB;IAEjB;;;;;;OAMG;IACH,6BALW,YAAY,aACZ,WAAW,QACX,IAAI,UACJ,MAAM,QA4BhB;CAgBJ;uBAvNsB,wBAAwB;yBAItB,mBAAmB;4BAFhB,uCAAuC;4CAHvB,uDAAuD;iBAIlF,uBAAuB"}

package/src/engine/navigation/ecs/path_following/PathFollowingSystem.js

@@ -55,9 +55,9 @@ function performStep(pathFollower, path, transform, timeDelta) {
         const nextPosition = v3_temp1;
 
         const next_offset = pathFollower.position + stepDistance;
-        const next_offset_truncated = next_offset % path_length;
+        const next_offset_truncated = path_length > 0 ? next_offset % path_length : 0;
 
-        if (next_offset >= path_length && !pathFollower.getFlag(PathFollowerFlags.Loop)) {
+        if ((path_length <= 0 || next_offset >= path_length) && !pathFollower.getFlag(PathFollowerFlags.Loop)) {
             // we're not looping
             remainingDistance = 0;
             path.sample(nextPosition, path_length);
@@ -65,6 +65,9 @@ function performStep(pathFollower, path, transform, timeDelta) {
             pathFollower.setFlag(PathFollowerFlags.Finished);
             pathFollower.position = path_length;
         } else {
+            if (path_length <= 0) {
+                remainingDistance = 0;
+            }
             path.sample(nextPosition, next_offset_truncated);
             pathFollower.position = next_offset_truncated;
         }

package/src/engine/physics/body/SolverBodyState.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SolverBodyState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/body/SolverBodyState.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,+CAA+C;AAC/C,6BAA8B;AAC9B,oFAAoF;AACpF,4BAA6B;AAC7B,4BAA6B;AAC7B,4BAA6B;AAC7B,oFAAoF;AACpF,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,kCAAkC;AAClC,yBAA0B;AAC1B,yBAA0B;AAC1B,0BAA2B;AAC3B,mCAAmC;AACnC,0BAA2B;AAC3B,0BAA2B;AAC3B,0BAA2B;AAE3B,wBAAwB;AACxB,4BAA6B;AAE7B;IAWI,uCA0BC;IApCD,eAAe;IACf,yBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAKN;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,+CA6DhB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}
+{"version":3,"file":"SolverBodyState.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/body/SolverBodyState.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AAEH,+CAA+C;AAC/C,6BAA8B;AAC9B,oFAAoF;AACpF,4BAA6B;AAC7B,4BAA6B;AAC7B,4BAA6B;AAC7B,oFAAoF;AACpF,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,uBAAwB;AACxB,kCAAkC;AAClC,yBAA0B;AAC1B,yBAA0B;AAC1B,0BAA2B;AAC3B,mCAAmC;AACnC,0BAA2B;AAC3B,0BAA2B;AAC3B,0BAA2B;AAE3B,wBAAwB;AACxB,4BAA6B;AAE7B;IAWI,uCA0BC;IApCD,eAAe;IACf,yBAAqB;IAErB;;;;OAIG;IACH,cAAU;IAKN;;;OAGG;IACH,MAFU,YAAY,CAEwB;IAE9C;;;;;OAKG;IACH,gBAAkC;IAElC;;;;OAIG;IACH,mBAAsC;IAEtC,eAAe;IACf,mBAAqB;IAGzB;;;OAGG;IACH,6BAEC;IAED;;;;;OAKG;IACH,WAFW,MAAM,QAiBhB;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,+CAyDhB;IAED;;;;;;;OAOG;IACH,gBAFW,WAAW,QAoBrB;IAED;;;OAGG;IACH,eAeC;CACJ"}

package/src/engine/physics/body/SolverBodyState.js

@@ -1,6 +1,6 @@
 import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 import { BodyKind } from "../ecs/BodyKind.js";
-import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
+import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
 import { SleepState } from "../ecs/SleepState.js";
 
 /**
@@ -188,11 +188,7 @@ export class SolverBodyState {
             // flag does not cancel a PRE-EXISTING spin about the axis — no
             // impulse can change it any more; callers zero angularVelocity
             // themselves when locking a body mid-spin.
-            const ii = rb.inverseInertiaLocal;
-            const flags = rb.flags;
-            d[base + SBS_INV_I_X] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
-            d[base + SBS_INV_I_Y] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
-            d[base + SBS_INV_I_Z] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
+            locked_inverse_inertia(d, base + SBS_INV_I_X, rb);
         } else {
             // Static / Kinematic: immovable to the solver — no inverse mass,
             // no inverse inertia (mirrors the object path's `kind` guards).

package/src/engine/physics/ccd/linear_sweep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AA2SA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0CAhBW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE,UAAU,MAAM,CAAC,MAGjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA6ClB;AA85BD;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,oCAPW,OAAO,yBAAyB,EAAE,aAAa,MAC/C,MAAM,KACN,MAAM,YACN,MAAM,GAEJ,MAAM,CA2NlB;AAED;;;;;;;GAOG;AACH,sCAFa,WAAW,CAIvB;AAriDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAjEP,mCAAmC"}
+{"version":3,"file":"linear_sweep.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ccd/linear_sweep.js"],"names":[],"mappings":"AA4SA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0CAhBW,OAAO,yBAAyB,EAAE,aAAa,SAC/C,OAAO,gDAAgD,EAAE,eAAe,YACxE,UAAU,MAAM,CAAC,MAGjB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,kBACN,MAAM,UAEN,mBAAmB,GACjB,MAAM,CA6ClB;AAg5BD;;;;;;;;;;;;GAYG;AACH,6CAFW,OAAO,yBAAyB,EAAE,aAAa,QAezD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,oCAPW,OAAO,yBAAyB,EAAE,aAAa,MAC/C,MAAM,KACN,MAAM,YACN,MAAM,GAEJ,MAAM,CA2NlB;AAED;;;;;;;GAOG;AACH,sCAFa,WAAW,CAIvB;AAvhDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,qCAFU,MAAM,CAE2B;oCAjEP,mCAAmC"}

package/src/engine/physics/ccd/linear_sweep.js

@@ -5,6 +5,7 @@ import { BodyKind } from "../ecs/BodyKind.js";
 import { is_sensor } from "../ecs/is_sensor.js";
 import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
 import { SleepState } from "../ecs/SleepState.js";
+import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
 import { angular_effective_mass_raw, world_inverse_inertia_apply_raw } from "../inertia/world_inverse_inertia.js";
 import { PhysicsSurfacePoint } from "../queries/PhysicsSurfacePoint.js";
 import { shape_cast, shape_cast_struck_support } from "../queries/shape_cast.js";
@@ -1064,7 +1065,7 @@ function ccd_respond_shared(system, rb, body_tr, blocker, blocker_idx, blocker_t
     if (blocker.sleepState !== SleepState.Awake) {
         // The blocker's velocity change: −j·n linearly, I⁻¹(r × −j·n) angularly.
         const dv = j * inv_mb;
-        masked_inverse_inertia(blocker);
+        locked_inverse_inertia(_masked_inertia, 0, blocker);
         world_inverse_inertia_apply_raw(
             _inertia_scratch, 0,
             _masked_inertia[0], _masked_inertia[1], _masked_inertia[2],
@@ -1141,20 +1142,6 @@ function inverse_mass(rb) {
     return rb.mass > 0 ? 1 / rb.mass : 0;
 }
 
-/**
- * Write `rb`'s body-local inverse-inertia diagonal into {@link _masked_inertia}
- * with the `LockRot*` mask `PhysicsSystem#applyImpulseAt` (which applies the
- * impulse) and the solver gather use.
- *
- * @param {RigidBody} rb
- */
-function masked_inverse_inertia(rb) {
-    const ii = rb.inverseInertiaLocal;
-    const flags = rb.flags;
-    _masked_inertia[0] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
-    _masked_inertia[1] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
-    _masked_inertia[2] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
-}
 
 /**
  * One body's angular share of a normal impulse's effective mass at lever arm
@@ -1171,7 +1158,7 @@ function masked_inverse_inertia(rb) {
  * @returns {number}
  */
 function angular_term(rb, tr, rx, ry, rz, nx, ny, nz) {
-    masked_inverse_inertia(rb);
+    locked_inverse_inertia(_masked_inertia, 0, rb);
     return angular_effective_mass_raw(
         _masked_inertia[0], _masked_inertia[1], _masked_inertia[2],
         tr.rotation_x, tr.rotation_y, tr.rotation_z, tr.rotation_w,

package/src/engine/physics/cloth/build/cloth_proxy_from_joints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_proxy_from_joints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/build/cloth_proxy_from_joints.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,gDARW,MAAM,QACN,IAAI,eAEJ,MAAM,EAAE;IAES,IAAI,GAArB,MAAM;IACJ,qBAAqB,CA6QjC;qBA9UY,OAAO,qCAAqC,EAAE,MAAM;mBACpD,OAAO,8CAA8C,EAAE,IAAI;;;;;;;;WAwC1D,MAAM;;;;eACN,UAAU;;;;;;WAKV,UAAU,GAAC,IAAI;;;;YACf,eAAe,EAAE;;;;WACjB,MAAM;;2BAtDO,iBAAiB"}
+{"version":3,"file":"cloth_proxy_from_joints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/build/cloth_proxy_from_joints.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;;;;GAKG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;GAcG;AACH,gDARW,MAAM,QACN,IAAI,eAEJ,MAAM,EAAE;IAES,IAAI,GAArB,MAAM;IACJ,qBAAqB,CA8PjC;qBA/TY,OAAO,qCAAqC,EAAE,MAAM;mBACpD,OAAO,8CAA8C,EAAE,IAAI;;;;;;;;WAwC1D,MAAM;;;;eACN,UAAU;;;;;;WAKV,UAAU,GAAC,IAAI;;;;YACf,eAAe,EAAE;;;;WACjB,MAAM;;2BAtDO,iBAAiB"}

package/src/engine/physics/cloth/build/cloth_proxy_from_joints.js

@@ -1,3 +1,4 @@
+import { cloth_tree_pairs } from "../ecs/cloth_build_rows.js";
 import { ClothProxy } from "./ClothProxy.js";
 import { cloth_bind_in_frame, cloth_bind_scaled_above } from "./cloth_bind_in_frame.js";
 import { number_compare_ascending } from "../../../../core/primitives/numbers/number_compare_ascending.js";
@@ -302,22 +303,7 @@ export function cloth_proxy_from_joints(prefab, skin, joint_names, { name = "" }
 
     // A chain's fabric runs along its links, and it bends through the pair two
     // links apart.
-    const edge = [];
-    const skip = [];
-
-    for (let i = 0; i < particle_count; i++) {
-        const p = parent[i];
-
-        if (p < 0) {
-            continue;
-        }
-
-        edge.push(p, i);
-
-        if (parent[p] >= 0) {
-            skip.push(parent[p], i);
-        }
-    }
+    const { edge, skip } = cloth_tree_pairs(parent, particle_count);
 
     return {
         proxy: ClothProxy.from({

package/src/engine/physics/cloth/ecs/cloth_build_rows.d.ts

@@ -15,7 +15,19 @@ export function cloth_build_children(instance: ClothInstance): void;
  * @param {ClothInstance} instance with {@link ClothInstance#node_parent} set
  * @returns {void}
  */
-export function cloth_tree_graph(instance: ClothInstance): void;
+/**
+ * Build the fabric edge (`parent -> node`) and bending skip (`grandparent -> node`)
+ * index-pair arrays for a tree parent array.
+ *
+ * @param {ArrayLike<number>} parent
+ * @param {number} node_count
+ * @returns {{edge: number[], skip: number[]}}
+ */
+export function cloth_tree_pairs(parent: ArrayLike<number>, node_count: number): {
+    edge: number[];
+    skip: number[];
+};
+export function cloth_tree_graph(instance: any): void;
 /**
  * The triangles around each node, CSR, and one neighbour per node to measure a
  * tangent by — what `cloth_reconstruct_pose` turns a sheet's joints with. A

package/src/engine/physics/cloth/ecs/cloth_build_rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH,2DAFa,IAAI,CA6BhB;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CA4OhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AAzjBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}
+{"version":3,"file":"cloth_build_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/ecs/cloth_build_rows.js"],"names":[],"mappings":"AAqEA;;;;GAIG;AACH,+DAFa,IAAI,CAsBhB;AAED;;;;;;;;;;GAUG;AACH;;;;;;;GAOG;AACH,yCAJW,UAAU,MAAM,CAAC,cACjB,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAC,CAuB5C;AAED,sDAOC;AAED;;;;;;;;GAQG;AACH,8DAFa,IAAI,CAgDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,4CAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;;;;;;;GAaG;AACH,8DAHW,MAAM,GACJ,IAAI,CA4OhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kEAHW,MAAM,GACJ,IAAI,CAiEhB;AAED;;;;;;;;;;;GAWG;AACH,iGAFa,OAAO,CAkBnB;AApkBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;GAIG;AACH,kCAFU,MAAM,CAEwB;AAIxC;;;;;;;;;;;;;;;;;GAiBG;AACH,gCAFU,MAAM,CAEmB"}

package/src/engine/physics/cloth/ecs/cloth_build_rows.js

@@ -105,10 +105,15 @@ export function cloth_build_children(instance) {
  * @param {ClothInstance} instance with {@link ClothInstance#node_parent} set
  * @returns {void}
  */
-export function cloth_tree_graph(instance) {
-    const node_count = instance.node_count;
-    const parent = instance.node_parent;
-
+/**
+ * Build the fabric edge (`parent -> node`) and bending skip (`grandparent -> node`)
+ * index-pair arrays for a tree parent array.
+ *
+ * @param {ArrayLike<number>} parent
+ * @param {number} node_count
+ * @returns {{edge: number[], skip: number[]}}
+ */
+export function cloth_tree_pairs(parent, node_count) {
     const edge = [];
     const skip = [];
 
@@ -128,6 +133,12 @@ export function cloth_tree_graph(instance) {
         }
     }
 
+    return { edge, skip };
+}
+
+export function cloth_tree_graph(instance) {
+    const { edge, skip } = cloth_tree_pairs(instance.node_parent, instance.node_count);
+
     instance.edge = Int32Array.from(edge);
     instance.skip = Int32Array.from(skip);
     instance.hinge = new Int32Array(0);

package/src/engine/physics/ecs/PhysicsSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PhysicsSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/ecs/PhysicsSystem.js"],"names":[],"mappings":"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"}

package/src/engine/physics/ecs/PhysicsSystem.js

@@ -38,6 +38,7 @@ import { ContactEventBuffer, ContactEventKind } from "../events/ContactEventBuff
 import { diff_manifolds } from "../events/diff_manifolds.js";
 import { v3_add } from "../../../core/geom/vec3/v3_add.js";
 import { v3_set } from "../../../core/geom/vec3/v3_set.js";
+import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
 import { world_inverse_inertia_apply_raw } from "../inertia/world_inverse_inertia.js";
 import { integrate_position } from "../integration/integrate_position.js";
 import { integrate_velocity_forces, integrate_velocity_gravity } from "../integration/integrate_velocity.js";
@@ -1259,11 +1260,7 @@ export class PhysicsSystem extends System {
         // LockRot* masks the BODY-LOCAL inverse-inertia diagonal here exactly
         // as the solver gather does, so a user impulse cannot spin a locked
         // DOF either.
-        const flags = rigidBody.flags;
-        const ii = rigidBody.inverseInertiaLocal;
-        scratch_locked_inertia[0] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
-        scratch_locked_inertia[1] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
-        scratch_locked_inertia[2] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
+        locked_inverse_inertia(scratch_locked_inertia, 0, rigidBody);
         world_inverse_inertia_apply_raw(
             scratch_angular_delta, 0,
             scratch_locked_inertia[0], scratch_locked_inertia[1], scratch_locked_inertia[2],

package/src/engine/physics/inertia/locked_inverse_inertia.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Write `rb`'s body-local inverse-inertia diagonal into `out[out_offset .. out_offset + 2]`
+ * with axes locked by {@link RigidBodyFlags.LockRotX}, {@link RigidBodyFlags.LockRotY},
+ * or {@link RigidBodyFlags.LockRotZ} zeroed out.
+ *
+ * @param {number[]|Float64Array} out
+ * @param {number} out_offset
+ * @param {import("../ecs/RigidBody.js").RigidBody} rb
+ * @returns {number[]|Float64Array} `out`
+ */
+export function locked_inverse_inertia(out: number[] | Float64Array, out_offset: number, rb: import("../ecs/RigidBody.js").RigidBody): number[] | Float64Array;
+//# sourceMappingURL=locked_inverse_inertia.d.ts.map

package/src/engine/physics/inertia/locked_inverse_inertia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locked_inverse_inertia.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/inertia/locked_inverse_inertia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,4CALW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,MACN,OAAO,qBAAqB,EAAE,SAAS,GACrC,MAAM,EAAE,GAAC,YAAY,CAWjC"}

package/src/engine/physics/inertia/locked_inverse_inertia.js

@@ -0,0 +1,22 @@
+import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
+
+/**
+ * Write `rb`'s body-local inverse-inertia diagonal into `out[out_offset .. out_offset + 2]`
+ * with axes locked by {@link RigidBodyFlags.LockRotX}, {@link RigidBodyFlags.LockRotY},
+ * or {@link RigidBodyFlags.LockRotZ} zeroed out.
+ *
+ * @param {number[]|Float64Array} out
+ * @param {number} out_offset
+ * @param {import("../ecs/RigidBody.js").RigidBody} rb
+ * @returns {number[]|Float64Array} `out`
+ */
+export function locked_inverse_inertia(out, out_offset, rb) {
+    const flags = rb.flags;
+    const ii = rb.inverseInertiaLocal;
+
+    out[out_offset] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
+    out[out_offset + 1] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
+    out[out_offset + 2] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
+
+    return out;
+}

package/src/engine/physics/integration/integrate_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"integrate_velocity.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_velocity.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,8EALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA0DhB;AAED;;;;;;;;;;;;GAYG;AACH,qFAFW,MAAM,QAqDhB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CARW,YAAY,QACZ,MAAM,qBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkChB"}
+{"version":3,"file":"integrate_velocity.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/integration/integrate_velocity.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,8EALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA0DhB;AAED;;;;;;;;;;;;GAYG;AACH,qFAFW,MAAM,QAqDhB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CARW,YAAY,QACZ,MAAM,qBAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkChB"}

package/src/engine/physics/integration/integrate_velocity.js

@@ -1,6 +1,6 @@
 import { SBS_AV_X, SBS_AV_Y, SBS_AV_Z, SBS_LV_X, SBS_LV_Y, SBS_LV_Z, } from "../body/SolverBodyState.js";
 import { BodyKind } from "../ecs/BodyKind.js";
-import { RigidBodyFlags } from "../ecs/RigidBodyFlags.js";
+import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
 import { world_inverse_inertia_apply_raw } from "../inertia/world_inverse_inertia.js";
 
 const scratch_angular = new Float64Array(3);
@@ -11,21 +11,6 @@ const scratch_angular = new Float64Array(3);
 // apply, applied here so the torque/force accumulator path can't spin a locked DOF.
 const scratch_locked_inertia = new Float64Array(3);
 
-/**
- * @param {RigidBody} rb
- * @returns {Float64Array} the shared {@link scratch_locked_inertia}, filled with
- *   `rb.inverseInertiaLocal` masked by the body's LockRot* flags.
- */
-function locked_inverse_inertia(rb) {
-    const flags = rb.flags;
-    const ii = rb.inverseInertiaLocal;
-
-    scratch_locked_inertia[0] = (flags & RigidBodyFlags.LockRotX) !== 0 ? 0 : ii[0];
-    scratch_locked_inertia[1] = (flags & RigidBodyFlags.LockRotY) !== 0 ? 0 : ii[1];
-    scratch_locked_inertia[2] = (flags & RigidBodyFlags.LockRotZ) !== 0 ? 0 : ii[2];
-
-    return scratch_locked_inertia;
-}
 
 /**
  * Semi-implicit Euler velocity integration for a single rigid body.
@@ -99,7 +84,7 @@ export function integrate_velocity(rb, transform, gx, gy, gz, dt) {
     let avy = av[1];
     let avz = av[2];
     if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
-        const ii = locked_inverse_inertia(rb);
+        const ii = locked_inverse_inertia(scratch_locked_inertia, 0, rb);
         world_inverse_inertia_apply_raw(
             scratch_angular, 0,
             ii[0], ii[1], ii[2],
@@ -162,7 +147,7 @@ export function integrate_velocity_forces(rb, transform, dt) {
 
     if (at[0] !== 0 || at[1] !== 0 || at[2] !== 0) {
 
-        const ii = locked_inverse_inertia(rb);
+        const ii = locked_inverse_inertia(scratch_locked_inertia, 0, rb);
 
         world_inverse_inertia_apply_raw(
             scratch_angular, 0,

package/src/engine/physics/mls-mpm/MLS_MPM.d.ts

@@ -1,5 +1,6 @@
 export class MLS_MPMSolver {
     particles: any[];
+    boundary: number;
     /**
      * velocity + mass, node_res = cell_res + 1
      *

package/src/engine/physics/mls-mpm/MLS_MPM.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MLS_MPM.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/mls-mpm/MLS_MPM.js"],"names":[],"mappings":"AAcA;IACI,iBAAe;IAIX;;;;;OAKG;IACH,MAFU,YAAY,CAEiB;IAG3C;;;OAGG;IACH,YAFW,MAAM,QAuXhB;IAED;;;;;;;;;;;OAWG;IACH,uBALW,MAAM,EAAE,KACR,MAAM,gBACK,MAAM,UACjB,MAAM,QAgBhB;CACJ"}
+{"version":3,"file":"MLS_MPM.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/mls-mpm/MLS_MPM.js"],"names":[],"mappings":"AAcA;IACI,iBAAe;IACf,iBAAgB;IAIZ;;;;;OAKG;IACH,MAFU,YAAY,CAEiB;IAG3C;;;OAGG;IACH,YAFW,MAAM,QAuXhB;IAED;;;;;;;;;;;OAWG;IACH,uBALW,MAAM,EAAE,KACR,MAAM,gBACK,MAAM,UACjB,MAAM,QAgBhB;CACJ"}

package/src/engine/physics/mls-mpm/MLS_MPM.js

@@ -13,7 +13,8 @@ import { m2_svd } from "../../../core/math/linalg/m2/m2_svd.js";
 const dimensions = 2;
 
 export class MLS_MPMSolver {
-    particles = [];
+    particles = [];
+    boundary = 0.05;
 
     constructor() {
         const d = n + 1;
@@ -189,7 +190,7 @@ export class MLS_MPMSolver {
                 const grid_y = base_coordinate_y + j;
 
 
-                if (grid_y < 0 || grid_y >= n) {
+                if (grid_y < 0 || grid_y >= grid_height) {
                     continue;
                 }
 
@@ -200,7 +201,7 @@ export class MLS_MPMSolver {
                 for (let i = 0; i < 3; i++) {
                     const grid_x = base_coordinate_x + i;
 
-                    if (grid_x < 0 || grid_x >= n) {
+                    if (grid_x < 0 || grid_x >= grid_width) {
                         continue;
                     }
 
@@ -223,7 +224,7 @@ export class MLS_MPMSolver {
         }
 
         // Modify grid velocities to respect boundaries
-        const boundary = 0.05;
+        const boundary = this.boundary;
 
         for (let j = 0; j < grid_height; j++) {
 

package/src/engine/physics/narrowphase/convex_decomposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA4CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH,oEAFa;IAAC,MAAM,EAAE,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAmHnI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC,GAEzC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAC,CAgG5G;AAzPD,kCAAiF;oBAvC7D,gCAAgC"}
+{"version":3,"file":"convex_decomposition.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_decomposition.js"],"names":[],"mappings":"AA+CA;;;;;;;;;GASG;AACH,4BALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;GAGG;AACH,oEAFa;IAAC,MAAM,EAAE,MAAM;QAAC,QAAQ,EAAC,YAAY,CAAC;QAAC,YAAY,EAAC,WAAW,CAAC;QAAC,UAAU,EAAC,WAAW,CAAC;QAAC,IAAI,EAAC,YAAY,CAAA;KAAC,CAAC,CAAC;IAAC,GAAG,EAAE,GAAG,CAAA;CAAC,CAmHnI;AAED;;;;;;;;;;;;;GAaG;AACH,gCAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAElC,IAAI,MAAM,EAAE;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,CAAC,GAEzC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,YAAY,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAC,CAoF5G;AA9OD,kCAAiF;oBAzC7D,gCAAgC"}

package/src/engine/physics/narrowphase/convex_decomposition.js

@@ -1,7 +1,9 @@
 import { BVH } from "../../../core/bvh2/bvh3/BVH.js";
 import { tri3_compute_normal } from "../../../core/geom/3d/triangle/tri3_compute_normal.js";
 import { tetrahedral_mesh_get_neighbours } from "../../../core/geom/3d/tetrahedra/tetrahedral_mesh_get_neighbours.js";
+import { aabb3_from_v3_array } from "../../../core/geom/3d/aabb/aabb3_from_v3_array.js";
 import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
+import { v3_orthonormal_matrix_from_normal } from "../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 
 /**
  * Greedy convex decomposition of a tetrahedralised mesh into a small set of
@@ -41,6 +43,7 @@ export const FACE_OPP = [[1, 2, 3, 0], [0, 2, 3, 1], [0, 1, 3, 2], [0, 1, 2, 3]]
 
 // Reusable scratch for tri3_compute_normal (writes a unit normal as 3 floats).
 const _face_normal = new Float64Array(3);
+const _face_basis = new Float64Array(9);
 
 /**
  * Exact, collision-free, order-independent key for a triangle's vertex triple:
@@ -237,14 +240,9 @@ export function build_piece(tp, boundary) {
         const inv = 1 / varr.length; cx *= inv; cy *= inv; cz *= inv;
 
         // In-plane basis (u, v=n×u) from the outward normal n.
-        const nx = g.nx, ny = g.ny, nz = g.nz;
-        let ux, uy, uz;
-        const ax = Math.abs(nx), ay = Math.abs(ny), az = Math.abs(nz);
-        if (ax <= ay && ax <= az) { ux = 0; uy = -nz; uz = ny; }
-        else if (ay <= az) { ux = -nz; uy = 0; uz = nx; }
-        else { ux = -ny; uy = nx; uz = 0; }
-        const ul = Math.hypot(ux, uy, uz) || 1; ux /= ul; uy /= ul; uz /= ul;
-        const vx = ny * uz - nz * uy, vy = nz * ux - nx * uz, vz = nx * uy - ny * ux;
+        v3_orthonormal_matrix_from_normal(_face_basis, 0, g.nx, g.ny, g.nz);
+        const ux = _face_basis[0], uy = _face_basis[1], uz = _face_basis[2];
+        const vx = _face_basis[3], vy = _face_basis[4], vz = _face_basis[5];
 
         const items = varr.map((gv) => {
             const dx = tp[gv * 3] - cx, dy = tp[gv * 3 + 1] - cy, dz = tp[gv * 3 + 2] - cz;
@@ -276,14 +274,7 @@ export function build_piece(tp, boundary) {
 
     const vertices = new Float32Array(verts);
     const aabb = new Float64Array(6);
-    let mnx = Infinity, mny = Infinity, mnz = Infinity, mxx = -Infinity, mxy = -Infinity, mxz = -Infinity;
-    for (let i = 0; i < vertices.length / 3; i++) {
-        const x = vertices[i * 3], y = vertices[i * 3 + 1], z = vertices[i * 3 + 2];
-        if (x < mnx) mnx = x; if (x > mxx) mxx = x;
-        if (y < mny) mny = y; if (y > mxy) mxy = y;
-        if (z < mnz) mnz = z; if (z > mxz) mxz = z;
-    }
-    aabb[0] = mnx; aabb[1] = mny; aabb[2] = mnz; aabb[3] = mxx; aabb[4] = mxy; aabb[5] = mxz;
+    aabb3_from_v3_array(aabb, vertices, vertices.length);
 
     return { vertices, face_offsets, face_loops: new Uint32Array(loop_flat), aabb };
 }

package/src/engine/physics/vehicle/RaycastVehicle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RaycastVehicle.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/vehicle/RaycastVehicle.js"],"names":[],"mappings":"AA8EA;;;;GAIG;AACH;IAEI,8DAA8D;IAC9D,eAD8C,YAAY,CACtB;IAEpC,8EAA8E;IAC9E,oBAD8D,YAAY,CACvB;IAEnD,sEAAsE;IACtE,cADsD,YAAY,CACtB;IAE5C,4BAA0B;IAC1B,0BAAuB;IACvB,2BAA8B;IAC9B,eAAa;IACb,iBAAe;IACf,iBAAgB;IAChB,gBAAe;IAGf,mBAAkB;IAElB,oBAAgB;IAEhB,gDAAgD;IAChD,cADgC,YAAY,CACT;IAEnC,iDAAiD;IACjD,eADiC,YAAY,CACA;IAE7C,qDAAqD;IACrD,sBAAmB;IAEnB,gFAAgF;IAChF,iBAAa;IAEb,kDAAkD;IAClD,iBAAa;IAEb,iDAAiD;IACjD,qBAAiB;IAEjB,yDAAyD;IACzD,wBAAoB;IAGhB,6BAA+B;IAC/B,yBAAiD;CAExD;AAED;IAoBI;;;;OAIG;IACH,0FAOC;IA/BD,sBAAsB;IACtB,QADW,KAAK,EAAE,CACN;IAEZ,qBAAiB;IACjB,qBAAiB;IACjB,sBAAkB;IAClB,YAAmB;IACnB,2BAAkC;IAGlC,sBAA8B;IAE9B;;;;OAIG;IACH,SAFU,YAAY,CAEQ;IAQ1B,sBAAoB;IACpB,uBAA8B;IAC9B,8BAAwC;IAGxC,kDAAmF;IAGvF;;;;;;;;;;;;;;;;;OAiBG;IACH;QAb0B,aAAa,EAA5B,MAAM,EAAE;QACQ,kBAAkB,GAAlC,MAAM,EAAE;QACQ,YAAY,GAA5B,MAAM,EAAE;QACM,oBAAoB,GAAlC,MAAM;QACQ,mBAAmB,GAAjC,MAAM;QACQ,iBAAiB,GAA/B,MAAM;QACQ,kBAAkB,GAAhC,MAAM;QACQ,MAAM,GAApB,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACS,OAAO,GAAtB,OAAO;QACQ,MAAM,GAArB,OAAO;QACL,KAAK,CA0BjB;IAED,2DAA2D;IAC3D,8BAIC;IAED,2EAA2E;IAC3E,gCAAmD;IAEnD,uEAAuE;IACvE,2BAA8C;IAE9C;;;;;OAKG;IACH,WAFW,MAAM,QAsIhB;CACJ;qBA5WoB,mCAAmC;oCACpB,mCAAmC"}
+{"version":3,"file":"RaycastVehicle.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/vehicle/RaycastVehicle.js"],"names":[],"mappings":"AAmFA;;;;GAIG;AACH;IAEI,8DAA8D;IAC9D,eAD8C,YAAY,CACtB;IAEpC,8EAA8E;IAC9E,oBAD8D,YAAY,CACvB;IAEnD,sEAAsE;IACtE,cADsD,YAAY,CACtB;IAE5C,4BAA0B;IAC1B,0BAAuB;IACvB,2BAA8B;IAC9B,eAAa;IACb,iBAAe;IACf,iBAAgB;IAChB,gBAAe;IAGf,mBAAkB;IAElB,oBAAgB;IAEhB,gDAAgD;IAChD,cADgC,YAAY,CACT;IAEnC,iDAAiD;IACjD,eADiC,YAAY,CACA;IAE7C,qDAAqD;IACrD,sBAAmB;IAEnB,gFAAgF;IAChF,iBAAa;IAEb,kDAAkD;IAClD,iBAAa;IAEb,iDAAiD;IACjD,qBAAiB;IAEjB,yDAAyD;IACzD,wBAAoB;IAGhB,6BAA+B;IAC/B,yBAAiD;CAExD;AAED;IAoBI;;;;OAIG;IACH,0FAOC;IA/BD,sBAAsB;IACtB,QADW,KAAK,EAAE,CACN;IAEZ,qBAAiB;IACjB,qBAAiB;IACjB,sBAAkB;IAClB,YAAmB;IACnB,2BAAkC;IAGlC,sBAA8B;IAE9B;;;;OAIG;IACH,SAFU,YAAY,CAEQ;IAQ1B,sBAAoB;IACpB,uBAA8B;IAC9B,8BAAwC;IAGxC,kDAAmF;IAGvF;;;;;;;;;;;;;;;;;OAiBG;IACH;QAb0B,aAAa,EAA5B,MAAM,EAAE;QACQ,kBAAkB,GAAlC,MAAM,EAAE;QACQ,YAAY,GAA5B,MAAM,EAAE;QACM,oBAAoB,GAAlC,MAAM;QACQ,mBAAmB,GAAjC,MAAM;QACQ,iBAAiB,GAA/B,MAAM;QACQ,kBAAkB,GAAhC,MAAM;QACQ,MAAM,GAApB,MAAM;QACQ,QAAQ,GAAtB,MAAM;QACS,OAAO,GAAtB,OAAO;QACQ,MAAM,GAArB,OAAO;QACL,KAAK,CA0BjB;IAED,2DAA2D;IAC3D,8BAIC;IAED,2EAA2E;IAC3E,gCAAmD;IAEnD,uEAAuE;IACvE,2BAA8C;IAE9C;;;;;OAKG;IACH,WAFW,MAAM,QA2IhB;CACJ;qBAtXoB,mCAAmC;oCACpB,mCAAmC"}

package/src/engine/physics/vehicle/RaycastVehicle.js

@@ -4,7 +4,8 @@ import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply
 import { v3_set } from "../../../core/geom/vec3/v3_set.js";
 import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { angular_effective_mass_raw } from "../inertia/world_inverse_inertia.js";
-import { BodyKind } from "../ecs/BodyKind.js";
+import { BodyKind } from "../ecs/BodyKind.js";
+import { locked_inverse_inertia } from "../inertia/locked_inverse_inertia.js";
 
 /**
  * # Raycast vehicle controller
@@ -39,6 +40,7 @@ import { BodyKind } from "../ecs/BodyKind.js";
 
 const scratch_v = new Float64Array(3);
 const scratch_i = new Float64Array(3);
+const scratch_ii = new Float64Array(3);
 
 /**
  * Effective mass denominator for a unit-direction velocity constraint at a
@@ -49,10 +51,13 @@ const scratch_i = new Float64Array(3);
  */
 function effective_mass(rb, transform, invM, rx, ry, rz, dx, dy, dz) {
     let k = invM;
-    const ii = rb.inverseInertiaLocal;
-    if (ii[0] !== 0 || ii[1] !== 0 || ii[2] !== 0) {
+    locked_inverse_inertia(scratch_ii, 0, rb);
+    const iix = scratch_ii[0];
+    const iiy = scratch_ii[1];
+    const iiz = scratch_ii[2];
+    if (iix !== 0 || iiy !== 0 || iiz !== 0) {
         k += angular_effective_mass_raw(
-            ii[0], ii[1], ii[2],
+            iix, iiy, iiz,
             transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w,
             rx, ry, rz,
             dx, dy, dz,
@@ -237,7 +242,12 @@ export class RaycastVehicle {
         const qx = tr.rotation_x, qy = tr.rotation_y, qz = tr.rotation_z, qw = tr.rotation_w;
         const px = tr.translation_x, py = tr.translation_y, pz = tr.translation_z;
         const lv = rb.linearVelocity, av = rb.angularVelocity;
-        const drivePer = this.__drivenCount > 0 ? this.__driveForce / this.__drivenCount : 0;
+        let drivenCount = 0;
+        for (let i = 0; i < this.wheels.length; i++) {
+            if (this.wheels[i].driven) drivenCount++;
+        }
+        this.__drivenCount = drivenCount;
+        const drivePer = drivenCount > 0 ? this.__driveForce / drivenCount : 0;
 
         for (let wi = 0; wi < this.wheels.length; wi++) {
             const w = this.wheels[wi];

package/src/engine/save/StorageBackedList.d.ts

@@ -2,6 +2,11 @@
  * @template T
  */
 export class StorageBackedSet<T> {
+    /**
+     * @param {Storage} [storage]
+     * @param {string} [key]
+     */
+    constructor(storage?: Storage, key?: string);
     /**
      *
      * @type {string}

package/src/engine/save/StorageBackedList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StorageBackedList.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/StorageBackedList.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAEI;;;OAGG;IACH,KAFU,MAAM,CAEP;IACT;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,oBAAgC;IAGhC;;;;;OAKG;IACH;QAH2B,GAAG,EAAnB,MAAM;QACW,OAAO,EAAxB,OAAO;aAQjB;IAED;;;OAGG;IACH,QAFY,QAAQ,CAAC,EAAE,CAAC,CAiCvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACA,QAAQ,CAAC,EAAE,CAAC,CAoBvB;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACA,QAAQ,OAAO,CAAC,CAU3B;IAGD;;;OAGG;IACH,cAHW,CAAC,GACC,QAAQ,OAAO,CAAC,CAqB5B;CACJ"}
+{"version":3,"file":"StorageBackedList.d.ts","sourceRoot":"","sources":["../../../../src/engine/save/StorageBackedList.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAmBI;;;OAGG;IACH,sBAHW,OAAO,QACP,MAAM,EAMhB;IAzBD;;;OAGG;IACH,KAFU,MAAM,CAEP;IACT;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,oBAAgC;IAYhC;;;;;OAKG;IACH;QAH2B,GAAG,EAAnB,MAAM;QACW,OAAO,EAAxB,OAAO;aAQjB;IAED;;;OAGG;IACH,QAFY,QAAQ,CAAC,EAAE,CAAC,CAyCvB;IAED;;;;OAIG;IACH,WAHW,CAAC,GACA,QAAQ,CAAC,EAAE,CAAC,CAoBvB;IAED;;;;OAIG;IACH,gBAHW,CAAC,GACA,QAAQ,OAAO,CAAC,CAU3B;IAGD;;;OAGG;IACH,cAHW,CAAC,GACC,QAAQ,OAAO,CAAC,CAqB5B;CACJ"}