@perplexdotgg/bounce 1.3.1 → 1.4.0

package/build/bounce.js

@@ -1959,6 +1959,7 @@ class Aabb extends createClass(aabbProps) {
     this.min.minVectors(boxA.min, boxB.min);
     this.max.maxVectors(boxA.max, boxB.max);
     this.computeCentroid(this.centroid);
+    return this;
   }
   expand(value) {
     this.min.x -= value;
@@ -4027,7 +4028,6 @@ const CollisionFilter = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.def
   shouldPairCollide,
   toggleFlag
 }, Symbol.toStringTag, { value: "Module" }));
-const expandedObjectBounds = /* @__PURE__ */ Aabb.create();
 const leftAabb = /* @__PURE__ */ Aabb.create();
 const rightAabb = /* @__PURE__ */ Aabb.create();
 const centroidBounds$1 = /* @__PURE__ */ Aabb.create();
@@ -4086,7 +4086,7 @@ class BvhTree {
   }
   updateDirtyObjects() {
     for (const object of this.dirtyObjects) {
-      if (this.update(object, false)) ;
+      this.update(object, false);
     }
     this.dirtyObjects.clear();
   }
@@ -4175,7 +4175,7 @@ class BvhTree {
         node.computedBounds.min.fromArray([Infinity, Infinity, Infinity]);
         node.computedBounds.max.fromArray([-Infinity, -Infinity, -Infinity]);
         for (const object of node.objects) {
-          node.computedBounds.unionAabb(object.computedBounds);
+          node.computedBounds.unionAabb(object.computedExpandedBounds);
         }
         node.height = 0;
       } else {
@@ -4265,11 +4265,11 @@ class BvhTree {
   destroyBvhNode(node) {
     node.destroy();
   }
-  insert(object, shouldUpdateDirtyObjects = true) {
-    expandedObjectBounds.expandAabb(object.computedBounds, this.options.expansionMargin);
+  insert(object) {
+    object.computedExpandedBounds.expandAabb(object.computedBounds, this.options.expansionMargin);
     if (!this.root) {
       const root = this.createBvhNode();
-      root.computedBounds.copy(expandedObjectBounds);
+      root.computedBounds.copy(object.computedExpandedBounds);
       root.objects.push(object);
       root.height = 0;
       this.root = root;
@@ -4288,7 +4288,7 @@ class BvhTree {
     }
     if (best.objects.length < this.options.maxObjectsPerLeaf || best.height >= this.options.maxDepth) {
       best.objects.push(object);
-      best.computedBounds.unionAabb(expandedObjectBounds);
+      best.computedBounds.unionAabb(object.computedExpandedBounds);
       object.node = best;
       return this.refit(best);
     }
@@ -4297,15 +4297,15 @@ class BvhTree {
     best.objects.push(object);
     this.splitObjects(left, right, best);
     best.objects.length = 0;
-    left.computedBounds.copy(left.objects.getAtIndex(0).computedBounds);
+    left.computedBounds.copy(left.objects.getAtIndex(0).computedExpandedBounds);
     for (let i = 1; i < left.objects.length; i++) {
-      left.computedBounds.unionAabb(left.objects.getAtIndex(i).computedBounds);
+      left.computedBounds.unionAabb(left.objects.getAtIndex(i).computedExpandedBounds);
     }
     left.parent = best;
     left.height = 0;
-    right.computedBounds.copy(right.objects.getAtIndex(0).computedBounds);
+    right.computedBounds.copy(right.objects.getAtIndex(0).computedExpandedBounds);
     for (let i = 1; i < right.objects.length; i++) {
-      right.computedBounds.unionAabb(right.objects.getAtIndex(i).computedBounds);
+      right.computedBounds.unionAabb(right.objects.getAtIndex(i).computedExpandedBounds);
     }
     right.parent = best;
     right.height = 0;
@@ -4365,7 +4365,7 @@ class BvhTree {
     this.remove(object);
     return this.insert(object);
   }
-  intersectBody(onHit2, body2, shouldUpdateDirtyObjects = true) {
+  intersectBody(onHit2, bodyToIntersect, shouldUpdateDirtyObjects = true) {
     if (!this.root) {
       return;
     }
@@ -4380,7 +4380,7 @@ class BvhTree {
       if (!node) {
         continue;
       }
-      if (!node.computedBounds.intersectsAabb(body2.computedBounds)) {
+      if (!node.computedBounds.intersectsAabb(bodyToIntersect.computedBounds)) {
         continue;
       }
       if (!node.isLeaf()) {
@@ -4389,21 +4389,40 @@ class BvhTree {
         continue;
       }
       for (const otherBody of node.objects) {
-        if (body2 === otherBody) {
+        if (bodyToIntersect === otherBody || !shouldPairCollide(bodyToIntersect.belongsToGroups, bodyToIntersect.collidesWithGroups, otherBody.belongsToGroups, otherBody.collidesWithGroups) || !bodyToIntersect.computedBounds.intersectsAabb(otherBody.computedBounds)) {
           continue;
         }
-        if (shouldPairCollide(
-          body2.belongsToGroups,
-          body2.collidesWithGroups,
-          otherBody.belongsToGroups,
-          otherBody.collidesWithGroups
-        ) === false) {
-          continue;
+        if (onHit2(otherBody)) {
+          return;
         }
-        if (!body2.computedBounds.intersectsAabb(otherBody.computedBounds)) {
+      }
+    }
+  }
+  intersectAabb(onHit2, bounds, shouldUpdateDirtyObjects = true) {
+    if (!this.root) {
+      return;
+    }
+    if (shouldUpdateDirtyObjects) {
+      this.updateDirtyObjects();
+    }
+    const stack2 = this.intersectStack;
+    stack2.length = 0;
+    stack2.push(this.root);
+    while (stack2.length > 0) {
+      const node = stack2.pop();
+      if (!node.computedBounds.intersectsAabb(bounds)) {
+        continue;
+      }
+      if (!node.isLeaf()) {
+        stack2.push(node.left);
+        stack2.push(node.right);
+        continue;
+      }
+      for (const object of node.objects) {
+        if (!bounds.intersectsAabb(object.computedBounds)) {
           continue;
         }
-        if (onHit2(otherBody)) {
+        if (onHit2(object)) {
           return;
         }
       }
@@ -4445,10 +4464,7 @@ class BvhTree {
     stack2.push(this.root);
     while (stack2.length > 0) {
       const node = stack2.pop();
-      if (!node) {
-        continue;
-      }
-      if (node.computedBounds.intersectsAabb(bounds) === false) {
+      if (!node || !node.computedBounds.intersectsAabb(bounds)) {
         continue;
       }
       if (!node.isLeaf()) {
@@ -4457,10 +4473,7 @@ class BvhTree {
         continue;
       }
       for (const body2 of node.objects) {
-        if (shouldPairCollide(body2.belongsToGroups, body2.collidesWithGroups, belongsToGroups, collidesWithGroups) === false) {
-          continue;
-        }
-        if (!body2.computedBounds.intersectsAabb(bounds)) {
+        if (!shouldPairCollide(body2.belongsToGroups, body2.collidesWithGroups, belongsToGroups, collidesWithGroups) || !body2.computedBounds.intersectsAabb(bounds)) {
           continue;
         }
         bodyVisitor.visit(body2);
@@ -4486,7 +4499,7 @@ class BvhTree {
         continue;
       }
       nodeBounds$1.copy(node.computedBounds);
-      if (ray2.intersectsAabb(nodeBounds$1) === false) {
+      if (!ray2.intersectsAabb(nodeBounds$1)) {
         continue;
       }
       if (!node.isLeaf()) {
@@ -4495,11 +4508,11 @@ class BvhTree {
         continue;
       }
       for (const body2 of node.objects) {
-        if (shouldPairCollide(body2.belongsToGroups, body2.collidesWithGroups, belongsToGroups, collidesWithGroups) === false) {
+        if (!shouldPairCollide(body2.belongsToGroups, body2.collidesWithGroups, belongsToGroups, collidesWithGroups)) {
           continue;
         }
         bodyBounds$1.copy(body2.computedBounds);
-        if (ray2.intersectsAabb(bodyBounds$1) === false) {
+        if (!ray2.intersectsAabb(bodyBounds$1)) {
           continue;
         }
         bodyVisitor.visit(body2);
@@ -4530,7 +4543,7 @@ class BvhTree {
       }
       nodeBounds$1.copy(node.computedBounds);
       nodeBounds$1.expandByVector(halfExtents$2);
-      if (ray$4.intersectsAabb(nodeBounds$1) === false) {
+      if (!ray$4.intersectsAabb(nodeBounds$1)) {
         continue;
       }
       if (!node.isLeaf()) {
@@ -4539,12 +4552,12 @@ class BvhTree {
         continue;
       }
       for (const body2 of node.objects) {
-        if (shouldPairCollide(body2.belongsToGroups, body2.collidesWithGroups, belongsToGroups, collidesWithGroups) === false) {
+        if (!shouldPairCollide(body2.belongsToGroups, body2.collidesWithGroups, belongsToGroups, collidesWithGroups)) {
           continue;
         }
         bodyBounds$1.copy(body2.computedBounds);
         bodyBounds$1.expandByVector(halfExtents$2);
-        if (ray$4.intersectsAabb(bodyBounds$1) === false) {
+        if (!ray$4.intersectsAabb(bodyBounds$1)) {
           continue;
         }
         bodyVisitor.visit(body2);
@@ -7991,6 +8004,7 @@ const bodyProps = {
   angularVelocity: Vec3,
   computedCenterOfMassPosition: ChildType(Vec3, void 0, true),
   computedBounds: ChildType(Aabb, void 0, true),
+  computedExpandedBounds: ChildType(Aabb, void 0, true),
   previousPosition: ChildType(Vec3, void 0, true),
   previousOrientation: ChildType(Quat, void 0, true),
   isSleeping: BooleanType(false, true),
@@ -8042,6 +8056,9 @@ class Body extends createClass(bodyProps, { afterConstructorCode }) {
     return this["shape" + this.shapeType];
   }
   set shape(newShape) {
+    this.setShape(newShape);
+  }
+  setShape(newShape, updateBroadphase = true) {
     this["shape" + this.shapeType] = null;
     this["shape" + newShape.type] = newShape;
     this.shapeType = newShape.type;
@@ -8063,7 +8080,9 @@ class Body extends createClass(bodyProps, { afterConstructorCode }) {
       newShape.computedVolume = hull.computedVolume;
       newShape.inertia.copy(hull.inertia);
     }
-    updateBody(this);
+    if (updateBroadphase) {
+      updateBody(this);
+    }
   }
   // physics integration functions
   /**
@@ -8379,112 +8398,13 @@ function updateMassProperties(body2) {
   body2.shape.computeInverseInertiaTensor(body2.computedLocalInverseInertia, body2.mass);
   transformTensor(body2.computedWorldInverseInertia, body2.computedLocalInverseInertia, body2.orientation);
 }
-function updateBody(body2) {
+function updateBody(body2, updateBroadphase = true) {
   updateMassProperties(body2);
   updateCenterOfMassPosition(body2);
   updateWorldBounds(body2);
-}
-var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
-  CollisionStatus2[CollisionStatus2["NotColliding"] = 0] = "NotColliding";
-  CollisionStatus2[CollisionStatus2["Colliding"] = 1] = "Colliding";
-  CollisionStatus2[CollisionStatus2["Indeterminate"] = 2] = "Indeterminate";
-  return CollisionStatus2;
-})(CollisionStatus || {});
-const collisionResultProps = {
-  status: NumberType(
-    2
-    /* Indeterminate */
-  ),
-  hasContact: BooleanType(false),
-  penetration: 0,
-  contactPointA: Vec3,
-  contactPointB: Vec3,
-  normalA: Vec3,
-  normalB: Vec3,
-  momentArmA: Vec3,
-  momentArmB: Vec3,
-  surfaceNormalA: Vec3,
-  surfaceNormalB: Vec3,
-  bodyA: LazyReferenceType((() => Body)),
-  bodyB: LazyReferenceType((() => Body)),
-  subShapeIdA: 0,
-  subShapeIdB: 0,
-  isBackFace: BooleanType(false),
-  faceA: Face,
-  faceB: Face
-};
-class CollisionResult extends createClass(collisionResultProps) {
-  /**
-   * swaps the A and B data
-   */
-  swap() {
-    this.contactPointA.swap(this.contactPointB);
-    this.normalA.swap(this.normalB);
-    this.momentArmA.swap(this.momentArmB);
-    this.surfaceNormalA.swap(this.surfaceNormalB);
-    const tempBody = this.bodyA;
-    this.bodyA = this.bodyB;
-    this.bodyB = tempBody;
-    const tempSubShapeId = this.subShapeIdA;
-    this.subShapeIdA = this.subShapeIdB;
-    this.subShapeIdB = tempSubShapeId;
-    const tempFace = this.faceA;
-    this.faceA = this.faceB;
-    this.faceB = tempFace;
-  }
-}
-const _CollisionCollector = class _CollisionCollector {
-  constructor() {
-    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
-    this.body2 = null;
-  }
-  getEarlyOutFraction() {
-    return _CollisionCollector.initialEarlyOutFraction;
+  if (updateBroadphase) {
+    body2.markBodyAsDirty();
   }
-  getPositiveEarlyOutFraction() {
-    return Math.max(Number.MIN_VALUE, this.earlyOutFraction);
-  }
-  reset() {
-    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
-    this.body2 = null;
-    return this;
-  }
-  addHit(result2) {
-  }
-  addMiss() {
-  }
-};
-_CollisionCollector.initialEarlyOutFraction = Infinity;
-_CollisionCollector.shouldEarlyOutFraction = -Infinity;
-let CollisionCollector = _CollisionCollector;
-var CollectFacesMode = /* @__PURE__ */ ((CollectFacesMode2) => {
-  CollectFacesMode2[CollectFacesMode2["CollectFaces"] = 0] = "CollectFaces";
-  CollectFacesMode2[CollectFacesMode2["NoFaces"] = 1] = "NoFaces";
-  return CollectFacesMode2;
-})(CollectFacesMode || {});
-var ActiveEdgeMode = /* @__PURE__ */ ((ActiveEdgeMode2) => {
-  ActiveEdgeMode2[ActiveEdgeMode2["CollideOnlyWithActive"] = 0] = "CollideOnlyWithActive";
-  ActiveEdgeMode2[ActiveEdgeMode2["CollideWithAll"] = 1] = "CollideWithAll";
-  return ActiveEdgeMode2;
-})(ActiveEdgeMode || {});
-var BackFaceMode = /* @__PURE__ */ ((BackFaceMode2) => {
-  BackFaceMode2[BackFaceMode2["IgnoreBackFaces"] = 0] = "IgnoreBackFaces";
-  BackFaceMode2[BackFaceMode2["CollideWithBackFaces"] = 1] = "CollideWithBackFaces";
-  return BackFaceMode2;
-})(BackFaceMode || {});
-function createDefaultCollisionSettings() {
-  return {
-    maxSeparation: 0,
-    collisionTolerance: 1e-4,
-    activeEdgeMode: 0,
-    collectFacesMode: 1,
-    penetrationTolerance: 1e-4,
-    activeEdgeMovementDirectionX: 0,
-    activeEdgeMovementDirectionY: 0,
-    activeEdgeMovementDirectionZ: 0,
-    backFaceMode: 0
-    /* IgnoreBackFaces */
-  };
 }
 const castResultProps = {
   status: NumberType(
@@ -8567,15 +8487,6 @@ var QueryPrecision = /* @__PURE__ */ ((QueryPrecision2) => {
   QueryPrecision2[QueryPrecision2["preciseWithContacts"] = 2] = "preciseWithContacts";
   return QueryPrecision2;
 })(QueryPrecision || {});
-function createDefaultCastSettings() {
-  return {
-    ...createDefaultCollisionSettings(),
-    backFaceModeConvex: BackFaceMode.IgnoreBackFaces,
-    backFaceModeTriangles: BackFaceMode.IgnoreBackFaces,
-    useShrunkenShapeAndConvexRadius: false,
-    returnDeepestPoint: false
-  };
-}
 const ab$4 = /* @__PURE__ */ Vec3.create();
 function computeBarycentricCoordinates2d(outBarycentric, a3, b3, squaredTolerance = 1e-10) {
   ab$4.subtractVectors(b3, a3);
@@ -9437,6 +9348,94 @@ class GjkModule {
   }
 }
 const v = /* @__PURE__ */ Vec3.create();
+var CollisionStatus = /* @__PURE__ */ ((CollisionStatus2) => {
+  CollisionStatus2[CollisionStatus2["NotColliding"] = 0] = "NotColliding";
+  CollisionStatus2[CollisionStatus2["Colliding"] = 1] = "Colliding";
+  CollisionStatus2[CollisionStatus2["Indeterminate"] = 2] = "Indeterminate";
+  return CollisionStatus2;
+})(CollisionStatus || {});
+const collisionResultProps = {
+  status: NumberType(
+    2
+    /* Indeterminate */
+  ),
+  hasContact: BooleanType(false),
+  penetration: 0,
+  contactPointA: Vec3,
+  contactPointB: Vec3,
+  normalA: Vec3,
+  normalB: Vec3,
+  momentArmA: Vec3,
+  momentArmB: Vec3,
+  surfaceNormalA: Vec3,
+  surfaceNormalB: Vec3,
+  bodyA: LazyReferenceType((() => Body)),
+  bodyB: LazyReferenceType((() => Body)),
+  subShapeIdA: 0,
+  subShapeIdB: 0,
+  isBackFace: BooleanType(false),
+  faceA: Face,
+  faceB: Face
+};
+class CollisionResult extends createClass(collisionResultProps) {
+  /**
+   * swaps the A and B data
+   */
+  swap() {
+    this.contactPointA.swap(this.contactPointB);
+    this.normalA.swap(this.normalB);
+    this.momentArmA.swap(this.momentArmB);
+    this.surfaceNormalA.swap(this.surfaceNormalB);
+    const tempBody = this.bodyA;
+    this.bodyA = this.bodyB;
+    this.bodyB = tempBody;
+    const tempSubShapeId = this.subShapeIdA;
+    this.subShapeIdA = this.subShapeIdB;
+    this.subShapeIdB = tempSubShapeId;
+    const tempFace = this.faceA;
+    this.faceA = this.faceB;
+    this.faceB = tempFace;
+  }
+}
+const _CollisionCollector = class _CollisionCollector {
+  constructor() {
+    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
+    this.body2 = null;
+  }
+  getEarlyOutFraction() {
+    return _CollisionCollector.initialEarlyOutFraction;
+  }
+  getPositiveEarlyOutFraction() {
+    return Math.max(Number.MIN_VALUE, this.earlyOutFraction);
+  }
+  reset() {
+    this.earlyOutFraction = _CollisionCollector.initialEarlyOutFraction;
+    this.body2 = null;
+    return this;
+  }
+  addHit(result2) {
+  }
+  addMiss() {
+  }
+};
+_CollisionCollector.initialEarlyOutFraction = Infinity;
+_CollisionCollector.shouldEarlyOutFraction = -Infinity;
+let CollisionCollector = _CollisionCollector;
+var CollectFacesMode = /* @__PURE__ */ ((CollectFacesMode2) => {
+  CollectFacesMode2[CollectFacesMode2["CollectFaces"] = 0] = "CollectFaces";
+  CollectFacesMode2[CollectFacesMode2["NoFaces"] = 1] = "NoFaces";
+  return CollectFacesMode2;
+})(CollectFacesMode || {});
+var ActiveEdgeMode = /* @__PURE__ */ ((ActiveEdgeMode2) => {
+  ActiveEdgeMode2[ActiveEdgeMode2["CollideOnlyWithActive"] = 0] = "CollideOnlyWithActive";
+  ActiveEdgeMode2[ActiveEdgeMode2["CollideWithAll"] = 1] = "CollideWithAll";
+  return ActiveEdgeMode2;
+})(ActiveEdgeMode || {});
+var BackFaceMode = /* @__PURE__ */ ((BackFaceMode2) => {
+  BackFaceMode2[BackFaceMode2["IgnoreBackFaces"] = 0] = "IgnoreBackFaces";
+  BackFaceMode2[BackFaceMode2["CollideWithBackFaces"] = 1] = "CollideWithBackFaces";
+  return BackFaceMode2;
+})(BackFaceMode || {});
 const edgeProps = {
   neighbourTriangle: LazyReferenceType((() => Triangle2)),
   neighbourEdge: 0,
@@ -11218,88 +11217,79 @@ function collideCompoundVsTriangleMesh(penetrationDepthModule2, collector2, shap
 function noOp() {
   return;
 }
-const collideShapesFns = {
-  [ShapeType.sphere]: {
-    [ShapeType.box]: collideConvexVsConvex,
-    [ShapeType.capsule]: collideConvexVsConvex,
-    [ShapeType.convexHull]: collideConvexVsConvex,
-    [ShapeType.compoundShape]: collideConvexVsCompound,
-    [ShapeType.cylinder]: collideConvexVsConvex,
-    [ShapeType.heightMap]: collideConvexVsHeightMap,
-    [ShapeType.sphere]: collideSphereVsSphere,
-    [ShapeType.triangleMesh]: collideConvexVsTriangleMesh
-  },
-  [ShapeType.box]: {
-    [ShapeType.box]: collideConvexVsConvex,
-    [ShapeType.capsule]: collideConvexVsConvex,
-    [ShapeType.compoundShape]: collideConvexVsCompound,
-    [ShapeType.convexHull]: collideConvexVsConvex,
-    [ShapeType.cylinder]: collideConvexVsConvex,
-    [ShapeType.heightMap]: collideConvexVsHeightMap,
-    [ShapeType.sphere]: collideConvexVsConvex,
-    [ShapeType.triangleMesh]: collideConvexVsTriangleMesh
-  },
-  [ShapeType.convexHull]: {
-    [ShapeType.box]: collideConvexVsConvex,
-    [ShapeType.capsule]: collideConvexVsConvex,
-    [ShapeType.compoundShape]: collideConvexVsCompound,
-    [ShapeType.convexHull]: collideConvexVsConvex,
-    [ShapeType.cylinder]: collideConvexVsConvex,
-    [ShapeType.heightMap]: collideConvexVsHeightMap,
-    [ShapeType.sphere]: collideConvexVsConvex,
-    [ShapeType.triangleMesh]: collideConvexVsTriangleMesh
-  },
-  [ShapeType.compoundShape]: {
-    [ShapeType.box]: collideCompoundVsConvex,
-    [ShapeType.capsule]: collideCompoundVsConvex,
-    [ShapeType.compoundShape]: collideCompoundVsCompound,
-    [ShapeType.convexHull]: collideCompoundVsConvex,
-    [ShapeType.cylinder]: collideCompoundVsConvex,
-    [ShapeType.heightMap]: collideCompoundVsHeightMap,
-    [ShapeType.sphere]: collideCompoundVsConvex,
-    [ShapeType.triangleMesh]: collideCompoundVsTriangleMesh
-  },
-  [ShapeType.cylinder]: {
-    [ShapeType.box]: collideConvexVsConvex,
-    [ShapeType.capsule]: collideConvexVsConvex,
-    [ShapeType.compoundShape]: collideConvexVsCompound,
-    [ShapeType.convexHull]: collideConvexVsConvex,
-    [ShapeType.cylinder]: collideConvexVsConvex,
-    [ShapeType.heightMap]: collideConvexVsHeightMap,
-    [ShapeType.sphere]: collideConvexVsConvex,
-    [ShapeType.triangleMesh]: collideConvexVsTriangleMesh
-  },
-  [ShapeType.capsule]: {
-    [ShapeType.box]: collideConvexVsConvex,
-    [ShapeType.capsule]: collideConvexVsConvex,
-    [ShapeType.compoundShape]: collideConvexVsCompound,
-    [ShapeType.convexHull]: collideConvexVsConvex,
-    [ShapeType.cylinder]: collideConvexVsConvex,
-    [ShapeType.heightMap]: collideConvexVsHeightMap,
-    [ShapeType.sphere]: collideConvexVsConvex,
-    [ShapeType.triangleMesh]: collideConvexVsTriangleMesh
-  },
-  [ShapeType.heightMap]: {
-    [ShapeType.box]: collideHeightMapVsConvex,
-    [ShapeType.capsule]: collideHeightMapVsConvex,
-    [ShapeType.compoundShape]: collideHeightMapVsCompound,
-    [ShapeType.convexHull]: collideHeightMapVsConvex,
-    [ShapeType.cylinder]: collideHeightMapVsConvex,
-    [ShapeType.heightMap]: noOp,
-    [ShapeType.sphere]: collideHeightMapVsConvex,
-    [ShapeType.triangleMesh]: noOp
-  },
-  [ShapeType.triangleMesh]: {
-    [ShapeType.box]: collideTriangleMeshVsConvex,
-    [ShapeType.capsule]: collideTriangleMeshVsConvex,
-    [ShapeType.compoundShape]: collideTriangleMeshVsCompound,
-    [ShapeType.convexHull]: collideTriangleMeshVsConvex,
-    [ShapeType.cylinder]: collideTriangleMeshVsConvex,
-    [ShapeType.heightMap]: noOp,
-    [ShapeType.sphere]: collideTriangleMeshVsConvex,
-    [ShapeType.triangleMesh]: noOp
-  }
-};
+const collideShapesFns = [];
+collideShapesFns[ShapeType.box] = [];
+collideShapesFns[ShapeType.capsule] = [];
+collideShapesFns[ShapeType.compoundShape] = [];
+collideShapesFns[ShapeType.convexHull] = [];
+collideShapesFns[ShapeType.cylinder] = [];
+collideShapesFns[ShapeType.heightMap] = [];
+collideShapesFns[ShapeType.sphere] = [];
+collideShapesFns[ShapeType.triangleMesh] = [];
+collideShapesFns[ShapeType.box][ShapeType.box] = collideConvexVsConvex;
+collideShapesFns[ShapeType.box][ShapeType.capsule] = collideConvexVsConvex;
+collideShapesFns[ShapeType.box][ShapeType.compoundShape] = collideConvexVsCompound;
+collideShapesFns[ShapeType.box][ShapeType.convexHull] = collideConvexVsConvex;
+collideShapesFns[ShapeType.box][ShapeType.cylinder] = collideConvexVsConvex;
+collideShapesFns[ShapeType.box][ShapeType.heightMap] = collideConvexVsHeightMap;
+collideShapesFns[ShapeType.box][ShapeType.sphere] = collideConvexVsConvex;
+collideShapesFns[ShapeType.box][ShapeType.triangleMesh] = collideConvexVsTriangleMesh;
+collideShapesFns[ShapeType.capsule][ShapeType.box] = collideConvexVsConvex;
+collideShapesFns[ShapeType.capsule][ShapeType.capsule] = collideConvexVsConvex;
+collideShapesFns[ShapeType.capsule][ShapeType.compoundShape] = collideConvexVsCompound;
+collideShapesFns[ShapeType.capsule][ShapeType.convexHull] = collideConvexVsConvex;
+collideShapesFns[ShapeType.capsule][ShapeType.cylinder] = collideConvexVsConvex;
+collideShapesFns[ShapeType.capsule][ShapeType.heightMap] = collideConvexVsHeightMap;
+collideShapesFns[ShapeType.capsule][ShapeType.sphere] = collideConvexVsConvex;
+collideShapesFns[ShapeType.capsule][ShapeType.triangleMesh] = collideConvexVsTriangleMesh;
+collideShapesFns[ShapeType.compoundShape][ShapeType.box] = collideCompoundVsConvex;
+collideShapesFns[ShapeType.compoundShape][ShapeType.capsule] = collideCompoundVsConvex;
+collideShapesFns[ShapeType.compoundShape][ShapeType.compoundShape] = collideCompoundVsCompound;
+collideShapesFns[ShapeType.compoundShape][ShapeType.convexHull] = collideCompoundVsConvex;
+collideShapesFns[ShapeType.compoundShape][ShapeType.cylinder] = collideCompoundVsConvex;
+collideShapesFns[ShapeType.compoundShape][ShapeType.heightMap] = collideCompoundVsHeightMap;
+collideShapesFns[ShapeType.compoundShape][ShapeType.sphere] = collideCompoundVsConvex;
+collideShapesFns[ShapeType.compoundShape][ShapeType.triangleMesh] = collideCompoundVsTriangleMesh;
+collideShapesFns[ShapeType.convexHull][ShapeType.box] = collideConvexVsConvex;
+collideShapesFns[ShapeType.convexHull][ShapeType.capsule] = collideConvexVsConvex;
+collideShapesFns[ShapeType.convexHull][ShapeType.compoundShape] = collideConvexVsCompound;
+collideShapesFns[ShapeType.convexHull][ShapeType.convexHull] = collideConvexVsConvex;
+collideShapesFns[ShapeType.convexHull][ShapeType.cylinder] = collideConvexVsConvex;
+collideShapesFns[ShapeType.convexHull][ShapeType.heightMap] = collideConvexVsHeightMap;
+collideShapesFns[ShapeType.convexHull][ShapeType.sphere] = collideConvexVsConvex;
+collideShapesFns[ShapeType.convexHull][ShapeType.triangleMesh] = collideConvexVsTriangleMesh;
+collideShapesFns[ShapeType.cylinder][ShapeType.box] = collideConvexVsConvex;
+collideShapesFns[ShapeType.cylinder][ShapeType.capsule] = collideConvexVsConvex;
+collideShapesFns[ShapeType.cylinder][ShapeType.compoundShape] = collideConvexVsCompound;
+collideShapesFns[ShapeType.cylinder][ShapeType.convexHull] = collideConvexVsConvex;
+collideShapesFns[ShapeType.cylinder][ShapeType.cylinder] = collideConvexVsConvex;
+collideShapesFns[ShapeType.cylinder][ShapeType.heightMap] = collideConvexVsHeightMap;
+collideShapesFns[ShapeType.cylinder][ShapeType.sphere] = collideConvexVsConvex;
+collideShapesFns[ShapeType.cylinder][ShapeType.triangleMesh] = collideConvexVsTriangleMesh;
+collideShapesFns[ShapeType.heightMap][ShapeType.box] = collideHeightMapVsConvex;
+collideShapesFns[ShapeType.heightMap][ShapeType.capsule] = collideHeightMapVsConvex;
+collideShapesFns[ShapeType.heightMap][ShapeType.compoundShape] = collideHeightMapVsCompound;
+collideShapesFns[ShapeType.heightMap][ShapeType.convexHull] = collideHeightMapVsConvex;
+collideShapesFns[ShapeType.heightMap][ShapeType.cylinder] = collideHeightMapVsConvex;
+collideShapesFns[ShapeType.heightMap][ShapeType.heightMap] = noOp;
+collideShapesFns[ShapeType.heightMap][ShapeType.sphere] = collideHeightMapVsConvex;
+collideShapesFns[ShapeType.heightMap][ShapeType.triangleMesh] = noOp;
+collideShapesFns[ShapeType.sphere][ShapeType.box] = collideConvexVsConvex;
+collideShapesFns[ShapeType.sphere][ShapeType.capsule] = collideConvexVsConvex;
+collideShapesFns[ShapeType.sphere][ShapeType.compoundShape] = collideConvexVsCompound;
+collideShapesFns[ShapeType.sphere][ShapeType.convexHull] = collideConvexVsConvex;
+collideShapesFns[ShapeType.sphere][ShapeType.cylinder] = collideConvexVsConvex;
+collideShapesFns[ShapeType.sphere][ShapeType.heightMap] = collideConvexVsHeightMap;
+collideShapesFns[ShapeType.sphere][ShapeType.sphere] = collideSphereVsSphere;
+collideShapesFns[ShapeType.sphere][ShapeType.triangleMesh] = collideConvexVsTriangleMesh;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.box] = collideTriangleMeshVsConvex;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.capsule] = collideTriangleMeshVsConvex;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.compoundShape] = collideTriangleMeshVsCompound;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.convexHull] = collideTriangleMeshVsConvex;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.cylinder] = collideTriangleMeshVsConvex;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.heightMap] = noOp;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.sphere] = collideTriangleMeshVsConvex;
+collideShapesFns[ShapeType.triangleMesh][ShapeType.triangleMesh] = noOp;
 class CollideShapesModule {
   constructor(penetrationDepthModule2) {
     this.penetrationDepthModule = penetrationDepthModule2;
@@ -11309,11 +11299,9 @@ class CollideShapesModule {
   // the isometries must transform the shapes into world space
   // the results are in world space
   collideShapes(collector2, shapeA, isometryA2, shapeB2, isometryB2, settings, bodyA, bodyB, subShapeIdA = 0, subShapeIdB = 0) {
-    const keyA = shapeA.type;
-    const keyB = shapeB2.type;
-    const collisionFunction = collideShapesFns[keyA][keyB];
+    const collisionFunction = collideShapesFns[shapeA.type][shapeB2.type];
     if (!collisionFunction) {
-      throw new Error(`no collision function found for shapes with type ${keyA} and ${keyB}`);
+      throw new Error(`no collision function found for shapes with type ${shapeA.type} and ${shapeB2.type}`);
     }
     return collisionFunction(
       this.penetrationDepthModule,
@@ -11628,7 +11616,7 @@ class CollideBodiesModule {
     }
     isometryA.matrix.postTranslatedMatrix(inCenterOfMassTransform.matrix, offset);
     boundsA$1.copy(inShape.computedAabb);
-    boundsA$1.expand(inCollideShapeSettings ? inCollideShapeSettings.maxSeparation : 0);
+    boundsA$1.expand(inCollideShapeSettings?.maxSeparation ?? 0);
     boundsA$1.transform(inCenterOfMassTransform);
     collideShapeVisitor.initialize(
       isometryA,
@@ -11735,7 +11723,7 @@ class CastRayBodyVisitor {
   }
   visit(body2) {
     isometryB.fromRotationAndTranslation(body2.orientation, body2.computedCenterOfMassPosition);
-    this.castModule.castRay(this.collector, this.ray, body2.shape, isometryB, 1, zeroVector$1, this.settings, body2);
+    this.castModule.castRay(this.collector, this.ray, body2.shape, isometryB, 1, zeroVector$1, body2);
   }
 }
 const castRayVisitor = /* @__PURE__ */ new CastRayBodyVisitor();
@@ -12615,19 +12603,9 @@ class BvhModule {
     for (const node of this.pairs.iteratePairs()) {
       const bodyA = node.bodyA;
       const bodyB = node.bodyB;
-      if (bodyA.type === BodyType.static && bodyB.type === BodyType.static) {
+      if (bodyA.type !== BodyType.dynamic && bodyB.type !== BodyType.dynamic || bodyB.type === BodyType.static && bodyA.isSleeping) {
         continue;
       }
-      if (bodyA.type === BodyType.static && bodyB.type === BodyType.dynamic) {
-        if (bodyB.isSleeping) {
-          continue;
-        }
-      }
-      if (bodyA.type === BodyType.dynamic && bodyB.type === BodyType.static) {
-        if (bodyA.isSleeping) {
-          continue;
-        }
-      }
       yield node;
     }
   }
@@ -13069,7 +13047,7 @@ function castConvexVsTriangleMesh(penetrationDepthModule2, ioCollector, inShapeA
   isometryWorldToB$2.matrix.multiply3x3(transformedDisplacement, displacement2);
   inShapeB.bvh.castAabb(onHit$2, boundsA, transformedDisplacement);
 }
-function castRayVsConvex(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, inSettings, bodyB = null) {
+function castRayVsConvex(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, bodyB = null) {
   const convexB2 = inShapeB.computeSupportShape(SupportMode.IncludeConvexRadius, 1);
   raycast.fraction = ioCollector.getEarlyOutFraction();
   worldToB.matrix.invertMatrix(isometryB2.matrix);
@@ -13095,7 +13073,7 @@ const result$2 = /* @__PURE__ */ CastResult.create();
 const raycast = { fraction: 0 };
 const transformedRay$2 = /* @__PURE__ */ Ray.create();
 const worldToB = /* @__PURE__ */ Isometry.create();
-function castRayVsCompound(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, inSettings, bodyB = null) {
+function castRayVsCompound(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, bodyB = null) {
   for (const shapeObj of inShapeB.shapes) {
     const shape = shapeObj.shape;
     const transform2 = shapeObj.transform;
@@ -13109,7 +13087,6 @@ function castRayVsCompound(penetrationDepthModule2, ioCollector, inRay, inShapeB
       transformSubShapeBToWorld,
       inScaleB,
       offset2,
-      inSettings,
       bodyB
     );
   }
@@ -13136,7 +13113,7 @@ function onHit$1(triangle2) {
   collector$1.addHit(result$1);
   return false;
 }
-function castRayVsTriangleMesh(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, inSettings, bodyB = null) {
+function castRayVsTriangleMesh(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, bodyB = null) {
   ioCollector.reset();
   isometryWorldToB$1.matrix.invertMatrix(isometryB2.matrix);
   transformedRay$1.copy(inRay).transform(isometryWorldToB$1);
@@ -13169,7 +13146,7 @@ function onHit(triangle2) {
   collector.addHit(result);
   return false;
 }
-function castRayVsHeightMap(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, inSettings, bodyB = null) {
+function castRayVsHeightMap(penetrationDepthModule2, ioCollector, inRay, inShapeB, isometryB2, inScaleB, offset2, bodyB = null) {
   ioCollector.reset();
   isometryWorldToB.matrix.invertMatrix(isometryB2.matrix);
   transformedRay.copy(inRay).transform(isometryWorldToB);
@@ -13182,100 +13159,76 @@ const result = /* @__PURE__ */ CastResult.create();
 const raycasterResult = { fraction: 1, hit: false };
 const isometryWorldToB = /* @__PURE__ */ Isometry.create();
 const transformedRay = /* @__PURE__ */ Ray.create();
-const castShapesFns = {
-  [ShapeType.sphere]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh
-  },
-  [ShapeType.box]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh
-  },
-  [ShapeType.capsule]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh
-  },
-  [ShapeType.cylinder]: {
-    [ShapeType.box]: castConvexVsConvex,
-    [ShapeType.capsule]: castConvexVsConvex,
-    [ShapeType.compoundShape]: castConvexVsCompound,
-    [ShapeType.convexHull]: castConvexVsConvex,
-    [ShapeType.cylinder]: castConvexVsConvex,
-    [ShapeType.heightMap]: castConvexVsHeightMap,
-    [ShapeType.sphere]: castConvexVsConvex,
-    [ShapeType.triangleMesh]: castConvexVsTriangleMesh
-  },
-  [ShapeType.compoundShape]: {
-    [ShapeType.box]: castCompoundVsConvex,
-    [ShapeType.capsule]: castCompoundVsConvex,
-    // [ShapeType.compoundShape]: castCompoundVsCompound,
-    [ShapeType.convexHull]: castCompoundVsConvex,
-    [ShapeType.cylinder]: castCompoundVsConvex,
-    // [ShapeType.heightMap]: castCompoundVsHeightMap,
-    [ShapeType.sphere]: castCompoundVsConvex
-    // [ShapeType.triangleMesh]: castCompoundVsTriangleMesh,
-  }
-  // [ShapeType.heightMap]: {
-  //   [ShapeType.box]: castHeightMapVsConvex,
-  //   [ShapeType.capsule]: castHeightMapVsConvex,
-  //   [ShapeType.compoundShape]: castHeightMapVsCompound,
-  //   [ShapeType.convexHull]: castHeightMapVsConvex,
-  //   [ShapeType.cylinder]: castHeightMapVsConvex,
-  //   [ShapeType.heightMap]: castHeightMapVsHeightMap,
-  //   [ShapeType.sphere]: castHeightMapVsConvex,
-  //   [ShapeType.triangleMesh]: castHeightMapVsTriangleMesh,
-  // },
-  // [ShapeType.triangleMesh]: {
-  //   [ShapeType.box]: castTriangleMeshVsConvex,
-  //   [ShapeType.capsule]: castTriangleMeshVsConvex,
-  //   [ShapeType.compoundShape]: castTriangleMeshVsCompound,
-  //   [ShapeType.convexHull]: castTriangleMeshVsConvex,
-  //   [ShapeType.cylinder]: castTriangleMeshVsConvex,
-  //   [ShapeType.heightMap]: castTriangleMeshVsHeightMap,
-  //   [ShapeType.sphere]: castTriangleMeshVsConvex,
-  //   [ShapeType.triangleMesh]: castTriangleMeshVsTriangleMesh,
-  // },
-  // [ShapeType.triangle]: {
-  //   [ShapeType.box]: castTriangleVsConvex,
-  //   [ShapeType.sphere]: castTriangleVsConvex,
-  // },
-};
-const raycastFns = {
-  [ShapeType.sphere]: castRayVsConvex,
-  [ShapeType.box]: castRayVsConvex,
-  [ShapeType.capsule]: castRayVsConvex,
-  [ShapeType.cylinder]: castRayVsConvex,
-  [ShapeType.compoundShape]: castRayVsCompound,
-  // castRayVsCompound,
-  [ShapeType.convexHull]: castRayVsConvex,
-  [ShapeType.heightMap]: castRayVsHeightMap,
-  // castRayVsHeightMap,
-  [ShapeType.triangleMesh]: castRayVsTriangleMesh
-  // castRayVsTriangleMesh,
-};
+const castShapesFns = [];
+castShapesFns[ShapeType.box] = [];
+castShapesFns[ShapeType.capsule] = [];
+castShapesFns[ShapeType.compoundShape] = [];
+castShapesFns[ShapeType.convexHull] = [];
+castShapesFns[ShapeType.cylinder] = [];
+castShapesFns[ShapeType.heightMap] = [];
+castShapesFns[ShapeType.sphere] = [];
+castShapesFns[ShapeType.triangleMesh] = [];
+castShapesFns[ShapeType.box][ShapeType.box] = castConvexVsConvex;
+castShapesFns[ShapeType.box][ShapeType.capsule] = castConvexVsConvex;
+castShapesFns[ShapeType.box][ShapeType.compoundShape] = castConvexVsCompound;
+castShapesFns[ShapeType.box][ShapeType.convexHull] = castConvexVsConvex;
+castShapesFns[ShapeType.box][ShapeType.cylinder] = castConvexVsConvex;
+castShapesFns[ShapeType.box][ShapeType.heightMap] = castConvexVsHeightMap;
+castShapesFns[ShapeType.box][ShapeType.sphere] = castConvexVsConvex;
+castShapesFns[ShapeType.box][ShapeType.triangleMesh] = castConvexVsTriangleMesh;
+castShapesFns[ShapeType.capsule][ShapeType.box] = castConvexVsConvex;
+castShapesFns[ShapeType.capsule][ShapeType.capsule] = castConvexVsConvex;
+castShapesFns[ShapeType.capsule][ShapeType.compoundShape] = castConvexVsCompound;
+castShapesFns[ShapeType.capsule][ShapeType.convexHull] = castConvexVsConvex;
+castShapesFns[ShapeType.capsule][ShapeType.cylinder] = castConvexVsConvex;
+castShapesFns[ShapeType.capsule][ShapeType.heightMap] = castConvexVsHeightMap;
+castShapesFns[ShapeType.capsule][ShapeType.sphere] = castConvexVsConvex;
+castShapesFns[ShapeType.capsule][ShapeType.triangleMesh] = castConvexVsTriangleMesh;
+castShapesFns[ShapeType.compoundShape][ShapeType.box] = castCompoundVsConvex;
+castShapesFns[ShapeType.compoundShape][ShapeType.capsule] = castCompoundVsConvex;
+castShapesFns[ShapeType.compoundShape][ShapeType.convexHull] = castCompoundVsConvex;
+castShapesFns[ShapeType.compoundShape][ShapeType.cylinder] = castCompoundVsConvex;
+castShapesFns[ShapeType.compoundShape][ShapeType.heightMap] = castConvexVsHeightMap;
+castShapesFns[ShapeType.compoundShape][ShapeType.sphere] = castCompoundVsConvex;
+castShapesFns[ShapeType.compoundShape][ShapeType.triangleMesh] = castConvexVsTriangleMesh;
+castShapesFns[ShapeType.convexHull][ShapeType.box] = castConvexVsConvex;
+castShapesFns[ShapeType.convexHull][ShapeType.capsule] = castConvexVsConvex;
+castShapesFns[ShapeType.convexHull][ShapeType.compoundShape] = castConvexVsCompound;
+castShapesFns[ShapeType.convexHull][ShapeType.convexHull] = castConvexVsConvex;
+castShapesFns[ShapeType.convexHull][ShapeType.cylinder] = castConvexVsConvex;
+castShapesFns[ShapeType.convexHull][ShapeType.heightMap] = castConvexVsHeightMap;
+castShapesFns[ShapeType.convexHull][ShapeType.sphere] = castConvexVsConvex;
+castShapesFns[ShapeType.convexHull][ShapeType.triangleMesh] = castConvexVsTriangleMesh;
+castShapesFns[ShapeType.cylinder][ShapeType.box] = castConvexVsConvex;
+castShapesFns[ShapeType.cylinder][ShapeType.capsule] = castConvexVsConvex;
+castShapesFns[ShapeType.cylinder][ShapeType.compoundShape] = castConvexVsCompound;
+castShapesFns[ShapeType.cylinder][ShapeType.convexHull] = castConvexVsConvex;
+castShapesFns[ShapeType.cylinder][ShapeType.cylinder] = castConvexVsConvex;
+castShapesFns[ShapeType.cylinder][ShapeType.heightMap] = castConvexVsHeightMap;
+castShapesFns[ShapeType.cylinder][ShapeType.sphere] = castConvexVsConvex;
+castShapesFns[ShapeType.cylinder][ShapeType.triangleMesh] = castConvexVsTriangleMesh;
+castShapesFns[ShapeType.sphere][ShapeType.box] = castConvexVsConvex;
+castShapesFns[ShapeType.sphere][ShapeType.capsule] = castConvexVsConvex;
+castShapesFns[ShapeType.sphere][ShapeType.compoundShape] = castConvexVsCompound;
+castShapesFns[ShapeType.sphere][ShapeType.convexHull] = castConvexVsConvex;
+castShapesFns[ShapeType.sphere][ShapeType.cylinder] = castConvexVsConvex;
+castShapesFns[ShapeType.sphere][ShapeType.heightMap] = castConvexVsHeightMap;
+castShapesFns[ShapeType.sphere][ShapeType.sphere] = castConvexVsConvex;
+castShapesFns[ShapeType.sphere][ShapeType.triangleMesh] = castConvexVsTriangleMesh;
+const raycastFns = [];
+raycastFns[ShapeType.box] = castRayVsConvex;
+raycastFns[ShapeType.capsule] = castRayVsConvex;
+raycastFns[ShapeType.compoundShape] = castRayVsCompound;
+raycastFns[ShapeType.convexHull] = castRayVsConvex;
+raycastFns[ShapeType.cylinder] = castRayVsConvex;
+raycastFns[ShapeType.heightMap] = castRayVsHeightMap;
+raycastFns[ShapeType.sphere] = castRayVsConvex;
+raycastFns[ShapeType.triangleMesh] = castRayVsTriangleMesh;
 class CastShapesModule {
   constructor(penetrationDepthModule2) {
     this.penetrationDepthModule = penetrationDepthModule2;
   }
-  castRay(collector2, ray2, shapeB2, isometryB2, scaleB, offset2, settings, bodyB = null) {
+  castRay(collector2, ray2, shapeB2, isometryB2, scaleB, offset2, bodyB = null) {
     const fn = raycastFns[shapeB2.type];
     if (!fn) {
       return;
@@ -13289,7 +13242,6 @@ class CastShapesModule {
       isometryB2,
       scaleB,
       offset2,
-      settings,
       bodyB
     );
   }
@@ -13298,11 +13250,9 @@ class CastShapesModule {
   // the isometries must transform the shapes into world space
   // the results are in world space
   castShapes(collector2, shapeA, isometryA2, scaleA, shapeB2, isometryB2, scaleB, displacement2, offset2, settings, bodyA = null, bodyB = null) {
-    const keyA = shapeA.type;
-    const keyB = shapeB2.type;
-    const castFunction = castShapesFns[keyA][keyB];
+    const castFunction = castShapesFns[shapeA.type][shapeB2.type];
     if (!castFunction) {
-      throw new Error(`no cast function found for shapes with type ${keyA} and ${keyB}`);
+      throw new Error(`no cast function found for shapes with type ${shapeA.type} and ${shapeB2.type}`);
     }
     return castFunction(
       this.penetrationDepthModule,
@@ -15458,11 +15408,6 @@ class World {
       updateWorldBounds(body2);
     }
   }
-  // updateBodyProperties() {
-  //   for (const body of this.bodies()) {
-  //     // updateBody(body);
-  //   }
-  // }
   clearForcesOnBodies() {
     for (const body2 of this.dynamicBodies) {
       body2.clearForces();
@@ -15666,10 +15611,13 @@ class World {
     options.type = BodyType.static;
     options.world = this;
     const body2 = this.staticBodies.create(options);
+    const originalShape = options.shape;
+    options.shape = null;
     const bodyCopy = this.staticBodyCopies.create(options);
     bodyCopy.copy(body2);
     body2.copyForDiff = bodyCopy;
-    this.broadphase.addStaticBody(body2);
+    bodyCopy.setShape(body2.shape, false);
+    options.shape = originalShape;
     return body2;
   }
   createDynamicBody(options) {
@@ -15677,10 +15625,13 @@ class World {
     options.type = BodyType.dynamic;
     options.world = this;
     const body2 = this.dynamicBodies.create(options);
+    const originalShape = options.shape;
+    options.shape = null;
     const bodyCopy = this.dynamicBodyCopies.create(options);
     bodyCopy.copy(body2);
     body2.copyForDiff = bodyCopy;
-    this.broadphase.addDynamicBody(body2);
+    bodyCopy.setShape(body2.shape, false);
+    options.shape = originalShape;
     return body2;
   }
   createKinematicBody(options) {
@@ -15688,10 +15639,13 @@ class World {
     options.type = BodyType.kinematic;
     options.world = this;
     const body2 = this.kinematicBodies.create(options);
+    const originalShape = options.shape;
+    options.shape = null;
     const bodyCopy = this.kinematicBodyCopies.create(options);
     bodyCopy.copy(body2);
     body2.copyForDiff = bodyCopy;
-    this.broadphase.addKinematicBody(body2);
+    bodyCopy.setShape(body2.shape, false);
+    options.shape = originalShape;
     return body2;
   }
   createBody(options) {
@@ -15775,6 +15729,10 @@ class World {
   }
   // scene query API
   intersectShape(onHit2, shape, transform2, settings) {
+    if (!(transform2 instanceof BasicTransform)) {
+      tempBasicTransform.reset(transform2);
+      transform2 = tempBasicTransform;
+    }
     isometry.fromRotationAndTranslation(transform2.rotation, transform2.position);
     intersectShapeCollector.initialize(onHit2);
     this.collideBodiesModule.collideShape(
@@ -15784,7 +15742,7 @@ class World {
       intersectShapeCollector,
       collideShapeSettings,
       zeroVector,
-      AllFlag
+      settings?.collisionMask ?? AllFlag
     );
   }
   castRay(onHit2, ray2, settings) {
@@ -15793,12 +15751,8 @@ class World {
   }
   castShape(onHit2, shape, transform2, displacementOrEndPosition, settings) {
     isometry.fromRotationAndTranslation(transform2.rotation, transform2.position);
-    settings = settings || {
-      precision: QueryPrecision.preciseWithContacts,
-      returnClosestOnly: false,
-      treatAsDisplacement: false
-    };
-    if (settings.treatAsDisplacement) {
+    settings = settings || {};
+    if (settings?.treatAsDisplacement ?? false) {
       displacement.copy(displacementOrEndPosition);
     } else {
       displacement.zero();
@@ -16063,7 +16017,21 @@ class IntersectShapeCollector extends CollisionCollector {
 }
 const intersectShapeCollector = /* @__PURE__ */ new IntersectShapeCollector();
 const displacement = /* @__PURE__ */ Vec3.create();
-const castSettings = /* @__PURE__ */ createDefaultCastSettings();
+const castSettings = {
+  maxSeparation: 0,
+  collisionTolerance: 1e-4,
+  activeEdgeMode: ActiveEdgeMode.CollideOnlyWithActive,
+  collectFacesMode: CollectFacesMode.NoFaces,
+  penetrationTolerance: 1e-4,
+  activeEdgeMovementDirectionX: 0,
+  activeEdgeMovementDirectionY: 0,
+  activeEdgeMovementDirectionZ: 0,
+  backFaceMode: BackFaceMode.IgnoreBackFaces,
+  backFaceModeConvex: BackFaceMode.IgnoreBackFaces,
+  backFaceModeTriangles: BackFaceMode.IgnoreBackFaces,
+  useShrunkenShapeAndConvexRadius: false,
+  returnDeepestPoint: false
+};
 class CastShapeCollector extends CastCollector {
   constructor() {
     super(...arguments);
@@ -16077,6 +16045,7 @@ class CastShapeCollector extends CastCollector {
   }
 }
 const castShapeCollector = /* @__PURE__ */ new CastShapeCollector();
+const tempBasicTransform = /* @__PURE__ */ BasicTransform.create();
 export {
   Aabb,
   ActiveEdgeMode,