babylon-box3d 0.1.0 → 0.2.0

package/umd/babylon.box3d.js

@@ -0,0 +1,2602 @@
+/* babylon-box3d 0.2.0 | MIT | https://github.com/Pryme8/babylon-box3d */
+"use strict";
+var BABYLONBOX3D = (() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // babylon-global:@babylonjs/core/Maths/math.vector.js
+  var require_math_vector = __commonJS({
+    "babylon-global:@babylonjs/core/Maths/math.vector.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Physics/v2/IPhysicsEnginePlugin.js
+  var require_IPhysicsEnginePlugin = __commonJS({
+    "babylon-global:@babylonjs/core/Physics/v2/IPhysicsEnginePlugin.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Physics/physicsRaycastResult.js
+  var require_physicsRaycastResult = __commonJS({
+    "babylon-global:@babylonjs/core/Physics/physicsRaycastResult.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Misc/logger.js
+  var require_logger = __commonJS({
+    "babylon-global:@babylonjs/core/Misc/logger.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Culling/boundingBox.js
+  var require_boundingBox = __commonJS({
+    "babylon-global:@babylonjs/core/Culling/boundingBox.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Meshes/mesh.js
+  var require_mesh = __commonJS({
+    "babylon-global:@babylonjs/core/Meshes/mesh.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Meshes/instancedMesh.js
+  var require_instancedMesh = __commonJS({
+    "babylon-global:@babylonjs/core/Meshes/instancedMesh.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Buffers/buffer.js
+  var require_buffer = __commonJS({
+    "babylon-global:@babylonjs/core/Buffers/buffer.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // babylon-global:@babylonjs/core/Misc/observable.js
+  var require_observable = __commonJS({
+    "babylon-global:@babylonjs/core/Misc/observable.js"(exports, module) {
+      if (typeof BABYLON === "undefined") {
+        throw new Error("babylon.box3d.js needs babylon.js loaded first");
+      }
+      module.exports = BABYLON;
+    }
+  });
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    BOX3D_HEIGHT_FIELD_HOLE: () => BOX3D_HEIGHT_FIELD_HOLE,
+    Box3D: () => wasm_default,
+    Box3DPlugin: () => Box3DPlugin,
+    Box3DWheelJoint: () => Box3DWheelJoint
+  });
+
+  // src/box3dPlugin.ts
+  var import_math_vector = __toESM(require_math_vector(), 1);
+  var import_IPhysicsEnginePlugin = __toESM(require_IPhysicsEnginePlugin(), 1);
+  var import_physicsRaycastResult = __toESM(require_physicsRaycastResult(), 1);
+  var import_logger = __toESM(require_logger(), 1);
+  var import_boundingBox = __toESM(require_boundingBox(), 1);
+  var import_mesh = __toESM(require_mesh(), 1);
+  var import_instancedMesh = __toESM(require_instancedMesh(), 1);
+  var import_buffer = __toESM(require_buffer(), 1);
+  var import_observable = __toESM(require_observable(), 1);
+  var BOX3D_HEIGHT_FIELD_HOLE = 255;
+  var Box3DBodyData = class {
+    constructor(slot) {
+      this.slot = slot;
+      this.userMassProps = {};
+      /** Box3D angular motion locks currently set on the body, bits x, y, z */
+      this.angularLocks = 0;
+      /** Havok's EventType bits: 1 collision started, 2 collision continued, 4 collision finished */
+      this.eventMask = 0;
+      this.motionType = import_IPhysicsEnginePlugin.PhysicsMotionType.STATIC;
+      /** Babylon activation control; ALWAYS_INACTIVE parks the body as a static Box3D body, see setActivationControl */
+      this.activation = import_IPhysicsEnginePlugin.PhysicsActivationControl.SIMULATION_CONTROLLED;
+    }
+  };
+  var Box3DShapeData = class {
+    constructor(slot, type) {
+      this.slot = slot;
+      this.type = type;
+      this.material = {};
+      /** bodies currently instantiating this shape, refreshed when the description changes */
+      this.users = /* @__PURE__ */ new Set();
+      /** for containers: child shapes, so changes propagate to users */
+      this.children = [];
+      this.parents = /* @__PURE__ */ new Set();
+    }
+  };
+  var Box3DConstraintData = class {
+    constructor() {
+      this.joints = [];
+      this.pairs = [];
+      this.type = import_IPhysicsEnginePlugin.PhysicsConstraintType.LOCK;
+      this.jointType = 0;
+      this.enabled = true;
+      this.collisions = false;
+      this.frames = new Float32Array(14);
+      this.length = 0;
+      this.axes = /* @__PURE__ */ new Map();
+      /** SIX_DOF only */
+      this.plan = null;
+    }
+  };
+  var Box3DWheelJoint = class {
+    /**
+     * @internal
+     */
+    constructor(_plugin, _slot) {
+      this._plugin = _plugin;
+      this._slot = _slot;
+    }
+    /**
+     * Sets the target angular speed of the spin motor.
+     * @param speed radians per second
+     */
+    setSpinSpeed(speed) {
+      this._plugin._wheelCall("_bx_WheelJoint_SetSpinMotorSpeed", this._slot, speed);
+    }
+    /**
+     * Sets the maximum torque the spin motor can apply.
+     * @param torque newton meters
+     */
+    setMaxSpinTorque(torque) {
+      this._plugin._wheelCall("_bx_WheelJoint_SetMaxSpinTorque", this._slot, torque);
+    }
+    /**
+     * Enables or disables the spin motor (disabled wheels roll freely).
+     * @param enabled true to enable
+     */
+    enableSpinMotor(enabled) {
+      this._plugin._wheelCall("_bx_WheelJoint_EnableSpinMotor", this._slot, enabled ? 1 : 0);
+    }
+    /**
+     * Sets the target steering angle.
+     * @param radians steering angle
+     */
+    setSteeringAngle(radians) {
+      this._plugin._wheelCall("_bx_WheelJoint_SetTargetSteeringAngle", this._slot, radians);
+    }
+    /**
+     * Tunes the suspension spring.
+     * @param hertz stiffness
+     * @param dampingRatio damping ratio
+     */
+    setSuspension(hertz, dampingRatio) {
+      this._plugin._wheelCall("_bx_WheelJoint_SetSuspension", this._slot, hertz, dampingRatio);
+    }
+    /**
+     * Removes the joint.
+     */
+    dispose() {
+      this._plugin._destroyExtraJoint(this._slot);
+      this._slot = 0;
+    }
+  };
+  var LockedInertiaRatio = 1e5;
+  function DiagonalizeInertia(tensor, moments, orientation) {
+    const a = [
+      [tensor[0], tensor[3], tensor[4]],
+      [tensor[3], tensor[1], tensor[5]],
+      [tensor[4], tensor[5], tensor[2]]
+    ];
+    orientation.set(0, 0, 0, 1);
+    moments.set(tensor[0], tensor[1], tensor[2]);
+    const q = [0, 0, 0, 1];
+    for (let sweep = 0; sweep < 24; sweep++) {
+      const [x, y, z, w] = q;
+      const r = [
+        [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+        [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+        [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)]
+      ];
+      const d = [0, 1, 2].map((i) => [0, 1, 2].map((j) => [0, 1, 2].reduce((sum, k3) => sum + r[k3][i] * [0, 1, 2].reduce((s2, l) => s2 + a[k3][l] * r[l][j], 0), 0)));
+      moments.set(d[0][0], d[1][1], d[2][2]);
+      orientation.set(q[0], q[1], q[2], q[3]);
+      const offDiagonal = [Math.abs(d[1][2]), Math.abs(d[0][2]), Math.abs(d[0][1])];
+      const k = offDiagonal.indexOf(Math.max(...offDiagonal));
+      const k1 = (k + 1) % 3;
+      const k2 = (k + 2) % 3;
+      const off = d[k1][k2];
+      const scale = Math.abs(d[0][0]) + Math.abs(d[1][1]) + Math.abs(d[2][2]) + 1e-30;
+      if (Math.abs(off) <= 1e-9 * scale) {
+        return;
+      }
+      let theta = (d[k2][k2] - d[k1][k1]) / (2 * off);
+      const sign = theta > 0 ? 1 : -1;
+      theta *= sign;
+      const t = sign / (theta + (theta < 1e6 ? Math.sqrt(theta * theta + 1) : theta));
+      const c = 1 / Math.sqrt(t * t + 1);
+      if (c === 1) {
+        return;
+      }
+      const jacobi = [0, 0, 0, 0];
+      jacobi[k] = -sign * Math.sqrt((1 - c) / 2);
+      jacobi[3] = Math.sqrt(1 - jacobi[k] * jacobi[k]);
+      const [qx, qy, qz, qw] = q;
+      const [jx, jy, jz, jw] = jacobi;
+      q[0] = qw * jx + qx * jw + qy * jz - qz * jy;
+      q[1] = qw * jy - qx * jz + qy * jw + qz * jx;
+      q[2] = qw * jz + qx * jy - qy * jx + qz * jw;
+      q[3] = qw * jw - qx * jx - qy * jy - qz * jz;
+      const length = Math.hypot(q[0], q[1], q[2], q[3]) || 1;
+      for (let i = 0; i < 4; i++) {
+        q[i] /= length;
+      }
+    }
+  }
+  function ComposeInertia(moments, orientation) {
+    const { x, y, z, w } = orientation;
+    const r = [
+      [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+      [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+      [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)]
+    ];
+    const at = (i, j) => r[i][0] * moments[0] * r[j][0] + r[i][1] * moments[1] * r[j][1] + r[i][2] * moments[2] * r[j][2];
+    return [at(0, 0), at(1, 1), at(2, 2), at(0, 1), at(0, 2), at(1, 2)];
+  }
+  var MOVE_STRIDE = 9;
+  var CONTACT_STRIDE = 12;
+  var SENSOR_STRIDE = 5;
+  var RAY_STRIDE = 11;
+  var MeshGeometryAccumulator = class {
+    constructor(_collectIndices, _flipWinding) {
+      this._collectIndices = _collectIndices;
+      this._flipWinding = _flipWinding;
+      this._vertices = [];
+      this._indices = [];
+    }
+    addNodeMeshes(mesh, includeChildren) {
+      mesh.computeWorldMatrix(true);
+      const rootScaled = import_math_vector.TmpVectors.Matrix[0];
+      import_math_vector.Matrix.ScalingToRef(mesh.absoluteScaling.x, mesh.absoluteScaling.y, mesh.absoluteScaling.z, rootScaled);
+      if (mesh instanceof import_mesh.Mesh) {
+        this._addMesh(mesh, rootScaled);
+      } else if (mesh instanceof import_instancedMesh.InstancedMesh) {
+        this._addMesh(mesh.sourceMesh, rootScaled);
+      }
+      if (includeChildren) {
+        const worldToRoot = import_math_vector.TmpVectors.Matrix[1];
+        mesh.computeWorldMatrix().invertToRef(worldToRoot);
+        const worldToRootScaled = import_math_vector.TmpVectors.Matrix[2];
+        worldToRoot.multiplyToRef(rootScaled, worldToRootScaled);
+        const children = mesh.getChildMeshes(false).filter((m) => !m.physicsBody);
+        for (const m of children) {
+          const childToWorld = m.computeWorldMatrix();
+          const childToRootScaled = import_math_vector.TmpVectors.Matrix[3];
+          childToWorld.multiplyToRef(worldToRootScaled, childToRootScaled);
+          if (m instanceof import_mesh.Mesh) {
+            this._addMesh(m, childToRootScaled);
+          } else if (m instanceof import_instancedMesh.InstancedMesh) {
+            this._addMesh(m.sourceMesh, childToRootScaled);
+          }
+        }
+      }
+    }
+    _addMesh(mesh, meshToRoot) {
+      const vertexData = mesh.getVerticesData(import_buffer.VertexBuffer.PositionKind) || [];
+      const numVerts = vertexData.length / 3;
+      const indexOffset = this._vertices.length / 3;
+      const p = import_math_vector.TmpVectors.Vector3[0];
+      for (let v = 0; v < numVerts; v++) {
+        p.set(vertexData[v * 3 + 0], vertexData[v * 3 + 1], vertexData[v * 3 + 2]);
+        import_math_vector.Vector3.TransformCoordinatesToRef(p, meshToRoot, p);
+        this._vertices.push(p.x, p.y, p.z);
+      }
+      if (this._collectIndices) {
+        const meshIndices = mesh.getIndices();
+        if (meshIndices) {
+          for (let i = 0; i < meshIndices.length; i += 3) {
+            if (this._flipWinding) {
+              this._indices.push(meshIndices[i + 2] + indexOffset, meshIndices[i + 1] + indexOffset, meshIndices[i + 0] + indexOffset);
+            } else {
+              this._indices.push(meshIndices[i + 0] + indexOffset, meshIndices[i + 1] + indexOffset, meshIndices[i + 2] + indexOffset);
+            }
+          }
+        }
+      }
+    }
+    get vertexCount() {
+      return this._vertices.length / 3;
+    }
+    get triangleCount() {
+      return this._indices.length / 3;
+    }
+    get vertices() {
+      return this._vertices;
+    }
+    get indices() {
+      return this._indices;
+    }
+  };
+  var RequiredNativeExports = [
+    "_bx_Body_AllowFastRotation",
+    "_bx_Body_ApplyAngularImpulse",
+    "_bx_Body_ApplyForce",
+    "_bx_Body_ApplyLinearImpulse",
+    "_bx_Body_ApplyMassFromShapes",
+    "_bx_Body_ApplyTorque",
+    "_bx_Body_ComputeShapeMassData",
+    "_bx_Body_EnableSleep",
+    "_bx_Body_GetAABB",
+    "_bx_Body_GetAngularDamping",
+    "_bx_Body_GetAngularVelocity",
+    "_bx_Body_GetGravityScale",
+    "_bx_Body_GetLinearDamping",
+    "_bx_Body_GetLinearVelocity",
+    "_bx_Body_GetMassData",
+    "_bx_Body_GetTransform",
+    "_bx_Body_SetAngularDamping",
+    "_bx_Body_SetAngularVelocity",
+    "_bx_Body_SetAwake",
+    "_bx_Body_SetEventFlags",
+    "_bx_Body_SetGravityScale",
+    "_bx_Body_SetLinearDamping",
+    "_bx_Body_SetLinearVelocity",
+    "_bx_Body_SetMassDataFull",
+    "_bx_Body_SetMotionLocks",
+    "_bx_Body_SetShape",
+    "_bx_Body_SetTargetTransform",
+    "_bx_Body_SetTransform",
+    "_bx_Body_SetType",
+    "_bx_Body_SyncShapeDesc",
+    "_bx_ComputeAlignedFrameB",
+    "_bx_ContactEventsPtr",
+    "_bx_CreateBody",
+    "_bx_CreateJoint",
+    "_bx_CreateWorld",
+    "_bx_DebugIndexCount",
+    "_bx_DebugIndicesPtr",
+    "_bx_DebugPositionsPtr",
+    "_bx_DestroyBody",
+    "_bx_DestroyJoint",
+    "_bx_DestroyWorld",
+    "_bx_GetRejectedSlotCount",
+    "_bx_Joint_EnableLimit",
+    "_bx_Joint_EnableMotor",
+    "_bx_Joint_EnableSpring",
+    "_bx_Joint_IsValid",
+    "_bx_Joint_SetCollideConnected",
+    "_bx_Joint_SetConstraintTuning",
+    "_bx_Joint_SetLimits",
+    "_bx_Joint_SetMaxMotorForce",
+    "_bx_Joint_SetMotorSpeed",
+    "_bx_Joint_SetSphericalMotor",
+    "_bx_Joint_SetSphericalTarget",
+    "_bx_Joint_SetSpring",
+    "_bx_Joint_SetTarget",
+    "_bx_Joint_SetTwistLimits",
+    "_bx_Joint_UpdateMotorFrame",
+    "_bx_Joint_WakeBodies",
+    "_bx_MoveEventsPtr",
+    "_bx_RayHitsPtr",
+    "_bx_Scratch",
+    "_bx_SensorEventsPtr",
+    "_bx_ShapeDesc_AddChild",
+    "_bx_ShapeDesc_BuildDebugGeometry",
+    "_bx_ShapeDesc_CreateBox",
+    "_bx_ShapeDesc_CreateCapsule",
+    "_bx_ShapeDesc_CreateContainer",
+    "_bx_ShapeDesc_CreateCylinder",
+    "_bx_ShapeDesc_CreateHeightField",
+    "_bx_ShapeDesc_CreateHull",
+    "_bx_ShapeDesc_CreateMesh",
+    "_bx_ShapeDesc_CreateSphere",
+    "_bx_ShapeDesc_Destroy",
+    "_bx_ShapeDesc_GetAABB",
+    "_bx_ShapeDesc_GetCategoryBits",
+    "_bx_ShapeDesc_GetChildCount",
+    "_bx_ShapeDesc_GetDensity",
+    "_bx_ShapeDesc_GetFriction",
+    "_bx_ShapeDesc_GetMaskBits",
+    "_bx_ShapeDesc_GetRestitution",
+    "_bx_ShapeDesc_RemoveChild",
+    "_bx_ShapeDesc_SetDensity",
+    "_bx_ShapeDesc_SetFilter",
+    "_bx_ShapeDesc_SetGroup",
+    "_bx_ShapeDesc_SetMaterial",
+    "_bx_ShapeDesc_SetRollingResistance",
+    "_bx_ShapeDesc_SetSensor",
+    "_bx_World_CastRay",
+    "_bx_World_EnableContinuous",
+    "_bx_World_EnableSleeping",
+    "_bx_World_Explode",
+    "_bx_World_GetContactEvents",
+    "_bx_World_GetMaximumLinearSpeed",
+    "_bx_World_GetMoveEvents",
+    "_bx_World_GetSensorEvents",
+    "_bx_World_GetStats",
+    "_bx_World_SetGravity",
+    "_bx_World_SetMaximumLinearSpeed",
+    "_bx_World_Step"
+  ];
+  var Box3DPlugin = class {
+    /**
+     * Creates a Box3D plugin.
+     * @param _useDeltaForWorldStep step the world with the frame delta (true) or a fixed time step (false)
+     * @param box3dModule the resolved Box3D WASM module (await Box3DModule())
+     */
+    constructor(_useDeltaForWorldStep = true, box3dModule) {
+      this._useDeltaForWorldStep = _useDeltaForWorldStep;
+      /** Name of the plugin */
+      this.name = "Box3DPlugin";
+      /** Number of solver sub steps per world step. Box3D recommends 4. */
+      this.subStepCount = 4;
+      /** Wall clock time of the last world step in milliseconds (JavaScript side, includes the event sync). */
+      this.lastStepTimeMs = 0;
+      this._worldSlot = 0;
+      this._fixedTimeStep = 1 / 60;
+      this._timeStep = 1 / 60;
+      this._maxAngularVelocity = 4 * Math.PI * 10;
+      this._bodies = [];
+      this._shapes = [];
+      this._bodyCollisionObservable = /* @__PURE__ */ new Map();
+      this._bodyCollisionEndedObservable = /* @__PURE__ */ new Map();
+      this._touchedInstanceMeshes = /* @__PURE__ */ new Set();
+      /** spherical joints whose velocity motor target has to be re-expressed in world space every step */
+      this._motorJoints = /* @__PURE__ */ new Set();
+      this._tmpVec3 = [new import_math_vector.Vector3(), new import_math_vector.Vector3(), new import_math_vector.Vector3(), new import_math_vector.Vector3()];
+      this._tmpQuat = [new import_math_vector.Quaternion(), new import_math_vector.Quaternion(), new import_math_vector.Quaternion()];
+      this._warned = /* @__PURE__ */ new Set();
+      /** the shim's rejected slot counter as of the last step, see executeStep */
+      this._rejectedSlots = 0;
+      /** Observable for collision started and continued events */
+      this.onCollisionObservable = new import_observable.Observable();
+      /** Observable for collision ended events */
+      this.onCollisionEndedObservable = new import_observable.Observable();
+      /** Observable for trigger entered and exited events */
+      this.onTriggerCollisionObservable = new import_observable.Observable();
+      if (!box3dModule) {
+        throw new Error("Box3D module is required: pass the awaited result of the Box3D module factory.");
+      }
+      const missing = RequiredNativeExports.filter((name) => typeof box3dModule[name] !== "function");
+      if (missing.length > 0) {
+        throw new Error(
+          `Box3DPlugin: the Box3D module is missing ${missing.length} entry point${missing.length === 1 ? "" : "s"} this build needs (${missing.slice(0, 3).join(", ")}${missing.length > 3 ? ", ..." : ""}). box3d.js and box3d.wasm have to come from the same build of this package: check what locateFile points at and clear any copied or cached box3d.wasm.`
+        );
+      }
+      this._b3 = box3dModule;
+      this.world = box3dModule;
+      this._worldSlot = this._b3._bx_CreateWorld(0, -9.81, 0);
+      if (!this._worldSlot) {
+        throw new Error("Box3D: could not create a world (max worlds reached?)");
+      }
+    }
+    // ----------------------------------------------------------------------------------------
+    // helpers
+    // ----------------------------------------------------------------------------------------
+    _scratch() {
+      return new Float32Array(this._b3.HEAPF32.buffer, this._b3._bx_Scratch(), 64);
+    }
+    _warnOnce(key, message) {
+      if (!this._warned.has(key)) {
+        this._warned.add(key);
+        import_logger.Logger.Warn(`Box3DPlugin: ${message}`);
+      }
+    }
+    _getPluginReference(body, instanceIndex) {
+      return body._pluginDataInstances?.length ? body._pluginDataInstances[instanceIndex ?? 0] : body._pluginData;
+    }
+    _applyToBodyOrInstances(body, fn, instanceIndex) {
+      if (body._pluginDataInstances?.length > 0 && instanceIndex === void 0) {
+        for (const data of body._pluginDataInstances) {
+          fn(data);
+        }
+      } else {
+        fn(this._getPluginReference(body, instanceIndex));
+      }
+    }
+    _motionTypeToNative(motionType) {
+      switch (motionType) {
+        case import_IPhysicsEnginePlugin.PhysicsMotionType.STATIC:
+          return 0;
+        case import_IPhysicsEnginePlugin.PhysicsMotionType.ANIMATED:
+          return 1;
+        default:
+          return 2;
+      }
+    }
+    _nodeTransformToRef(node, position, orientation) {
+      if (node.parent) {
+        node.computeWorldMatrix(true);
+        position.copyFrom(node.absolutePosition);
+        orientation.copyFrom(node.absoluteRotationQuaternion);
+        return;
+      }
+      position.copyFrom(node.position);
+      if (node.rotationQuaternion) {
+        orientation.copyFrom(node.rotationQuaternion);
+      } else {
+        import_math_vector.Quaternion.FromEulerAnglesToRef(node.rotation.x, node.rotation.y, node.rotation.z, orientation);
+      }
+    }
+    // ----------------------------------------------------------------------------------------
+    // world
+    // ----------------------------------------------------------------------------------------
+    setGravity(gravity) {
+      this._b3._bx_World_SetGravity(this._worldSlot, gravity.x, gravity.y, gravity.z);
+    }
+    setTimeStep(timeStep) {
+      this._fixedTimeStep = timeStep;
+    }
+    getTimeStep() {
+      return this._fixedTimeStep;
+    }
+    executeStep(delta, physicsBodies) {
+      for (const physicsBody of physicsBodies) {
+        if (physicsBody.disablePreStep) {
+          continue;
+        }
+        this.setPhysicsBodyTransformation(physicsBody, physicsBody.transformNode);
+      }
+      for (const joint of this._motorJoints) {
+        if (this._b3._bx_Joint_IsValid(joint)) {
+          this._b3._bx_Joint_UpdateMotorFrame(joint);
+        } else {
+          this._motorJoints.delete(joint);
+        }
+      }
+      const deltaTime = this._useDeltaForWorldStep ? delta : this._fixedTimeStep;
+      this._timeStep = deltaTime;
+      const start = performance.now();
+      this._b3._bx_World_Step(this._worldSlot, deltaTime, this.subStepCount);
+      const moveCount = this._b3._bx_World_GetMoveEvents(this._worldSlot);
+      if (moveCount > 0) {
+        const movePointer = this._b3._bx_MoveEventsPtr();
+        let buffer = new Float32Array(this._b3.HEAPF32.buffer, movePointer, moveCount * MOVE_STRIDE);
+        for (let i = 0; i < moveCount; i++) {
+          if (buffer.buffer !== this._b3.HEAPF32.buffer) {
+            buffer = new Float32Array(this._b3.HEAPF32.buffer, movePointer, moveCount * MOVE_STRIDE);
+          }
+          const offset = i * MOVE_STRIDE;
+          const ref = this._bodies[buffer[offset]];
+          if (!ref || ref.body.disableSync) {
+            continue;
+          }
+          this._syncBodyFromBuffer(ref.body, ref.index, buffer, offset + 1);
+        }
+        for (const mesh of this._touchedInstanceMeshes) {
+          mesh.thinInstanceBufferUpdated("matrix");
+        }
+        this._touchedInstanceMeshes.clear();
+      }
+      this._notifyCollisions();
+      this._notifyTriggers();
+      this.lastStepTimeMs = performance.now() - start;
+      const rejected = this._b3._bx_GetRejectedSlotCount();
+      if (rejected > this._rejectedSlots) {
+        this._rejectedSlots = rejected;
+        this._warnOnce(
+          "rejected-slots",
+          `the native module did not recognize ${rejected} of the handles it was given, and those calls did nothing. Something is using a body, shape or joint after it was destroyed, or box3d.js and box3d.wasm are from different builds.`
+        );
+      }
+    }
+    getPluginVersion() {
+      return 2;
+    }
+    setVelocityLimits(maxLinearVelocity, maxAngularVelocity) {
+      this._b3._bx_World_SetMaximumLinearSpeed(this._worldSlot, maxLinearVelocity);
+      this._maxAngularVelocity = maxAngularVelocity;
+    }
+    getMaxLinearVelocity() {
+      return this._b3._bx_World_GetMaximumLinearSpeed(this._worldSlot);
+    }
+    getMaxAngularVelocity() {
+      return this._maxAngularVelocity;
+    }
+    /**
+     * Box3D counters and timings for the current world.
+     * @returns body, shape, contact, joint and island counts plus the last step time in milliseconds
+     */
+    getStats() {
+      this._b3._bx_World_GetStats(this._worldSlot);
+      const s = this._scratch();
+      return { bodies: s[0], shapes: s[1], contacts: s[2], joints: s[3], islands: s[4], stepMs: s[5], collideMs: s[6], solveMs: s[7] };
+    }
+    /**
+     * Enables or disables island sleeping.
+     * @param enabled true to let resting bodies sleep
+     */
+    setSleepingEnabled(enabled) {
+      this._b3._bx_World_EnableSleeping(this._worldSlot, enabled ? 1 : 0);
+    }
+    /**
+     * Enables or disables continuous collision against static geometry.
+     * @param enabled true to enable continuous collision
+     */
+    setContinuousEnabled(enabled) {
+      this._b3._bx_World_EnableContinuous(this._worldSlot, enabled ? 1 : 0);
+    }
+    // ----------------------------------------------------------------------------------------
+    // bodies
+    // ----------------------------------------------------------------------------------------
+    _createNativeBody(motionType, position, orientation, startAsleep) {
+      const slot = this._b3._bx_CreateBody(
+        this._worldSlot,
+        this._motionTypeToNative(motionType),
+        position.x,
+        position.y,
+        position.z,
+        orientation.x,
+        orientation.y,
+        orientation.z,
+        orientation.w,
+        startAsleep ? 0 : 1
+      );
+      const data = new Box3DBodyData(slot);
+      data.motionType = motionType;
+      return data;
+    }
+    initBody(body, motionType, position, orientation) {
+      const data = this._createNativeBody(motionType, position, orientation, body.startAsleep);
+      body._pluginData = data;
+      this._bodies[data.slot] = { body, index: 0, data };
+    }
+    initBodyInstances(body, motionType, mesh) {
+      const instancesCount = mesh._thinInstanceDataStorage?.instancesCount ?? 0;
+      const matrixData = mesh._thinInstanceDataStorage?.matrixData;
+      if (!matrixData) {
+        return;
+      }
+      const shape = body.shape?._pluginData;
+      if (instancesCount > 8 && shape && this._bakesMeshCopies(shape)) {
+        this._warnOnce(
+          "instanced-mesh-child",
+          "a mesh inside a container has no local transform in Box3D, so every instance gets its own baked copy of the mesh data; put the mesh on the body directly, or bake the offset into the mesh, to share it."
+        );
+      }
+      this._createOrUpdateBodyInstances(body, motionType, matrixData, 0, instancesCount, false);
+    }
+    _createOrUpdateBodyInstances(body, motionType, matrixData, startIndex, endIndex, update) {
+      const rotation = import_math_vector.TmpVectors.Quaternion[0];
+      const rotationMatrix = import_math_vector.TmpVectors.Matrix[0];
+      const position = import_math_vector.TmpVectors.Vector3[0];
+      for (let i = startIndex; i < endIndex; i++) {
+        position.set(matrixData[i * 16 + 12], matrixData[i * 16 + 13], matrixData[i * 16 + 14]);
+        import_math_vector.Matrix.FromArrayToRef(matrixData, i * 16, rotationMatrix);
+        rotationMatrix.decompose(void 0, rotation, void 0);
+        if (update) {
+          const data = body._pluginDataInstances[i];
+          this._b3._bx_Body_SetTransform(data.slot, position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w);
+        } else {
+          const data = this._createNativeBody(motionType, position, rotation, body.startAsleep);
+          const sibling = body._pluginDataInstances[0];
+          if (sibling) {
+            data.userMassProps = sibling.userMassProps;
+            data.eventMask = sibling.eventMask;
+            this._applyEventFlags(data);
+            if (sibling.activation !== import_IPhysicsEnginePlugin.PhysicsActivationControl.SIMULATION_CONTROLLED) {
+              data.activation = sibling.activation;
+              this._applyNativeMotionType(data);
+              this._b3._bx_Body_EnableSleep(data.slot, sibling.activation === import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_ACTIVE ? 0 : 1);
+            }
+          }
+          body._pluginDataInstances.push(data);
+          this._bodies[data.slot] = { body, index: i, data };
+        }
+      }
+    }
+    updateBodyInstances(body, mesh) {
+      const instancesCount = mesh._thinInstanceDataStorage?.instancesCount ?? 0;
+      const matrixData = mesh._thinInstanceDataStorage?.matrixData;
+      if (!matrixData) {
+        return;
+      }
+      const pluginInstancesCount = body._pluginDataInstances.length;
+      const motionType = this.getMotionType(body);
+      if (instancesCount > pluginInstancesCount) {
+        this._createOrUpdateBodyInstances(body, motionType, matrixData, pluginInstancesCount, instancesCount, false);
+        const shape = body.shape;
+        if (shape && shape._pluginData) {
+          for (let i = pluginInstancesCount; i < instancesCount; i++) {
+            this._setBodyShape(body._pluginDataInstances[i], shape._pluginData);
+          }
+        }
+      } else if (instancesCount < pluginInstancesCount) {
+        const instancesToRemove = pluginInstancesCount - instancesCount;
+        for (let i = 0; i < instancesToRemove; i++) {
+          const data = body._pluginDataInstances.pop();
+          this._destroyBodyData(data);
+        }
+        this._createOrUpdateBodyInstances(body, motionType, matrixData, 0, instancesCount, true);
+      }
+    }
+    _destroyBodyData(data) {
+      if (!data) {
+        return;
+      }
+      for (const shape of this._shapes) {
+        shape?.users.delete(data);
+      }
+      this._bodyCollisionObservable.delete(data.slot);
+      this._bodyCollisionEndedObservable.delete(data.slot);
+      this._bodies[data.slot] = void 0;
+      this._b3._bx_DestroyBody(data.slot);
+      data.slot = 0;
+    }
+    removeBody(body) {
+      if (body._pluginDataInstances?.length) {
+        for (const data of body._pluginDataInstances) {
+          this._destroyBodyData(data);
+        }
+      }
+      if (body._pluginData) {
+        this._destroyBodyData(body._pluginData);
+      }
+    }
+    sync(body) {
+      this.syncTransform(body, body.transformNode);
+    }
+    _syncBodyFromBuffer(body, index, buffer, offset) {
+      const node = body.transformNode;
+      if (body._pluginDataInstances.length) {
+        const m = node;
+        const matrixData = m._thinInstanceDataStorage?.matrixData;
+        if (!matrixData) {
+          return;
+        }
+        const scale = this._tmpVec3[0];
+        const base = index * 16;
+        scale.set(
+          Math.hypot(matrixData[base], matrixData[base + 1], matrixData[base + 2]),
+          Math.hypot(matrixData[base + 4], matrixData[base + 5], matrixData[base + 6]),
+          Math.hypot(matrixData[base + 8], matrixData[base + 9], matrixData[base + 10])
+        );
+        const quat = this._tmpQuat[0];
+        quat.set(buffer[offset + 3], buffer[offset + 4], buffer[offset + 5], buffer[offset + 6]);
+        const position = this._tmpVec3[1];
+        position.set(buffer[offset], buffer[offset + 1], buffer[offset + 2]);
+        const matrix = import_math_vector.TmpVectors.Matrix[0];
+        import_math_vector.Matrix.ComposeToRef(scale, quat, position, matrix);
+        matrix.copyToArray(matrixData, base);
+        this._touchedInstanceMeshes.add(m);
+        return;
+      }
+      this._applyTransformToNode(node, buffer[offset], buffer[offset + 1], buffer[offset + 2], buffer[offset + 3], buffer[offset + 4], buffer[offset + 5], buffer[offset + 6]);
+    }
+    _applyTransformToNode(node, px, py, pz, qx, qy, qz, qw) {
+      const quat = this._tmpQuat[0];
+      quat.set(qx, qy, qz, qw);
+      const parent = node.parent;
+      if (parent && !parent.getWorldMatrix().isIdentity()) {
+        parent.computeWorldMatrix(true);
+        const savedScaling = this._tmpVec3[2];
+        savedScaling.copyFrom(node.scaling);
+        const finalTransform = import_math_vector.TmpVectors.Matrix[0];
+        const finalTranslation = this._tmpVec3[3];
+        finalTranslation.set(px, py, pz);
+        import_math_vector.Matrix.ComposeToRef(node.absoluteScaling, quat, finalTranslation, finalTransform);
+        const parentInverse = import_math_vector.TmpVectors.Matrix[1];
+        parent.getWorldMatrix().invertToRef(parentInverse);
+        const localTransform = import_math_vector.TmpVectors.Matrix[2];
+        finalTransform.multiplyToRef(parentInverse, localTransform);
+        localTransform.decomposeToTransformNode(node);
+        node.rotationQuaternion?.normalize();
+        node.scaling.copyFrom(savedScaling);
+      } else {
+        node.position.set(px, py, pz);
+        if (node.rotationQuaternion) {
+          node.rotationQuaternion.copyFrom(quat);
+        } else {
+          quat.toEulerAnglesToRef(node.rotation);
+        }
+      }
+    }
+    syncTransform(body, transformNode) {
+      if (body._pluginDataInstances.length) {
+        const m = transformNode;
+        const matrixData = m._thinInstanceDataStorage?.matrixData;
+        if (!matrixData) {
+          return;
+        }
+        for (let i = 0; i < body._pluginDataInstances.length; i++) {
+          const data2 = body._pluginDataInstances[i];
+          this._b3._bx_Body_GetTransform(data2.slot);
+          this._syncBodyFromBuffer(body, i, this._scratch(), 0);
+        }
+        m.thinInstanceBufferUpdated("matrix");
+        this._touchedInstanceMeshes.delete(m);
+        return;
+      }
+      const data = body._pluginData;
+      if (!data || !data.slot) {
+        return;
+      }
+      this._b3._bx_Body_GetTransform(data.slot);
+      const s = this._scratch();
+      this._applyTransformToNode(transformNode, s[0], s[1], s[2], s[3], s[4], s[5], s[6]);
+    }
+    /**
+     * Pushes the transform node's pose into the physics body (called during the pre step).
+     * @param body the physics body
+     * @param node the transform node to read from
+     */
+    setPhysicsBodyTransformation(body, node) {
+      const prestep = body.getPrestepType();
+      if (prestep == import_IPhysicsEnginePlugin.PhysicsPrestepType.TELEPORT) {
+        if (body._pluginDataInstances.length > 0) {
+          const m = node;
+          const matrixData = m._thinInstanceDataStorage?.matrixData;
+          if (!matrixData) {
+            return;
+          }
+          this._createOrUpdateBodyInstances(body, body.getMotionType(), matrixData, 0, body._pluginDataInstances.length, true);
+          return;
+        }
+        const data = body._pluginData;
+        const position = this._tmpVec3[0];
+        const orientation = this._tmpQuat[0];
+        this._nodeTransformToRef(node, position, orientation);
+        this._b3._bx_Body_SetTransform(data.slot, position.x, position.y, position.z, orientation.x, orientation.y, orientation.z, orientation.w);
+      } else if (prestep == import_IPhysicsEnginePlugin.PhysicsPrestepType.ACTION) {
+        this.setTargetTransform(body, node.absolutePosition, node.absoluteRotationQuaternion);
+      } else if (prestep == import_IPhysicsEnginePlugin.PhysicsPrestepType.DISABLED) {
+        import_logger.Logger.Warn("Prestep type is set to DISABLED. Unable to set physics body transformation.");
+      }
+    }
+    setTargetTransform(body, position, rotation, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => {
+          this._b3._bx_Body_SetTargetTransform(data.slot, position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w, this._timeStep);
+        },
+        instanceIndex
+      );
+    }
+    /** True when the shape puts a mesh inside a container, which Box3D can only do by baking a copy per body. */
+    _bakesMeshCopies(data, visited = /* @__PURE__ */ new Set()) {
+      if (visited.has(data)) {
+        return false;
+      }
+      visited.add(data);
+      return data.children.some((child) => child.type === import_IPhysicsEnginePlugin.PhysicsShapeType.MESH || this._bakesMeshCopies(child, visited));
+    }
+    _setBodyShape(data, shape) {
+      for (const existing of this._shapes) {
+        existing?.users.delete(data);
+      }
+      this._b3._bx_Body_SetShape(data.slot, shape ? shape.slot : 0);
+      if (shape) {
+        shape.users.add(data);
+      }
+      this._applyEventFlags(data);
+      this._internalUpdateMassProperties(data);
+    }
+    setShape(body, shape) {
+      const shapeData = shape && shape._pluginData ? shape._pluginData : null;
+      this._applyToBodyOrInstances(body, (data) => this._setBodyShape(data, shapeData));
+    }
+    getShape(body) {
+      return body.shape ?? null;
+    }
+    getShapeType(shape) {
+      return shape.type ?? shape._pluginData?.type ?? import_IPhysicsEnginePlugin.PhysicsShapeType.CONTAINER;
+    }
+    /** Turns the body's event mask into Box3D's two shape flags, so a body only pays for the events it asked for. */
+    _applyEventFlags(data) {
+      const touch = data.eventMask & (1 /* COLLISION_STARTED */ | 4 /* COLLISION_FINISHED */) ? 1 : 0;
+      const hit = data.eventMask & 2 /* COLLISION_CONTINUED */ ? 1 : 0;
+      this._b3._bx_Body_SetEventFlags(data.slot, touch, hit);
+    }
+    setEventMask(body, eventMask, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => {
+          data.eventMask = eventMask;
+          this._applyEventFlags(data);
+        },
+        instanceIndex
+      );
+    }
+    getEventMask(body, instanceIndex) {
+      return this._getPluginReference(body, instanceIndex).eventMask;
+    }
+    setMotionType(body, motionType, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => {
+          data.motionType = motionType;
+          this._applyNativeMotionType(data);
+          this._internalUpdateMassProperties(data);
+        },
+        instanceIndex
+      );
+    }
+    /** The Box3D body type: the Babylon motion type, unless the body is parked by ALWAYS_INACTIVE. */
+    _applyNativeMotionType(data) {
+      const native = data.activation === import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_INACTIVE ? 0 : this._motionTypeToNative(data.motionType);
+      this._b3._bx_Body_SetType(data.slot, native);
+    }
+    /**
+     * Babylon's activation control, matched to Havok's behaviour with Box3D sleeping.
+     * ALWAYS_ACTIVE turns sleeping off for the body, SIMULATION_CONTROLLED turns it back on. ALWAYS_INACTIVE parks the
+     * body: in Havok such a body ignores impulses and velocity changes, is not woken by anything that touches it and
+     * still blocks other bodies, which Box3D sleeping alone cannot do, so it becomes a static Box3D body until the
+     * control changes. Coming back it is left asleep, like Havok, until something wakes it.
+     * @param body the physics body
+     * @param controlMode how the body may be activated and deactivated
+     * @param instanceIndex optional thin instance index
+     */
+    setActivationControl(body, controlMode, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => {
+          if (data.activation === controlMode) {
+            return;
+          }
+          const wasInactive = data.activation === import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_INACTIVE;
+          data.activation = controlMode;
+          if (controlMode === import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_INACTIVE) {
+            this._b3._bx_Body_SetLinearVelocity(data.slot, 0, 0, 0);
+            this._b3._bx_Body_SetAngularVelocity(data.slot, 0, 0, 0);
+            this._applyNativeMotionType(data);
+            return;
+          }
+          this._applyNativeMotionType(data);
+          this._internalUpdateMassProperties(data);
+          this._b3._bx_Body_EnableSleep(data.slot, controlMode === import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_ACTIVE ? 0 : 1);
+          if (wasInactive && controlMode === import_IPhysicsEnginePlugin.PhysicsActivationControl.SIMULATION_CONTROLLED) {
+            this._b3._bx_Body_SetAwake(data.slot, 0);
+          }
+        },
+        instanceIndex
+      );
+    }
+    getMotionType(body, instanceIndex) {
+      return this._getPluginReference(body, instanceIndex).motionType;
+    }
+    /**
+     * Reads Box3D's mass data and converts it to Babylon's form: the inertia is the principal moments of the tensor
+     * divided by the mass (Babylon's inertia is per unit mass) and the orientation rotates the principal axes into
+     * body space.
+     */
+    _readMassData(data) {
+      if (data.motionType === import_IPhysicsEnginePlugin.PhysicsMotionType.DYNAMIC && data.activation !== import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_INACTIVE) {
+        this._b3._bx_Body_GetMassData(data.slot);
+      } else {
+        this._b3._bx_Body_ComputeShapeMassData(data.slot);
+      }
+      const s = this._scratch();
+      const mass = s[0];
+      const principal = new import_math_vector.Vector3();
+      const orientation = new import_math_vector.Quaternion();
+      DiagonalizeInertia([s[4], s[5], s[6], s[7], s[8], s[9]], principal, orientation);
+      if (mass > 0) {
+        principal.scaleInPlace(1 / mass);
+      }
+      return {
+        mass,
+        centerOfMass: new import_math_vector.Vector3(s[1], s[2], s[3]),
+        inertia: principal,
+        inertiaOrientation: orientation
+      };
+    }
+    /** The mass properties of the body: what the user asked for, filled in from the shapes where they said nothing. */
+    _resolveMassProperties(data) {
+      const computed = this._readMassData(data);
+      const user = data.userMassProps ?? {};
+      const mass = user.mass !== void 0 && user.mass > 0 ? user.mass : computed.mass;
+      return {
+        mass,
+        centerOfMass: user.centerOfMass ?? computed.centerOfMass,
+        inertia: user.inertia ?? computed.inertia,
+        inertiaOrientation: user.inertiaOrientation ?? (user.inertia ? import_math_vector.Quaternion.Identity() : computed.inertiaOrientation)
+      };
+    }
+    _internalUpdateMassProperties(data) {
+      if (data.motionType !== import_IPhysicsEnginePlugin.PhysicsMotionType.DYNAMIC || data.activation === import_IPhysicsEnginePlugin.PhysicsActivationControl.ALWAYS_INACTIVE) {
+        this._applyMotionLocks(data, false, false, false);
+        return;
+      }
+      this._b3._bx_Body_ApplyMassFromShapes(data.slot);
+      const user = data.userMassProps;
+      const hasUser = !!user && (user.mass !== void 0 || !!user.centerOfMass || !!user.inertia || !!user.inertiaOrientation);
+      if (!hasUser) {
+        this._applyMotionLocks(data, false, false, false);
+        return;
+      }
+      const props = this._resolveMassProperties(data);
+      const mass = props.mass > 0 ? props.mass : 1;
+      const inertia = props.inertia;
+      const orientation = props.inertiaOrientation;
+      const locked = [inertia.x <= 0, inertia.y <= 0, inertia.z <= 0];
+      const largest = Math.max(inertia.x, inertia.y, inertia.z, 1e-4) * LockedInertiaRatio;
+      const moments = [locked[0] ? largest : inertia.x, locked[1] ? largest : inertia.y, locked[2] ? largest : inertia.z].map((value) => value * mass);
+      const tensor = ComposeInertia(moments, orientation);
+      this._b3._bx_Body_SetMassDataFull(
+        data.slot,
+        mass,
+        props.centerOfMass.x,
+        props.centerOfMass.y,
+        props.centerOfMass.z,
+        tensor[0],
+        tensor[1],
+        tensor[2],
+        tensor[3],
+        tensor[4],
+        tensor[5]
+      );
+      this._applyLockedAxes(data, locked, orientation);
+    }
+    /**
+     * Box3D locks are world space, Babylon's zero inertia components are body local. Locking two of them leaves a single
+     * free axis, and if that axis is world aligned the body can only ever spin about it, so the world locks are exact
+     * and stay exact. Everything else relies on the large moment above.
+     */
+    _applyLockedAxes(data, locked, orientation) {
+      const count = locked.filter(Boolean).length;
+      if (count === 3) {
+        this._applyMotionLocks(data, true, true, true);
+        return;
+      }
+      if (count !== 2) {
+        this._applyMotionLocks(data, false, false, false);
+        return;
+      }
+      this._b3._bx_Body_GetTransform(data.slot);
+      const s = this._scratch();
+      const bodyRotation = this._tmpQuat[0].set(s[3], s[4], s[5], s[6]);
+      const free = locked.indexOf(false);
+      const axis = this._tmpVec3[0].set(free === 0 ? 1 : 0, free === 1 ? 1 : 0, free === 2 ? 1 : 0);
+      axis.applyRotationQuaternionInPlace(orientation).applyRotationQuaternionInPlace(bodyRotation);
+      const components = [Math.abs(axis.x), Math.abs(axis.y), Math.abs(axis.z)];
+      const dominant = components.indexOf(Math.max(...components));
+      if (components[dominant] > 0.9999) {
+        this._applyMotionLocks(data, dominant !== 0, dominant !== 1, dominant !== 2);
+      } else {
+        this._applyMotionLocks(data, false, false, false);
+      }
+    }
+    _applyMotionLocks(data, x, y, z) {
+      const locks = (x ? 1 : 0) | (y ? 2 : 0) | (z ? 4 : 0);
+      if (locks === data.angularLocks) {
+        return;
+      }
+      data.angularLocks = locks;
+      this._b3._bx_Body_SetMotionLocks(data.slot, 0, 0, 0, x ? 1 : 0, y ? 1 : 0, z ? 1 : 0);
+    }
+    computeMassProperties(body, instanceIndex) {
+      const data = this._getPluginReference(body, instanceIndex);
+      this._b3._bx_Body_ApplyMassFromShapes(data.slot);
+      const computed = this._readMassData(data);
+      this._internalUpdateMassProperties(data);
+      return computed;
+    }
+    setMassProperties(body, massProps, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => {
+          data.userMassProps = massProps;
+          this._internalUpdateMassProperties(data);
+        },
+        instanceIndex
+      );
+    }
+    getMassProperties(body, instanceIndex) {
+      return this._resolveMassProperties(this._getPluginReference(body, instanceIndex));
+    }
+    setLinearDamping(body, damping, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_SetLinearDamping(data.slot, damping), instanceIndex);
+    }
+    getLinearDamping(body, instanceIndex) {
+      return this._b3._bx_Body_GetLinearDamping(this._getPluginReference(body, instanceIndex).slot);
+    }
+    setAngularDamping(body, damping, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_SetAngularDamping(data.slot, damping), instanceIndex);
+    }
+    getAngularDamping(body, instanceIndex) {
+      return this._b3._bx_Body_GetAngularDamping(this._getPluginReference(body, instanceIndex).slot);
+    }
+    setLinearVelocity(body, linVel, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_SetLinearVelocity(data.slot, linVel.x, linVel.y, linVel.z), instanceIndex);
+    }
+    getLinearVelocityToRef(body, linVel, instanceIndex) {
+      this._b3._bx_Body_GetLinearVelocity(this._getPluginReference(body, instanceIndex).slot);
+      const s = this._scratch();
+      linVel.set(s[0], s[1], s[2]);
+    }
+    applyImpulse(body, impulse, location, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => this._b3._bx_Body_ApplyLinearImpulse(data.slot, impulse.x, impulse.y, impulse.z, location.x, location.y, location.z),
+        instanceIndex
+      );
+    }
+    applyAngularImpulse(body, angularImpulse, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_ApplyAngularImpulse(data.slot, angularImpulse.x, angularImpulse.y, angularImpulse.z), instanceIndex);
+    }
+    applyForce(body, force, location, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_ApplyForce(data.slot, force.x, force.y, force.z, location.x, location.y, location.z), instanceIndex);
+    }
+    applyTorque(body, torque, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_ApplyTorque(data.slot, torque.x, torque.y, torque.z), instanceIndex);
+    }
+    setAngularVelocity(body, angVel, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_SetAngularVelocity(data.slot, angVel.x, angVel.y, angVel.z), instanceIndex);
+    }
+    getAngularVelocityToRef(body, angVel, instanceIndex) {
+      this._b3._bx_Body_GetAngularVelocity(this._getPluginReference(body, instanceIndex).slot);
+      const s = this._scratch();
+      angVel.set(s[0], s[1], s[2]);
+    }
+    getBodyGeometry(body) {
+      const shape = body.shape?._pluginData;
+      if (!shape) {
+        return { positions: [], indices: [] };
+      }
+      const vertexCount = this._b3._bx_ShapeDesc_BuildDebugGeometry(shape.slot);
+      const indexCount = this._b3._bx_DebugIndexCount();
+      if (!vertexCount || !indexCount) {
+        return { positions: [], indices: [] };
+      }
+      const positions = new Float32Array(this._b3.HEAPF32.buffer, this._b3._bx_DebugPositionsPtr(), vertexCount * 3).slice();
+      const indices = new Uint32Array(this._b3.HEAPU32.buffer, this._b3._bx_DebugIndicesPtr(), indexCount).slice();
+      return { positions, indices };
+    }
+    disposeBody(body) {
+      this.removeBody(body);
+      body._pluginData = void 0;
+      body._pluginDataInstances.length = 0;
+    }
+    setCollisionCallbackEnabled(body, enabled, instanceIndex) {
+      this.setEventMask(body, enabled ? 7 /* ALL */ : 0, instanceIndex);
+    }
+    setCollisionEndedCallbackEnabled(body, enabled, instanceIndex) {
+      this._applyToBodyOrInstances(
+        body,
+        (data) => {
+          data.eventMask = enabled ? data.eventMask | 4 /* COLLISION_FINISHED */ : data.eventMask & ~4 /* COLLISION_FINISHED */;
+          this._applyEventFlags(data);
+        },
+        instanceIndex
+      );
+    }
+    getCollisionObservable(body, instanceIndex) {
+      const slot = this._getPluginReference(body, instanceIndex).slot;
+      let observable = this._bodyCollisionObservable.get(slot);
+      if (!observable) {
+        observable = new import_observable.Observable();
+        this._bodyCollisionObservable.set(slot, observable);
+      }
+      return observable;
+    }
+    getCollisionEndedObservable(body, instanceIndex) {
+      const slot = this._getPluginReference(body, instanceIndex).slot;
+      let observable = this._bodyCollisionEndedObservable.get(slot);
+      if (!observable) {
+        observable = new import_observable.Observable();
+        this._bodyCollisionEndedObservable.set(slot, observable);
+      }
+      return observable;
+    }
+    setGravityFactor(body, factor, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_SetGravityScale(data.slot, factor), instanceIndex);
+    }
+    getGravityFactor(body, instanceIndex) {
+      return this._b3._bx_Body_GetGravityScale(this._getPluginReference(body, instanceIndex).slot);
+    }
+    // ----------------------------------------------------------------------------------------
+    // shapes
+    // ----------------------------------------------------------------------------------------
+    _registerShape(shape, slot, type) {
+      if (!slot) {
+        throw new Error("Box3DPlugin: shape creation failed (degenerate geometry?)");
+      }
+      const data = new Box3DShapeData(slot, type);
+      shape._pluginData = data;
+      this._shapes[slot] = data;
+      return data;
+    }
+    _withFloatBuffer(values, fn) {
+      const ptr = this._b3._malloc(values.length * 4);
+      new Float32Array(this._b3.HEAPF32.buffer, ptr, values.length).set(values);
+      try {
+        return fn(ptr);
+      } finally {
+        this._b3._free(ptr);
+      }
+    }
+    /** Copies bytes into the module for the length of `fn`; with no bytes, `fn` gets a null pointer. */
+    _withByteBuffer(values, fn) {
+      if (!values || values.length === 0) {
+        return fn(0);
+      }
+      const ptr = this._b3._malloc(values.length);
+      new Uint8Array(this._b3.HEAPU8.buffer, ptr, values.length).set(values);
+      try {
+        return fn(ptr);
+      } finally {
+        this._b3._free(ptr);
+      }
+    }
+    _withIntBuffer(values, fn) {
+      const ptr = this._b3._malloc(values.length * 4);
+      new Int32Array(this._b3.HEAP32.buffer, ptr, values.length).set(values);
+      try {
+        return fn(ptr);
+      } finally {
+        this._b3._free(ptr);
+      }
+    }
+    _createOptionsFromGroundMesh(options) {
+      const mesh = options.groundMesh;
+      if (!mesh) {
+        return;
+      }
+      const pos = mesh.getVerticesData(import_buffer.VertexBuffer.PositionKind);
+      const transform = mesh.computeWorldMatrix(true);
+      const transformed = [];
+      const p = import_math_vector.TmpVectors.Vector3[0];
+      for (let i = 0; i < pos.length; i += 3) {
+        import_math_vector.Vector3.FromArrayToRef(pos, i, p);
+        import_math_vector.Vector3.TransformCoordinatesToRef(p, transform, p);
+        p.toArray(transformed, i);
+      }
+      const arraySize = ~~(Math.sqrt(transformed.length / 3) - 1);
+      const boundingInfo = mesh.getBoundingInfo();
+      const dim = Math.min(boundingInfo.boundingBox.extendSizeWorld.x, boundingInfo.boundingBox.extendSizeWorld.z);
+      const minX = boundingInfo.boundingBox.minimumWorld.x;
+      const minY = boundingInfo.boundingBox.minimumWorld.y;
+      const minZ = boundingInfo.boundingBox.minimumWorld.z;
+      const matrix = new Float32Array((arraySize + 1) * (arraySize + 1));
+      const elementSize = dim * 2 / arraySize;
+      matrix.fill(minY);
+      for (let i = 0; i < transformed.length; i += 3) {
+        const x = Math.round((transformed[i + 0] - minX) / elementSize);
+        const z = arraySize - Math.round((transformed[i + 2] - minZ) / elementSize);
+        matrix[z * (arraySize + 1) + x] = transformed[i + 1] - minY;
+      }
+      options.numHeightFieldSamplesX = arraySize + 1;
+      options.numHeightFieldSamplesZ = arraySize + 1;
+      options.heightFieldSizeX = boundingInfo.boundingBox.extendSizeWorld.x * 2;
+      options.heightFieldSizeZ = boundingInfo.boundingBox.extendSizeWorld.z * 2;
+      options.heightFieldData = matrix;
+    }
+    initShape(shape, type, options) {
+      const b3 = this._b3;
+      const center = options.center ?? import_math_vector.Vector3.ZeroReadOnly;
+      const rotation = options.rotation ?? import_math_vector.Quaternion.Identity();
+      switch (type) {
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.SPHERE: {
+          const radius = options.radius ?? 1;
+          this._registerShape(shape, b3._bx_ShapeDesc_CreateSphere(center.x, center.y, center.z, radius), type);
+          break;
+        }
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.CAPSULE: {
+          const a = options.pointA ?? import_math_vector.Vector3.ZeroReadOnly;
+          const b = options.pointB ?? import_math_vector.Vector3.UpReadOnly;
+          this._registerShape(shape, b3._bx_ShapeDesc_CreateCapsule(a.x, a.y, a.z, b.x, b.y, b.z, options.radius ?? 0), type);
+          break;
+        }
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.BOX: {
+          const extents = options.extents ?? import_math_vector.Vector3.OneReadOnly;
+          this._registerShape(
+            shape,
+            b3._bx_ShapeDesc_CreateBox(extents.x * 0.5, extents.y * 0.5, extents.z * 0.5, center.x, center.y, center.z, rotation.x, rotation.y, rotation.z, rotation.w),
+            type
+          );
+          break;
+        }
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.CYLINDER: {
+          const a = options.pointA ?? import_math_vector.Vector3.ZeroReadOnly;
+          const b = options.pointB ?? import_math_vector.Vector3.UpReadOnly;
+          const axis = b.subtract(a);
+          const height = axis.length();
+          const mid = a.add(b).scaleInPlace(0.5);
+          const q = this._tmpQuat[0];
+          if (height > 1e-6) {
+            axis.scaleInPlace(1 / height);
+            import_math_vector.Quaternion.FromUnitVectorsToRef(import_math_vector.Vector3.UpReadOnly, axis, q);
+          } else {
+            q.set(0, 0, 0, 1);
+          }
+          this._registerShape(shape, b3._bx_ShapeDesc_CreateCylinder(height, options.radius ?? 0, 16, mid.x, mid.y, mid.z, q.x, q.y, q.z, q.w), type);
+          break;
+        }
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.CONVEX_HULL:
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.MESH: {
+          const mesh = options.mesh;
+          if (!mesh) {
+            throw new Error("No mesh provided to create physics shape.");
+          }
+          const needIndices = type === import_IPhysicsEnginePlugin.PhysicsShapeType.MESH;
+          const flipWinding = !mesh.getScene().useRightHandedSystem;
+          const accum = new MeshGeometryAccumulator(needIndices, flipWinding);
+          accum.addNodeMeshes(mesh, !!options.includeChildMeshes);
+          if (type === import_IPhysicsEnginePlugin.PhysicsShapeType.CONVEX_HULL) {
+            const slot = this._withFloatBuffer(accum.vertices, (ptr) => b3._bx_ShapeDesc_CreateHull(ptr, accum.vertexCount));
+            this._registerShape(shape, slot, type);
+          } else {
+            const slot = this._withFloatBuffer(
+              accum.vertices,
+              (vptr) => this._withIntBuffer(accum.indices, (iptr) => b3._bx_ShapeDesc_CreateMesh(vptr, accum.vertexCount, iptr, accum.triangleCount, 1, 1, 1, 0, 0))
+            );
+            this._registerShape(shape, slot, type);
+          }
+          break;
+        }
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.HEIGHTFIELD: {
+          if (options.groundMesh) {
+            this._createOptionsFromGroundMesh(options);
+          }
+          const nx = options.numHeightFieldSamplesX;
+          const nz = options.numHeightFieldSamplesZ;
+          if (!nx || !nz || !options.heightFieldSizeX || !options.heightFieldSizeZ || !options.heightFieldData) {
+            throw new Error("Missing required heightfield parameters");
+          }
+          const heights = new Float32Array(nx * nz);
+          for (let x = 0; x < nx; x++) {
+            for (let z = 0; z < nz; z++) {
+              heights[z * nx + x] = options.heightFieldData[(nz - 1 - z) * nx + x];
+            }
+          }
+          const scaleX = options.heightFieldSizeX / (nx - 1);
+          const scaleZ = options.heightFieldSizeZ / (nz - 1);
+          const cellsX = nx - 1;
+          const cellsZ = nz - 1;
+          const source = options.heightFieldMaterials;
+          if (source && source.length !== cellsX * cellsZ) {
+            throw new Error(`heightFieldMaterials needs ${cellsX * cellsZ} cells (${cellsX} \xD7 ${cellsZ}), got ${source.length}`);
+          }
+          const materials = source ? new Uint8Array(cellsX * cellsZ) : null;
+          if (source && materials) {
+            for (let x = 0; x < cellsX; x++) {
+              for (let z = 0; z < cellsZ; z++) {
+                materials[z * cellsX + x] = source[(cellsZ - 1 - z) * cellsX + x];
+              }
+            }
+          }
+          const slot = this._withFloatBuffer(
+            heights,
+            (heightsPtr) => this._withByteBuffer(
+              materials,
+              (materialsPtr) => b3._bx_ShapeDesc_CreateHeightField(
+                heightsPtr,
+                materialsPtr,
+                nx,
+                nz,
+                scaleX,
+                1,
+                scaleZ,
+                0,
+                -options.heightFieldSizeX * 0.5,
+                0,
+                -options.heightFieldSizeZ * 0.5
+              )
+            )
+          );
+          this._registerShape(shape, slot, type);
+          break;
+        }
+        case import_IPhysicsEnginePlugin.PhysicsShapeType.CONTAINER: {
+          this._registerShape(shape, b3._bx_ShapeDesc_CreateContainer(), type);
+          break;
+        }
+        default:
+          throw new Error("Unsupported Shape Type.");
+      }
+    }
+    // Re-instantiates the shape on every body that uses it (or uses a container holding it). Only needed for geometry
+    // and child changes; filters, materials and density are applied in place, see _syncShapeUsers.
+    _refreshShapeUsers(data, visited = /* @__PURE__ */ new Set()) {
+      if (visited.has(data)) {
+        return;
+      }
+      visited.add(data);
+      for (const body of data.users) {
+        this._b3._bx_Body_SetShape(body.slot, data.slot);
+        this._applyEventFlags(body);
+        this._internalUpdateMassProperties(body);
+      }
+      for (const parent of data.parents) {
+        this._refreshShapeUsers(parent, visited);
+      }
+    }
+    /**
+     * Pushes changed description properties into the Box3D shapes that are already on the bodies using this shape,
+     * directly or through a container. Rebuilding them instead would drop their contacts and re-apply the body mass.
+     */
+    _syncShapeUsers(data, what, visited = /* @__PURE__ */ new Set(), changed = data) {
+      if (visited.has(data)) {
+        return;
+      }
+      visited.add(data);
+      for (const body of data.users) {
+        this._b3._bx_Body_SyncShapeDesc(body.slot, changed.slot, what);
+        if (what & 4 /* DENSITY */) {
+          this._internalUpdateMassProperties(body);
+        }
+      }
+      for (const parent of data.parents) {
+        this._syncShapeUsers(parent, what, visited, changed);
+      }
+    }
+    setShapeFilterMembershipMask(shape, membershipMask) {
+      const data = shape._pluginData;
+      const collide = this._b3._bx_ShapeDesc_GetMaskBits(data.slot);
+      this._b3._bx_ShapeDesc_SetFilter(data.slot, membershipMask >>> 0, collide >>> 0);
+      this._syncShapeUsers(data, 1 /* FILTER */);
+    }
+    getShapeFilterMembershipMask(shape) {
+      return this._b3._bx_ShapeDesc_GetCategoryBits(shape._pluginData.slot);
+    }
+    setShapeFilterCollideMask(shape, collideMask) {
+      const data = shape._pluginData;
+      const membership = this._b3._bx_ShapeDesc_GetCategoryBits(data.slot);
+      this._b3._bx_ShapeDesc_SetFilter(data.slot, membership >>> 0, collideMask >>> 0);
+      this._syncShapeUsers(data, 1 /* FILTER */);
+    }
+    getShapeFilterCollideMask(shape) {
+      return this._b3._bx_ShapeDesc_GetMaskBits(shape._pluginData.slot);
+    }
+    setMaterial(shape, material) {
+      const data = shape._pluginData;
+      data.material = material;
+      this._b3._bx_ShapeDesc_SetMaterial(data.slot, material.friction ?? 0.5, material.restitution ?? 0);
+      this._syncShapeUsers(data, 2 /* MATERIAL */);
+    }
+    getMaterial(shape) {
+      const data = shape._pluginData;
+      return {
+        friction: this._b3._bx_ShapeDesc_GetFriction(data.slot),
+        staticFriction: data.material.staticFriction,
+        restitution: this._b3._bx_ShapeDesc_GetRestitution(data.slot),
+        frictionCombine: data.material.frictionCombine,
+        restitutionCombine: data.material.restitutionCombine
+      };
+    }
+    setDensity(shape, density) {
+      const data = shape._pluginData;
+      this._b3._bx_ShapeDesc_SetDensity(data.slot, density);
+      this._syncShapeUsers(data, 4 /* DENSITY */);
+    }
+    getDensity(shape) {
+      return this._b3._bx_ShapeDesc_GetDensity(shape._pluginData.slot);
+    }
+    addChild(shape, newChild, translation, rotation, scale) {
+      const parent = shape._pluginData;
+      const child = newChild._pluginData;
+      const t = translation ?? import_math_vector.Vector3.ZeroReadOnly;
+      const r = rotation ?? import_math_vector.Quaternion.Identity();
+      const s = scale ?? import_math_vector.Vector3.OneReadOnly;
+      this._b3._bx_ShapeDesc_AddChild(parent.slot, child.slot, t.x, t.y, t.z, r.x, r.y, r.z, r.w, s.x, s.y, s.z);
+      parent.children.push(child);
+      child.parents.add(parent);
+      this._refreshShapeUsers(parent);
+    }
+    removeChild(shape, childIndex) {
+      const parent = shape._pluginData;
+      this._b3._bx_ShapeDesc_RemoveChild(parent.slot, childIndex);
+      const [child] = parent.children.splice(childIndex, 1);
+      if (child && !parent.children.includes(child)) {
+        child.parents.delete(parent);
+      }
+      this._refreshShapeUsers(parent);
+    }
+    getNumChildren(shape) {
+      return this._b3._bx_ShapeDesc_GetChildCount(shape._pluginData.slot);
+    }
+    getBoundingBox(shape) {
+      this._b3._bx_ShapeDesc_GetAABB(shape._pluginData.slot);
+      const s = this._scratch();
+      import_math_vector.TmpVectors.Vector3[0].set(s[0], s[1], s[2]);
+      import_math_vector.TmpVectors.Vector3[1].set(s[3], s[4], s[5]);
+      return new import_boundingBox.BoundingBox(import_math_vector.TmpVectors.Vector3[0], import_math_vector.TmpVectors.Vector3[1], import_math_vector.Matrix.IdentityReadOnly);
+    }
+    getBodyBoundingBox(body) {
+      const data = this._getPluginReference(body);
+      this._b3._bx_Body_GetAABB(data.slot);
+      const s = this._scratch();
+      import_math_vector.TmpVectors.Vector3[0].set(s[0], s[1], s[2]);
+      import_math_vector.TmpVectors.Vector3[1].set(s[3], s[4], s[5]);
+      return new import_boundingBox.BoundingBox(import_math_vector.TmpVectors.Vector3[0], import_math_vector.TmpVectors.Vector3[1], import_math_vector.Matrix.IdentityReadOnly);
+    }
+    disposeShape(shape) {
+      const data = shape._pluginData;
+      if (!data) {
+        return;
+      }
+      for (const parent of data.parents) {
+        const index = parent.children.indexOf(data);
+        if (index >= 0) {
+          parent.children.splice(index, 1);
+          this._b3._bx_ShapeDesc_RemoveChild(parent.slot, index);
+        }
+      }
+      for (const child of data.children) {
+        child.parents.delete(data);
+      }
+      this._shapes[data.slot] = void 0;
+      this._b3._bx_ShapeDesc_Destroy(data.slot);
+      shape._pluginData = void 0;
+    }
+    setTrigger(shape, isTrigger) {
+      const data = shape._pluginData;
+      this._b3._bx_ShapeDesc_SetSensor(data.slot, isTrigger ? 1 : 0);
+      this._refreshShapeUsers(data);
+    }
+    // ----------------------------------------------------------------------------------------
+    // constraints
+    // ----------------------------------------------------------------------------------------
+    _frameToBuffer(buffer, offset, pivot, xAxis, yAxis, zAxis) {
+      const m = import_math_vector.TmpVectors.Matrix[0];
+      import_math_vector.Matrix.FromValuesToRef(xAxis.x, xAxis.y, xAxis.z, 0, yAxis.x, yAxis.y, yAxis.z, 0, zAxis.x, zAxis.y, zAxis.z, 0, 0, 0, 0, 1, m);
+      const q = this._tmpQuat[2];
+      import_math_vector.Quaternion.FromRotationMatrixToRef(m, q);
+      q.normalize();
+      buffer[offset] = pivot.x;
+      buffer[offset + 1] = pivot.y;
+      buffer[offset + 2] = pivot.z;
+      buffer[offset + 3] = q.x;
+      buffer[offset + 4] = q.y;
+      buffer[offset + 5] = q.z;
+      buffer[offset + 6] = q.w;
+    }
+    _buildFrames(cdata, constraint, bodyA, bodyB) {
+      const options = constraint.options;
+      const pivotA = options.pivotA ?? import_math_vector.Vector3.ZeroReadOnly;
+      const pivotB = options.pivotB ?? import_math_vector.Vector3.ZeroReadOnly;
+      const axisA = (options.axisA ?? import_math_vector.Vector3.RightReadOnly).normalizeToNew();
+      const axisB = (options.axisB ?? import_math_vector.Vector3.RightReadOnly).normalizeToNew();
+      const perpA = options.perpAxisA ? options.perpAxisA.normalizeToNew() : axisA.getNormalToRef(new import_math_vector.Vector3());
+      const perpB = options.perpAxisB ? options.perpAxisB.normalizeToNew() : axisB.getNormalToRef(new import_math_vector.Vector3());
+      perpA.subtractInPlace(axisA.scale(import_math_vector.Vector3.Dot(axisA, perpA))).normalize();
+      perpB.subtractInPlace(axisB.scale(import_math_vector.Vector3.Dot(axisB, perpB))).normalize();
+      const thirdA = import_math_vector.Vector3.Cross(axisA, perpA);
+      const thirdB = import_math_vector.Vector3.Cross(axisB, perpB);
+      if (!constraint._initOptions) {
+        constraint._initOptions = {
+          axisA: axisA.clone(),
+          axisB: axisB.clone(),
+          perpAxisA: perpA.clone(),
+          perpAxisB: perpB.clone(),
+          pivotA: pivotA.clone(),
+          pivotB: pivotB.clone()
+        };
+      }
+      const frames = cdata.frames;
+      if (cdata.plan) {
+        const basis = cdata.plan.basis;
+        if (basis) {
+          const basisA = [axisA, perpA, thirdA];
+          const basisB = [axisB, perpB, thirdB];
+          this._frameToBuffer(frames, 0, pivotA, basisA[basis[0]], basisA[basis[1]], basisA[basis[2]]);
+          this._frameToBuffer(frames, 7, pivotB, basisB[basis[0]], basisB[basis[1]], basisB[basis[2]]);
+        } else {
+          frames.set([pivotA.x, pivotA.y, pivotA.z, 0, 0, 0, 1, pivotB.x, pivotB.y, pivotB.z, 0, 0, 0, 1]);
+        }
+        return;
+      }
+      switch (cdata.type) {
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.HINGE:
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET:
+          this._frameToBuffer(frames, 0, pivotA, perpA, import_math_vector.Vector3.Cross(axisA, perpA), axisA);
+          this._frameToBuffer(frames, 7, pivotB, perpB, import_math_vector.Vector3.Cross(axisB, perpB), axisB);
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.PRISMATIC:
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.SLIDER:
+          this._frameToBuffer(frames, 0, pivotA, axisA, perpA, thirdA);
+          this._frameToBuffer(frames, 7, pivotB, axisB, perpB, thirdB);
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.LOCK: {
+          this._b3._bx_Body_GetTransform(bodyA.slot);
+          let s = this._scratch();
+          const qA = this._tmpQuat[0];
+          qA.set(s[3], s[4], s[5], s[6]);
+          this._b3._bx_Body_GetTransform(bodyB.slot);
+          s = this._scratch();
+          const qB = this._tmpQuat[1];
+          qB.set(s[3], s[4], s[5], s[6]);
+          const rel = qB.invert().multiply(qA).normalize();
+          frames.set([pivotA.x, pivotA.y, pivotA.z, 0, 0, 0, 1, pivotB.x, pivotB.y, pivotB.z, rel.x, rel.y, rel.z, rel.w]);
+          break;
+        }
+        default:
+          frames.set([pivotA.x, pivotA.y, pivotA.z, 0, 0, 0, 1, pivotB.x, pivotB.y, pivotB.z, 0, 0, 0, 1]);
+          break;
+      }
+    }
+    _createJoint(cdata, bodyA, bodyB) {
+      this._scratch().set(cdata.frames);
+      const joint = this._b3._bx_CreateJoint(this._worldSlot, cdata.jointType, bodyA.slot, bodyB.slot, cdata.collisions ? 1 : 0, cdata.length);
+      if (!joint) {
+        import_logger.Logger.Warn("Box3DPlugin: joint creation failed.");
+        return 0;
+      }
+      this._applyAxisState(cdata, joint, bodyA, bodyB);
+      return joint;
+    }
+    /** Reads Physics6DoFConstraint.limits into the axis table with Havok's rules. */
+    _readSixDofLimits(cdata, limits) {
+      for (const limit of limits ?? []) {
+        const state = this._axisState(cdata, limit.axis);
+        if (limit.minLimit === 0 && limit.maxLimit === 0) {
+          state.mode = import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.LOCKED;
+          state.min = 0;
+          state.max = 0;
+        } else if (limit.minLimit !== void 0 || limit.maxLimit !== void 0) {
+          state.mode = import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.LIMITED;
+          state.min = limit.minLimit ?? -Infinity;
+          state.max = limit.maxLimit ?? Infinity;
+        }
+        state.stiffness = limit.stiffness ?? 0;
+        state.damping = limit.damping ?? 0;
+      }
+    }
+    /**
+     * Maps the six axes of a SIX_DOF constraint onto one Box3D joint, following Havok's semantics: an axis that is not
+     * listed is free, 0/0 is locked, anything else is limited. The constraint frame is [axis, perpAxis, axis x perpAxis];
+     * ANGULAR_X rotates about axis, ANGULAR_Y about perpAxis and ANGULAR_Z about axis x perpAxis, all measured as the
+     * rotation of the child frame relative to the parent frame (right handed, like Havok).
+     *  - all linear locked, all angular locked: weld
+     *  - all linear locked, one angular axis open: revolute about it, with its limits (one sided ranges work)
+     *  - all linear locked, two or three angular axes open: spherical, twist limits from ANGULAR_X and one symmetric
+     *    cone from ANGULAR_Y/Z (Box3D has no elliptical cone, the larger swing range is used)
+     *  - two linear locked, angular locked: prismatic along the open linear axis
+     *  - only LINEAR_DISTANCE constrained: distance joint (a spring when min == max and a stiffness is set)
+     *  - nothing constrained: filter joint (collision filtering only)
+     * Anything else warns once and uses the closest of these.
+     */
+    _planSixDof(cdata) {
+      const Axis = import_IPhysicsEnginePlugin.PhysicsConstraintAxis;
+      const Mode = import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode;
+      const mode = (axis) => cdata.axes.get(axis)?.mode ?? Mode.FREE;
+      const range = (axis) => {
+        const state = cdata.axes.get(axis);
+        return state.mode === Mode.LOCKED ? [0, 0] : [Math.min(state.min, state.max), Math.max(state.min, state.max)];
+      };
+      const clamp = (value, limit) => Math.max(-limit, Math.min(limit, value));
+      const maxAngle = 0.99 * Math.PI;
+      const maxLength = 1e5;
+      const plan = {
+        jointType: 0 /* WELD */,
+        basis: [0, 1, 2],
+        primaryAxis: null,
+        coneAngle: -1,
+        twist: null,
+        limit: null,
+        spring: false,
+        stiffness: 0,
+        damping: 0,
+        angularStiffness: false
+      };
+      for (const [axis, state] of cdata.axes) {
+        if ((state.stiffness > 0 || state.damping > 0) && state.stiffness >= plan.stiffness) {
+          plan.stiffness = state.stiffness;
+          plan.damping = state.damping;
+          plan.angularStiffness = axis === Axis.ANGULAR_X || axis === Axis.ANGULAR_Y || axis === Axis.ANGULAR_Z;
+        }
+      }
+      const linear = [Axis.LINEAR_X, Axis.LINEAR_Y, Axis.LINEAR_Z];
+      const angular = [Axis.ANGULAR_X, Axis.ANGULAR_Y, Axis.ANGULAR_Z];
+      const linearLocked = linear.filter((a) => mode(a) === Mode.LOCKED).length;
+      const linearFree = linear.filter((a) => mode(a) === Mode.FREE).length;
+      const angularOpen = angular.filter((a) => mode(a) !== Mode.LOCKED);
+      const angularFree = angular.filter((a) => mode(a) === Mode.FREE).length;
+      const distanceMode = mode(Axis.LINEAR_DISTANCE);
+      if (distanceMode !== Mode.FREE) {
+        if (linearFree === 3 && angularFree === 3) {
+          const [lower, upper] = range(Axis.LINEAR_DISTANCE);
+          plan.jointType = 4 /* DISTANCE */;
+          plan.basis = null;
+          plan.primaryAxis = Axis.LINEAR_DISTANCE;
+          plan.limit = [Math.min(Math.max(0, lower), maxLength), Math.min(Math.max(0, upper), maxLength)];
+          plan.spring = plan.stiffness > 0 && Math.abs(upper - lower) < 1e-6 && isFinite(lower);
+          return plan;
+        }
+        this._warnOnce("sixdof-distance", "SIX_DOF: LINEAR_DISTANCE combined with other constrained axes is not supported with Box3D, the distance limit is ignored.");
+      }
+      let pointJoint = linearLocked === 3;
+      if (!pointJoint && linearLocked !== 2 && linearFree === 0) {
+        this._warnOnce("sixdof-linear-limited", "SIX_DOF: two or more limited linear axes are treated as locked with Box3D.");
+        pointJoint = true;
+      }
+      if (pointJoint) {
+        if (angularOpen.length === 0) {
+          return plan;
+        }
+        if (angularOpen.length === 1) {
+          const axis = angularOpen[0];
+          plan.jointType = 2 /* REVOLUTE */;
+          plan.basis = [
+            [1, 2, 0],
+            [2, 0, 1],
+            [0, 1, 2]
+          ][angular.indexOf(axis)];
+          plan.primaryAxis = axis;
+          if (mode(axis) === Mode.LIMITED) {
+            const [lower, upper] = range(axis);
+            plan.limit = [clamp(lower, maxAngle), clamp(upper, maxAngle)];
+          }
+          return plan;
+        }
+        plan.jointType = 1 /* SPHERICAL */;
+        plan.basis = [1, 2, 0];
+        if (mode(Axis.ANGULAR_X) !== Mode.FREE) {
+          const [lower, upper] = range(Axis.ANGULAR_X);
+          plan.twist = [clamp(lower, maxAngle), clamp(upper, maxAngle)];
+        }
+        const swingModes = [mode(Axis.ANGULAR_Y), mode(Axis.ANGULAR_Z)];
+        if (swingModes.some((m) => m !== Mode.FREE)) {
+          const extents = [];
+          let asymmetric = false;
+          for (const axis of [Axis.ANGULAR_Y, Axis.ANGULAR_Z]) {
+            if (mode(axis) === Mode.FREE) {
+              continue;
+            }
+            const [lower, upper] = range(axis);
+            extents.push(Math.max(Math.abs(lower), Math.abs(upper)));
+            asymmetric || (asymmetric = Math.abs(lower + upper) > 1e-4);
+          }
+          const cone = Math.max(...extents);
+          if (isFinite(cone)) {
+            if (swingModes.includes(Mode.FREE) || Math.abs(extents[0] - extents[1]) > 1e-4 || asymmetric) {
+              this._warnOnce(
+                "sixdof-cone",
+                "SIX_DOF: Box3D has one symmetric swing cone, ANGULAR_Y and ANGULAR_Z use the larger of their ranges."
+              );
+            }
+            if (cone > Math.PI / 2) {
+              this._warnOnce("sixdof-cone-90", "SIX_DOF: Box3D cone limits are at most 90 degrees, larger swing ranges are clamped.");
+            }
+            plan.coneAngle = Math.min(cone, Math.PI / 2);
+          }
+        }
+        return plan;
+      }
+      if (linearLocked === 2) {
+        const slide = linear.find((a) => mode(a) !== Mode.LOCKED);
+        plan.jointType = 3 /* PRISMATIC */;
+        plan.basis = [
+          [0, 1, 2],
+          [1, 2, 0],
+          [2, 0, 1]
+        ][linear.indexOf(slide)];
+        plan.primaryAxis = slide;
+        if (mode(slide) === Mode.LIMITED) {
+          const [lower, upper] = range(slide);
+          plan.limit = [clamp(lower, maxLength), clamp(upper, maxLength)];
+        }
+        if (angularOpen.length) {
+          this._warnOnce("sixdof-prismatic", "SIX_DOF: a sliding axis with rotation is not supported with Box3D, rotation is locked.");
+        }
+        return plan;
+      }
+      plan.jointType = 5 /* FILTER */;
+      plan.basis = null;
+      if (linearFree !== 3 || angularFree !== 3) {
+        this._warnOnce("sixdof-unsupported", "SIX_DOF: this combination of free and limited axes is not supported with Box3D, the bodies are left unconstrained.");
+      }
+      return plan;
+    }
+    /** Box3D spring settings for a Havok spring constant and damping on a body pair. */
+    _springToHertz(stiffness, damping, angular, bodyA, bodyB) {
+      const inverse = (data) => {
+        if (data.motionType !== import_IPhysicsEnginePlugin.PhysicsMotionType.DYNAMIC) {
+          return 0;
+        }
+        this._b3._bx_Body_GetMassData(data.slot);
+        const s = this._scratch();
+        const value = angular ? (s[4] + s[5] + s[6]) / 3 : s[0];
+        return value > 0 ? 1 / value : 0;
+      };
+      const inverseSum = inverse(bodyA) + inverse(bodyB);
+      const mass = inverseSum > 0 ? 1 / inverseSum : 1;
+      const k = Math.max(stiffness, 0);
+      return {
+        hertz: Math.sqrt(k / mass) / (2 * Math.PI),
+        dampingRatio: k > 0 ? damping / (2 * Math.sqrt(k * mass)) : 1
+      };
+    }
+    initConstraint(constraint, body, childBody, instanceIndex, childInstanceIndex) {
+      const type = constraint.type;
+      const options = constraint.options;
+      if (!type || !options) {
+        import_logger.Logger.Warn("No constraint type or options. Constraint is invalid.");
+        return;
+      }
+      if (body._pluginDataInstances.length > 0 && instanceIndex === void 0 || childBody._pluginDataInstances.length > 0 && childInstanceIndex === void 0) {
+        import_logger.Logger.Warn("Body is instanced but no instance index was specified. Constraint will not be applied.");
+        return;
+      }
+      const firstPair = !constraint._pluginData;
+      const cdata = constraint._pluginData ?? new Box3DConstraintData();
+      constraint._pluginData = cdata;
+      cdata.type = type;
+      if (firstPair) {
+        cdata.collisions = !!options.collision;
+      }
+      switch (type) {
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET:
+          cdata.jointType = 1 /* SPHERICAL */;
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.HINGE:
+          cdata.jointType = 2 /* REVOLUTE */;
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.PRISMATIC:
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.SLIDER:
+          cdata.jointType = 3 /* PRISMATIC */;
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.LOCK:
+          cdata.jointType = 0 /* WELD */;
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.DISTANCE:
+          cdata.jointType = 4 /* DISTANCE */;
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.SIX_DOF:
+          if (firstPair) {
+            this._readSixDofLimits(cdata, constraint.limits);
+          }
+          cdata.plan = this._planSixDof(cdata);
+          cdata.jointType = cdata.plan.jointType;
+          break;
+        default:
+          import_logger.Logger.Warn("Box3DPlugin: unknown constraint type " + type);
+          return;
+      }
+      const bodyA = this._getPluginReference(body, instanceIndex);
+      const bodyB = this._getPluginReference(childBody, childInstanceIndex);
+      this._buildFrames(cdata, constraint, bodyA, bodyB);
+      this._updateJointLength(cdata, options.maxDistance, bodyA, bodyB);
+      const joint = cdata.enabled ? this._createJoint(cdata, bodyA, bodyB) : 0;
+      cdata.joints.push(joint);
+      cdata.pairs.push({ parent: body, parentIndex: instanceIndex ?? 0, child: childBody, childIndex: childInstanceIndex ?? 0, parentData: bodyA, childData: bodyB });
+    }
+    /** Length parameter passed to Box3D's distance joint at creation (the rest length of its spring). */
+    _updateJointLength(cdata, maxDistance, bodyA, bodyB) {
+      if (cdata.type === import_IPhysicsEnginePlugin.PhysicsConstraintType.DISTANCE) {
+        cdata.length = maxDistance ?? 0;
+      } else if (cdata.plan?.jointType === 4 /* DISTANCE */ && cdata.plan.limit) {
+        cdata.length = cdata.plan.limit[0];
+      } else {
+        return;
+      }
+      if (cdata.length <= 0) {
+        cdata.length = Math.max(0.01, this._currentPivotDistance(cdata, bodyA, bodyB));
+      }
+    }
+    _currentPivotDistance(cdata, bodyA, bodyB) {
+      const f = cdata.frames;
+      const worldA = this._tmpVec3[0];
+      const worldB = this._tmpVec3[1];
+      this._b3._bx_Body_GetTransform(bodyA.slot);
+      let s = this._scratch();
+      this._tmpQuat[0].set(s[3], s[4], s[5], s[6]);
+      worldA.set(f[0], f[1], f[2]).applyRotationQuaternionInPlace(this._tmpQuat[0]).addInPlaceFromFloats(s[0], s[1], s[2]);
+      this._b3._bx_Body_GetTransform(bodyB.slot);
+      s = this._scratch();
+      this._tmpQuat[0].set(s[3], s[4], s[5], s[6]);
+      worldB.set(f[7], f[8], f[9]).applyRotationQuaternionInPlace(this._tmpQuat[0]).addInPlaceFromFloats(s[0], s[1], s[2]);
+      return import_math_vector.Vector3.Distance(worldA, worldB);
+    }
+    setEnabled(constraint, isEnabled) {
+      const cdata = constraint._pluginData;
+      if (!cdata || cdata.enabled === isEnabled) {
+        return;
+      }
+      cdata.enabled = isEnabled;
+      this._recreateJoints(cdata);
+    }
+    _destroyJoint(joint) {
+      this._motorJoints.delete(joint);
+      this._b3._bx_DestroyJoint(joint);
+    }
+    _recreateJoints(cdata) {
+      for (let i = 0; i < cdata.pairs.length; i++) {
+        if (cdata.joints[i]) {
+          this._destroyJoint(cdata.joints[i]);
+        }
+        const pair = cdata.pairs[i];
+        cdata.joints[i] = cdata.enabled && pair.parentData.slot && pair.childData.slot ? this._createJoint(cdata, pair.parentData, pair.childData) : 0;
+      }
+    }
+    getEnabled(constraint) {
+      return constraint._pluginData?.enabled ?? false;
+    }
+    setCollisionsEnabled(constraint, isEnabled) {
+      const cdata = constraint._pluginData;
+      cdata.collisions = isEnabled;
+      for (const joint of cdata.joints) {
+        if (joint) {
+          this._b3._bx_Joint_SetCollideConnected(joint, isEnabled ? 1 : 0);
+        }
+      }
+    }
+    getCollisionsEnabled(constraint) {
+      return constraint._pluginData?.collisions ?? false;
+    }
+    // The one axis box3d exposes for this constraint type.
+    _primaryAxis(cdata) {
+      switch (cdata.type) {
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.HINGE:
+          return import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_X;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.PRISMATIC:
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.SLIDER:
+          return import_IPhysicsEnginePlugin.PhysicsConstraintAxis.LINEAR_X;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.DISTANCE:
+          return import_IPhysicsEnginePlugin.PhysicsConstraintAxis.LINEAR_DISTANCE;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET:
+          return import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_Y;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintType.SIX_DOF:
+          return cdata.plan?.primaryAxis ?? null;
+        default:
+          return null;
+      }
+    }
+    _isAngularAxis(axis) {
+      return axis === import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_X || axis === import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_Y || axis === import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_Z;
+    }
+    _isPrimaryAxis(cdata, axis) {
+      if (cdata.type === import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET || cdata.plan?.jointType === 1 /* SPHERICAL */) {
+        return this._isAngularAxis(axis);
+      }
+      return axis === this._primaryAxis(cdata);
+    }
+    _axisState(cdata, axis) {
+      let state = cdata.axes.get(axis);
+      if (!state) {
+        state = {
+          mode: import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.FREE,
+          min: 0,
+          max: 0,
+          motor: import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.NONE,
+          target: 0,
+          maxForce: 0,
+          friction: 0,
+          stiffness: 0,
+          damping: 0
+        };
+        cdata.axes.set(axis, state);
+      }
+      return state;
+    }
+    _applyAxisState(cdata, joint, bodyA, bodyB) {
+      const b3 = this._b3;
+      if (cdata.plan) {
+        this._applySixDofPlan(cdata, joint, bodyA, bodyB);
+        b3._bx_Joint_WakeBodies(joint);
+        return;
+      }
+      const primary = this._primaryAxis(cdata);
+      if (primary === null) {
+        return;
+      }
+      for (const [axis, state] of cdata.axes) {
+        if (!this._isPrimaryAxis(cdata, axis)) {
+          continue;
+        }
+        if (cdata.type === import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET) {
+          if (axis === import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_X) {
+            b3._bx_Joint_SetTwistLimits(joint, state.mode === import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.FREE ? 0 : 1, state.min, state.max);
+            continue;
+          }
+        }
+        const limited = state.mode !== import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.FREE;
+        if (limited) {
+          const min = state.mode === import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.LOCKED ? 0 : state.min;
+          const max = state.mode === import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.LOCKED ? 0 : state.max;
+          b3._bx_Joint_SetLimits(joint, min, max);
+        }
+        b3._bx_Joint_EnableLimit(joint, limited ? 1 : 0);
+        if (cdata.type !== import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET) {
+          this._applyMotor(joint, state);
+        }
+      }
+      if (cdata.type === import_IPhysicsEnginePlugin.PhysicsConstraintType.BALL_AND_SOCKET) {
+        this._applySphericalMotor(cdata, joint);
+      }
+      b3._bx_Joint_WakeBodies(joint);
+    }
+    /**
+     * Box3D's spherical joint has one motor for the whole joint: a relative angular velocity, and one spring towards a
+     * target rotation. Babylon has a motor per axis, so the three angular axes are combined into one target in the
+     * joint frame (ANGULAR_X about frame z, ANGULAR_Y about frame x, ANGULAR_Z about frame y).
+     */
+    _applySphericalMotor(cdata, joint) {
+      const b3 = this._b3;
+      const twist = cdata.axes.get(import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_X);
+      const swing1 = cdata.axes.get(import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_Y);
+      const swing2 = cdata.axes.get(import_IPhysicsEnginePlugin.PhysicsConstraintAxis.ANGULAR_Z);
+      const states = [twist, swing1, swing2];
+      const velocity = (state) => state?.motor === import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.VELOCITY ? state.target : 0;
+      const hasVelocity = states.some((state) => state?.motor === import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.VELOCITY);
+      const hasPosition = states.some((state) => state?.motor === import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.POSITION);
+      const maxTorque = Math.max(...states.map((state) => state?.motor === import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.VELOCITY ? state.maxForce : 0));
+      b3._bx_Joint_SetSphericalMotor(joint, hasVelocity ? 1 : 0, velocity(swing1), velocity(swing2), velocity(twist), maxTorque);
+      const target = velocity(swing1) !== 0 || velocity(swing2) !== 0 || velocity(twist) !== 0;
+      if (hasVelocity && target) {
+        this._motorJoints.add(joint);
+      } else {
+        this._motorJoints.delete(joint);
+      }
+      b3._bx_Joint_EnableSpring(joint, hasPosition ? 1 : 0);
+      if (hasPosition) {
+        const position = (state) => state?.motor === import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.POSITION ? state.target : 0;
+        const rotation = this._tmpQuat[0];
+        import_math_vector.Quaternion.RotationYawPitchRollToRef(0, 0, position(twist), rotation);
+        const swing = this._tmpQuat[1];
+        import_math_vector.Quaternion.RotationYawPitchRollToRef(position(swing2), position(swing1), 0, swing);
+        rotation.multiplyInPlace(swing);
+        b3._bx_Joint_SetSpring(joint, 5, 1);
+        b3._bx_Joint_SetSphericalTarget(joint, rotation.x, rotation.y, rotation.z, rotation.w);
+      }
+    }
+    _applyMotor(joint, state) {
+      const b3 = this._b3;
+      switch (state.motor) {
+        case import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.VELOCITY:
+          b3._bx_Joint_EnableSpring(joint, 0);
+          b3._bx_Joint_EnableMotor(joint, 1);
+          b3._bx_Joint_SetMotorSpeed(joint, state.target);
+          b3._bx_Joint_SetMaxMotorForce(joint, state.maxForce);
+          break;
+        case import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.POSITION:
+          b3._bx_Joint_EnableMotor(joint, 0);
+          b3._bx_Joint_EnableSpring(joint, 1);
+          b3._bx_Joint_SetSpring(joint, 5, 1);
+          b3._bx_Joint_SetTarget(joint, state.target);
+          break;
+        default:
+          b3._bx_Joint_EnableMotor(joint, 0);
+          b3._bx_Joint_EnableSpring(joint, 0);
+          break;
+      }
+    }
+    /** Applies a SIX_DOF plan's limits, springs and motors to one of its Box3D joints. */
+    _applySixDofPlan(cdata, joint, bodyA, bodyB) {
+      const b3 = this._b3;
+      const plan = cdata.plan;
+      switch (plan.jointType) {
+        case 1 /* SPHERICAL */:
+          if (plan.coneAngle >= 0) {
+            b3._bx_Joint_SetLimits(joint, -plan.coneAngle, plan.coneAngle);
+          }
+          b3._bx_Joint_EnableLimit(joint, plan.coneAngle >= 0 ? 1 : 0);
+          b3._bx_Joint_SetTwistLimits(joint, plan.twist ? 1 : 0, plan.twist ? plan.twist[0] : 0, plan.twist ? plan.twist[1] : 0);
+          break;
+        case 2 /* REVOLUTE */:
+        case 3 /* PRISMATIC */:
+          if (plan.limit) {
+            b3._bx_Joint_SetLimits(joint, plan.limit[0], plan.limit[1]);
+          }
+          b3._bx_Joint_EnableLimit(joint, plan.limit ? 1 : 0);
+          break;
+        case 4 /* DISTANCE */:
+          if (plan.spring) {
+            const spring = this._springToHertz(plan.stiffness, plan.damping, false, bodyA, bodyB);
+            b3._bx_Joint_EnableLimit(joint, 0);
+            b3._bx_Joint_EnableSpring(joint, 1);
+            b3._bx_Joint_SetSpring(joint, spring.hertz, spring.dampingRatio);
+            b3._bx_Joint_SetTarget(joint, cdata.length);
+          } else {
+            b3._bx_Joint_SetLimits(joint, plan.limit[0], plan.limit[1]);
+            b3._bx_Joint_EnableLimit(joint, 1);
+            b3._bx_Joint_EnableSpring(joint, 1);
+            b3._bx_Joint_SetSpring(joint, 0, 0);
+          }
+          break;
+        default:
+          break;
+      }
+      if (plan.stiffness > 0 && !plan.spring) {
+        this._warnOnce(
+          "sixdof-softness",
+          "SIX_DOF: limit stiffness and damping are approximated with Box3D's per joint constraint softness, which applies to every axis of the joint."
+        );
+        const soft = this._springToHertz(plan.stiffness, plan.damping, plan.angularStiffness, bodyA, bodyB);
+        b3._bx_Joint_SetConstraintTuning(joint, soft.hertz, soft.dampingRatio);
+      }
+      if (plan.jointType === 1 /* SPHERICAL */) {
+        this._applySphericalMotor(cdata, joint);
+      } else if (plan.primaryAxis !== null && plan.jointType !== 4 /* DISTANCE */) {
+        const state = cdata.axes.get(plan.primaryAxis);
+        if (state) {
+          this._applyMotor(joint, state);
+        }
+      }
+    }
+    _setAxis(constraint, axis, apply) {
+      const cdata = constraint._pluginData;
+      if (!cdata) {
+        return;
+      }
+      const state = this._axisState(cdata, axis);
+      const previousMotor = { motor: state.motor, target: state.target, maxForce: state.maxForce };
+      apply(state);
+      if (cdata.plan) {
+        const plan = this._planSixDof(cdata);
+        const rebuild = plan.jointType !== cdata.plan.jointType || String(plan.basis) !== String(cdata.plan.basis);
+        cdata.plan = plan;
+        cdata.jointType = plan.jointType;
+        const motorChanged = previousMotor.motor !== state.motor || previousMotor.target !== state.target || previousMotor.maxForce !== state.maxForce;
+        if (motorChanged && state.motor !== import_IPhysicsEnginePlugin.PhysicsConstraintMotorType.NONE && !this._isPrimaryAxis(cdata, axis)) {
+          this._warnOnce(`axis-motor-${axis}`, `SIX_DOF: a motor on axis ${axis} has no effect with the Box3D joint this constraint maps to.`);
+        }
+        const first = cdata.pairs[0];
+        if (first) {
+          this._updateJointLength(cdata, constraint.options.maxDistance, first.parentData, first.childData);
+        }
+        if (rebuild) {
+          if (first) {
+            this._buildFrames(cdata, constraint, first.parentData, first.childData);
+          }
+          this._recreateJoints(cdata);
+          return;
+        }
+      } else if (!this._isPrimaryAxis(cdata, axis)) {
+        this._warnOnce(`axis-${cdata.type}-${axis}`, `axis ${axis} is not configurable on constraint type ${cdata.type} with Box3D; the value is stored but has no effect.`);
+        return;
+      }
+      for (let i = 0; i < cdata.joints.length; i++) {
+        if (cdata.joints[i]) {
+          this._applyAxisState(cdata, cdata.joints[i], cdata.pairs[i].parentData, cdata.pairs[i].childData);
+        }
+      }
+    }
+    setAxisFriction(constraint, axis, friction) {
+      const cdata = constraint._pluginData;
+      if (cdata) {
+        this._axisState(cdata, axis).friction = friction;
+      }
+    }
+    getAxisFriction(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.friction ?? null;
+    }
+    setAxisMode(constraint, axis, limitMode) {
+      this._setAxis(constraint, axis, (state) => state.mode = limitMode);
+    }
+    getAxisMode(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.mode ?? null;
+    }
+    setAxisMinLimit(constraint, axis, minLimit) {
+      this._setAxis(constraint, axis, (state) => {
+        state.min = minLimit;
+        if (state.mode === import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.FREE) {
+          state.mode = import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.LIMITED;
+        }
+      });
+    }
+    getAxisMinLimit(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.min ?? null;
+    }
+    setAxisMaxLimit(constraint, axis, limit) {
+      this._setAxis(constraint, axis, (state) => {
+        state.max = limit;
+        if (state.mode === import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.FREE) {
+          state.mode = import_IPhysicsEnginePlugin.PhysicsConstraintAxisLimitMode.LIMITED;
+        }
+      });
+    }
+    getAxisMaxLimit(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.max ?? null;
+    }
+    setAxisMotorType(constraint, axis, motorType) {
+      this._setAxis(constraint, axis, (state) => state.motor = motorType);
+    }
+    getAxisMotorType(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.motor ?? null;
+    }
+    setAxisMotorTarget(constraint, axis, target) {
+      this._setAxis(constraint, axis, (state) => state.target = target);
+    }
+    getAxisMotorTarget(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.target ?? null;
+    }
+    setAxisMotorMaxForce(constraint, axis, maxForce) {
+      this._setAxis(constraint, axis, (state) => state.maxForce = maxForce);
+    }
+    getAxisMotorMaxForce(constraint, axis) {
+      return constraint._pluginData?.axes.get(axis)?.maxForce ?? null;
+    }
+    disposeConstraint(constraint) {
+      const cdata = constraint._pluginData;
+      if (!cdata) {
+        return;
+      }
+      for (const joint of cdata.joints) {
+        if (joint) {
+          this._destroyJoint(joint);
+        }
+      }
+      cdata.joints.length = 0;
+      cdata.pairs.length = 0;
+    }
+    getBodiesUsingConstraint(constraint) {
+      const cdata = constraint._pluginData;
+      if (!cdata) {
+        return [];
+      }
+      return cdata.pairs.map((p) => ({ parentBody: p.parent, parentBodyIndex: p.parentIndex, childBody: p.child, childBodyIndex: p.childIndex }));
+    }
+    addConstraint(body, childBody, constraint, instanceIndex, childInstanceIndex) {
+      this.initConstraint(constraint, body, childBody, instanceIndex, childInstanceIndex);
+    }
+    // ----------------------------------------------------------------------------------------
+    // Box3D specific extras
+    // ----------------------------------------------------------------------------------------
+    /**
+     * Applies a radial impulse to every shape within the radius, like a grenade.
+     * @param position world position of the explosion
+     * @param radius radius of the explosion
+     * @param impulsePerArea impulse per surface area of the affected shapes
+     * @param falloff distance beyond the radius over which the impulse fades to zero
+     */
+    explode(position, radius, impulsePerArea, falloff = 0) {
+      this._b3._bx_World_Explode(this._worldSlot, position.x, position.y, position.z, radius, falloff, impulsePerArea);
+    }
+    /**
+     * Box2D style collision group. Shapes sharing a negative group never collide with each other,
+     * shapes sharing a positive group always collide. Zero means no group.
+     * @param shape the shape
+     * @param groupIndex the group index
+     */
+    setShapeFilterGroup(shape, groupIndex) {
+      const data = shape._pluginData;
+      this._b3._bx_ShapeDesc_SetGroup(data.slot, groupIndex | 0);
+      this._syncShapeUsers(data, 1 /* FILTER */);
+    }
+    /**
+     * Rolling resistance for spheres and capsules (Babylon materials have no equivalent).
+     * @param shape the shape
+     * @param value resistance, typically in [0, 1]
+     */
+    setShapeRollingResistance(shape, value) {
+      const data = shape._pluginData;
+      this._b3._bx_ShapeDesc_SetRollingResistance(data.slot, value);
+      this._syncShapeUsers(data, 2 /* MATERIAL */);
+    }
+    /**
+     * Lets a body spin faster than the default angular speed cap (wheels).
+     * @param body the body
+     * @param allow true to allow fast rotation
+     * @param instanceIndex optional thin instance index
+     */
+    setAllowFastRotation(body, allow, instanceIndex) {
+      this._applyToBodyOrInstances(body, (data) => this._b3._bx_Body_AllowFastRotation(data.slot, allow ? 1 : 0), instanceIndex);
+    }
+    /**
+     * Creates a Box3D wheel joint between a chassis and a wheel body.
+     * @param chassis the chassis body
+     * @param wheel the wheel body
+     * @param options wheel joint options
+     * @returns a handle used to drive and steer the wheel
+     */
+    createWheelJoint(chassis, wheel, options) {
+      const s = this._scratch();
+      const axisA = (options.axisA ?? import_math_vector.Vector3.UpReadOnly).normalizeToNew();
+      const axleA = (options.axleA ?? import_math_vector.Vector3.Forward()).normalizeToNew();
+      axleA.subtractInPlace(axisA.scale(import_math_vector.Vector3.Dot(axisA, axleA))).normalize();
+      this._frameToBuffer(s, 0, options.pivotA, axisA, import_math_vector.Vector3.Cross(axleA, axisA), axleA);
+      const pivotB = options.pivotB ?? import_math_vector.Vector3.ZeroReadOnly;
+      s[7] = pivotB.x;
+      s[8] = pivotB.y;
+      s[9] = pivotB.z;
+      const chassisData = this._getPluginReference(chassis);
+      const wheelData = this._getPluginReference(wheel);
+      this._b3._bx_ComputeAlignedFrameB(chassisData.slot, wheelData.slot);
+      const susp = options.suspensionLimits ?? [-0.2, 0.2];
+      const steer = options.steeringLimits ?? [-Math.PI / 4, Math.PI / 4];
+      s.set(
+        [
+          1,
+          options.suspensionHertz ?? 4,
+          options.suspensionDampingRatio ?? 0.7,
+          1,
+          susp[0],
+          susp[1],
+          options.enableSpinMotor ? 1 : 0,
+          options.maxSpinTorque ?? 5,
+          0,
+          options.enableSteering ? 1 : 0,
+          options.steeringHertz ?? 10,
+          options.steeringDampingRatio ?? 0.7,
+          0,
+          options.maxSteeringTorque ?? 5,
+          1,
+          steer[0],
+          steer[1]
+        ],
+        14
+      );
+      const slot = this._b3._bx_CreateJoint(this._worldSlot, 6 /* WHEEL */, chassisData.slot, wheelData.slot, 0, 0);
+      if (!slot) {
+        throw new Error("Box3DPlugin: wheel joint creation failed");
+      }
+      return new Box3DWheelJoint(this, slot);
+    }
+    /**
+     * Creates a Box3D parallel joint: a spring that keeps a local axis of bodyB parallel to an axis
+     * of bodyA, for example to keep a vehicle upright without locking its motion.
+     * @param bodyA first body (often a static body)
+     * @param bodyB body to align
+     * @param axisA axis in bodyA local space
+     * @param axisB axis in bodyB local space
+     * @param hertz spring stiffness
+     * @param dampingRatio spring damping
+     * @param maxTorque maximum spring torque
+     * @returns a joint slot that can be passed to disposeExtraJoint
+     */
+    createParallelJoint(bodyA, bodyB, axisA, axisB, hertz = 1, dampingRatio = 1, maxTorque = 34e37) {
+      const s = this._scratch();
+      const a = axisA.normalizeToNew();
+      const pa = a.getNormalToRef(new import_math_vector.Vector3());
+      this._frameToBuffer(s, 0, import_math_vector.Vector3.ZeroReadOnly, pa, import_math_vector.Vector3.Cross(a, pa), a);
+      const b = axisB.normalizeToNew();
+      const pb = b.getNormalToRef(new import_math_vector.Vector3());
+      this._frameToBuffer(s, 7, import_math_vector.Vector3.ZeroReadOnly, pb, import_math_vector.Vector3.Cross(b, pb), b);
+      s.set([hertz, dampingRatio, maxTorque], 14);
+      return this._b3._bx_CreateJoint(this._worldSlot, 7 /* PARALLEL */, this._getPluginReference(bodyA).slot, this._getPluginReference(bodyB).slot, 1, 0);
+    }
+    /**
+     * Destroys a joint created by createParallelJoint.
+     * @param slot the joint slot
+     */
+    disposeExtraJoint(slot) {
+      this._destroyExtraJoint(slot);
+    }
+    /**
+     * @internal
+     */
+    _destroyExtraJoint(slot) {
+      if (slot) {
+        this._destroyJoint(slot);
+      }
+    }
+    /**
+     * @internal
+     */
+    _wheelCall(fn, slot, ...args) {
+      if (slot) {
+        this._b3[fn](slot, ...args);
+      }
+    }
+    // ----------------------------------------------------------------------------------------
+    // queries
+    // ----------------------------------------------------------------------------------------
+    raycast(from, to, result, query) {
+      const results = Array.isArray(result) ? result : [result];
+      for (const r of results) {
+        r.reset(from, to);
+      }
+      const membership = (query?.membership ?? ~0) >>> 0;
+      const collideWith = (query?.collideWith ?? ~0) >>> 0;
+      const ignore = query?.ignoreBody ? query.ignoreBody._pluginData?.slot ?? 0 : 0;
+      const closestOnly = results.length === 1;
+      const count = this._b3._bx_World_CastRay(
+        this._worldSlot,
+        from.x,
+        from.y,
+        from.z,
+        to.x - from.x,
+        to.y - from.y,
+        to.z - from.z,
+        membership,
+        collideWith,
+        ignore,
+        query?.shouldHitTriggers ? 1 : 0,
+        closestOnly ? 1 : 0
+      );
+      if (count <= 0) {
+        return;
+      }
+      const buffer = new Float32Array(this._b3.HEAPF32.buffer, this._b3._bx_RayHitsPtr(), count * RAY_STRIDE);
+      const hits = [];
+      for (let i = 0; i < count; i++) {
+        hits.push(i);
+      }
+      hits.sort((a, b) => buffer[a * RAY_STRIDE + 6] - buffer[b * RAY_STRIDE + 6]);
+      if (!results.length) {
+        for (let i = 0; i < count; i++) {
+          const r = new import_physicsRaycastResult.PhysicsRaycastResult();
+          r.reset(from, to);
+          results.push(r);
+        }
+      }
+      const n = Math.min(count, results.length);
+      for (let i = 0; i < n; i++) {
+        const o = hits[i] * RAY_STRIDE;
+        const r = results[i];
+        const bodyRef = this._bodies[buffer[o + 7]];
+        r.body = bodyRef?.body;
+        r.bodyIndex = bodyRef?.index;
+        r.shape = bodyRef?.body.shape ?? void 0;
+        r.setHitData({ x: buffer[o + 3], y: buffer[o + 4], z: buffer[o + 5] }, { x: buffer[o], y: buffer[o + 1], z: buffer[o + 2] }, buffer[o + 9]);
+        r.calculateHitDistance();
+      }
+    }
+    // ----------------------------------------------------------------------------------------
+    // events
+    // ----------------------------------------------------------------------------------------
+    /**
+     * Copies `count` event records out of wasm memory and resolves their two body slots (at `slotOffset`) to the plugin's
+     * body references. Observers run user code that can grow the wasm memory, which detaches every HEAPF32 view (creating
+     * bodies or shapes, casting rays), or dispose bodies and hand their slots to new ones, so nothing is read from wasm
+     * memory or the slot table once the first observer has been called.
+     */
+    _readEvents(pointer, count, stride, slotOffset) {
+      const records = new Float32Array(this._b3.HEAPF32.buffer, pointer, count * stride).slice();
+      const refs = new Array(count * 2);
+      for (let i = 0; i < count; i++) {
+        refs[i * 2] = this._bodies[records[i * stride + slotOffset]];
+        refs[i * 2 + 1] = this._bodies[records[i * stride + slotOffset + 1]];
+      }
+      return { records, refs };
+    }
+    _notifyCollisions() {
+      const count = this._b3._bx_World_GetContactEvents(this._worldSlot);
+      if (!count) {
+        return;
+      }
+      const { records: buffer, refs } = this._readEvents(this._b3._bx_ContactEventsPtr(), count, CONTACT_STRIDE, 3);
+      for (let i = 0; i < count; i++) {
+        const o = i * CONTACT_STRIDE;
+        const kind = buffer[o];
+        const refA = refs[i * 2];
+        const refB = refs[i * 2 + 1];
+        if (!refA || !refB || !refA.data.slot || !refB.data.slot) {
+          continue;
+        }
+        const bit = kind === 0 ? 1 /* COLLISION_STARTED */ : kind === 1 ? 4 /* COLLISION_FINISHED */ : 2 /* COLLISION_CONTINUED */;
+        if (((refA.data.eventMask | refB.data.eventMask) & bit) === 0) {
+          continue;
+        }
+        if (kind === 1) {
+          const ended = {
+            collider: refA.body,
+            colliderIndex: refA.index,
+            collidedAgainst: refB.body,
+            collidedAgainstIndex: refB.index,
+            type: import_IPhysicsEnginePlugin.PhysicsEventType.COLLISION_FINISHED
+          };
+          this.onCollisionEndedObservable.notifyObservers(ended);
+          this._bodyCollisionEndedObservable.get(refA.data.slot)?.notifyObservers(ended);
+          const endedB = this._bodyCollisionEndedObservable.get(refB.data.slot);
+          if (endedB) {
+            endedB.notifyObservers({ ...ended, collider: refB.body, colliderIndex: refB.index, collidedAgainst: refA.body, collidedAgainstIndex: refA.index });
+          }
+          continue;
+        }
+        const type = kind === 0 ? import_IPhysicsEnginePlugin.PhysicsEventType.COLLISION_STARTED : import_IPhysicsEnginePlugin.PhysicsEventType.COLLISION_CONTINUED;
+        const point = new import_math_vector.Vector3(buffer[o + 5], buffer[o + 6], buffer[o + 7]);
+        const normal = new import_math_vector.Vector3(buffer[o + 8], buffer[o + 9], buffer[o + 10]);
+        const info = {
+          collider: refA.body,
+          colliderIndex: refA.index,
+          collidedAgainst: refB.body,
+          collidedAgainstIndex: refB.index,
+          type,
+          point,
+          normal,
+          distance: 0,
+          impulse: buffer[o + 11]
+        };
+        this.onCollisionObservable.notifyObservers(info);
+        if (this._bodyCollisionObservable.size) {
+          this._bodyCollisionObservable.get(refA.data.slot)?.notifyObservers(info);
+          const obsB = this._bodyCollisionObservable.get(refB.data.slot);
+          if (obsB) {
+            obsB.notifyObservers({
+              ...info,
+              collider: refB.body,
+              colliderIndex: refB.index,
+              collidedAgainst: refA.body,
+              collidedAgainstIndex: refA.index,
+              normal: normal ? normal.negate() : null
+            });
+          }
+        }
+      }
+    }
+    _notifyTriggers() {
+      const count = this._b3._bx_World_GetSensorEvents(this._worldSlot);
+      if (!count || !this.onTriggerCollisionObservable.hasObservers()) {
+        return;
+      }
+      const { records: buffer, refs } = this._readEvents(this._b3._bx_SensorEventsPtr(), count, SENSOR_STRIDE, 3);
+      for (let i = 0; i < count; i++) {
+        const o = i * SENSOR_STRIDE;
+        const refA = refs[i * 2];
+        const refB = refs[i * 2 + 1];
+        if (!refA || !refB || !refA.data.slot || !refB.data.slot) {
+          continue;
+        }
+        this.onTriggerCollisionObservable.notifyObservers({
+          collider: refA.body,
+          colliderIndex: refA.index,
+          collidedAgainst: refB.body,
+          collidedAgainstIndex: refB.index,
+          type: buffer[o] === 0 ? import_IPhysicsEnginePlugin.PhysicsEventType.TRIGGER_ENTERED : import_IPhysicsEnginePlugin.PhysicsEventType.TRIGGER_EXITED
+        });
+      }
+    }
+    dispose() {
+      this._motorJoints.clear();
+      this.onCollisionObservable.clear();
+      this.onCollisionEndedObservable.clear();
+      this.onTriggerCollisionObservable.clear();
+      this._bodyCollisionObservable.clear();
+      this._bodyCollisionEndedObservable.clear();
+      for (const shape of this._shapes) {
+        if (shape) {
+          this._b3._bx_ShapeDesc_Destroy(shape.slot);
+        }
+      }
+      this._shapes.length = 0;
+      this._bodies.length = 0;
+      if (this._worldSlot) {
+        this._b3._bx_DestroyWorld(this._worldSlot);
+        this._worldSlot = 0;
+      }
+    }
+  };
+
+  // box3d-global:babylon-box3d/wasm
+  if (typeof Box3D === "undefined") {
+    throw new Error("babylon.box3d.js needs lib/umd/box3d.umd.js loaded first");
+  }
+  var wasm_default = Box3D;
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=babylon.box3d.js.map