npm - @perplexdotgg/bounce - Versions diffs - 1.0.0 - Mend

@perplexdotgg/bounce 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (140) hide show

package/LICENSE +21 -0
package/README.md +30 -0
package/package.json +32 -0
package/src/builders/ConvexHullBuilder.ts +437 -0
package/src/builders/ConvexHullBuilder2d.ts +344 -0
package/src/builders/ConvexHullBuilder3d.ts +1689 -0
package/src/builders/HeightMapBuilder.ts +414 -0
package/src/builders/TriangleMeshBuilder.ts +92 -0
package/src/collision/CastShapesModule.ts +184 -0
package/src/collision/CollideShapesModule.ts +152 -0
package/src/collision/HeightMapCaster.ts +38 -0
package/src/collision/HeightMapCollider.ts +33 -0
package/src/collision/TriangleCaster.ts +249 -0
package/src/collision/TriangleCollider.ts +308 -0
package/src/collision/TriangleCollider2.ts +379 -0
package/src/collision/activeEdge.ts +146 -0
package/src/collision/cast/cast.ts +139 -0
package/src/collision/cast/castCompoundVsCompound.ts +59 -0
package/src/collision/cast/castCompoundVsConvex.ts +116 -0
package/src/collision/cast/castConvexVsCompound.ts +123 -0
package/src/collision/cast/castConvexVsConvex.ts +213 -0
package/src/collision/cast/castConvexVsHeightMap.ts +73 -0
package/src/collision/cast/castConvexVsTriangleMesh.ts +56 -0
package/src/collision/cast/castRayVsCompound.ts +44 -0
package/src/collision/cast/castRayVsConvex.ts +45 -0
package/src/collision/cast/castRayVsHeightMap.ts +58 -0
package/src/collision/cast/castRayVsTriangleMesh.ts +58 -0
package/src/collision/closestPoints/closestPoints.ts +23 -0
package/src/collision/closestPoints/computeBarycentricCoordinates2d.ts +32 -0
package/src/collision/closestPoints/computeBarycentricCoordinates3d.ts +81 -0
package/src/collision/closestPoints/computeClosestPointOnLine.ts +30 -0
package/src/collision/closestPoints/computeClosestPointOnTetrahedron.ts +96 -0
package/src/collision/closestPoints/computeClosestPointOnTriangle.ts +195 -0
package/src/collision/closestPoints/isOriginOutsideOfPlane.ts +25 -0
package/src/collision/closestPoints/isOriginOutsideOfTrianglePlanes.ts +72 -0
package/src/collision/collide/collide.ts +146 -0
package/src/collision/collide/collideCompoundVsCompound.ts +60 -0
package/src/collision/collide/collideCompoundVsConvex.ts +59 -0
package/src/collision/collide/collideCompoundVsHeightMap.ts +73 -0
package/src/collision/collide/collideCompoundVsTriangleMesh.ts +56 -0
package/src/collision/collide/collideConvexVsCompound.ts +57 -0
package/src/collision/collide/collideConvexVsConvex.ts +225 -0
package/src/collision/collide/collideConvexVsConvexImp.ts +236 -0
package/src/collision/collide/collideConvexVsHeightMap.ts +53 -0
package/src/collision/collide/collideConvexVsTriangleMesh.ts +58 -0
package/src/collision/collide/collideHeightMapVsCompound.ts +69 -0
package/src/collision/collide/collideHeightMapVsConvex.ts +53 -0
package/src/collision/collide/collideSphereVsSphere.ts +81 -0
package/src/collision/collide/collideTriangleMeshVsCompound.ts +58 -0
package/src/collision/collide/collideTriangleMeshVsConvex.ts +58 -0
package/src/collision/epa/EpaConvexHullBuilder.ts +397 -0
package/src/collision/epa/StaticArray.ts +154 -0
package/src/collision/epa/TriangleFactory.ts +32 -0
package/src/collision/epa/arrays.ts +99 -0
package/src/collision/epa/binaryHeap.ts +82 -0
package/src/collision/epa/structs.ts +227 -0
package/src/collision/gjk/GjkModule.ts +864 -0
package/src/collision/gjk/PenetrationDepthModule.ts +493 -0
package/src/collision/gjk/SupportPoints.ts +50 -0
package/src/collision/imp/MinkowskiDifference.ts +36 -0
package/src/collision/imp/computeExploredDistanceLowerUpperBound.ts +40 -0
package/src/collision/imp/finalizeImpResult.ts +69 -0
package/src/collision/imp/findContactImp.ts +196 -0
package/src/collision/imp/imp.ts +28 -0
package/src/collision/imp/incrementalMinimumDistanceExploreDirection.ts +207 -0
package/src/collision/mpr/findPortal.ts +152 -0
package/src/collision/mpr/mpr.ts +29 -0
package/src/collision/mpr/updatePortal.ts +52 -0
package/src/constraints/BaseConstraint.ts +50 -0
package/src/constraints/ConstraintOptions.ts +22 -0
package/src/constraints/ConstraintSolver.ts +119 -0
package/src/constraints/DistanceConstraint.ts +229 -0
package/src/constraints/FixedConstraint.ts +203 -0
package/src/constraints/HingeConstraint.ts +460 -0
package/src/constraints/PointConstraint.ts +108 -0
package/src/constraints/components/AngleComponent.ts +226 -0
package/src/constraints/components/AxisComponent.ts +263 -0
package/src/constraints/components/HingeComponent.ts +215 -0
package/src/constraints/components/Motor.ts +36 -0
package/src/constraints/components/PointConstraintComponent.ts +179 -0
package/src/constraints/components/RotationEulerComponent.ts +139 -0
package/src/constraints/components/Spring.ts +30 -0
package/src/constraints/components/SpringComponent.ts +71 -0
package/src/constraints/types.ts +6 -0
package/src/helpers.ts +147 -0
package/src/index.ts +50 -0
package/src/math/BasicTransform.ts +19 -0
package/src/math/NumberValue.ts +13 -0
package/src/math/isometry.ts +64 -0
package/src/math/mat3.ts +529 -0
package/src/math/mat4.ts +588 -0
package/src/math/quat.ts +193 -0
package/src/math/scalar.ts +81 -0
package/src/math/tensor.ts +17 -0
package/src/math/vec3.ts +589 -0
package/src/math/vec4.ts +10 -0
package/src/physics/Body.ts +581 -0
package/src/physics/CollisionFilter.ts +52 -0
package/src/physics/SleepModule.ts +163 -0
package/src/physics/broadphase/BodyPairsModule.ts +363 -0
package/src/physics/broadphase/BvhModule.ts +237 -0
package/src/physics/broadphase/BvhTree.ts +803 -0
package/src/physics/broadphase/ConstraintPairsModule.ts +385 -0
package/src/physics/broadphase/TriangleMeshBvhTree.ts +379 -0
package/src/physics/manifold/ContactManifold.ts +227 -0
package/src/physics/manifold/ContactManifoldModule.ts +623 -0
package/src/physics/manifold/Face.ts +119 -0
package/src/physics/manifold/ManifoldCache.ts +116 -0
package/src/physics/manifold/clipping/clipPolyVsEdge.ts +131 -0
package/src/physics/manifold/clipping/clipPolyVsPlane.ts +73 -0
package/src/physics/manifold/clipping/clipPolyVsPoly.ts +72 -0
package/src/physics/narrowphase/CollideBodiesModule.ts +755 -0
package/src/physics/solver/ContactConstraintModule.ts +659 -0
package/src/physics/solver/ManifoldConstraint.ts +420 -0
package/src/physics/solver/estimateCollisionResponse.ts +146 -0
package/src/shape/Aabb.ts +400 -0
package/src/shape/Box.ts +231 -0
package/src/shape/Capsule.ts +332 -0
package/src/shape/CompoundShape.ts +288 -0
package/src/shape/Convex.ts +130 -0
package/src/shape/ConvexHull.ts +423 -0
package/src/shape/Cylinder.ts +313 -0
package/src/shape/HeightMap.ts +511 -0
package/src/shape/Line.ts +14 -0
package/src/shape/Plane.ts +116 -0
package/src/shape/Ray.ts +81 -0
package/src/shape/Segment.ts +25 -0
package/src/shape/Shape.ts +77 -0
package/src/shape/Sphere.ts +181 -0
package/src/shape/TransformedShape.ts +51 -0
package/src/shape/Triangle.ts +122 -0
package/src/shape/TriangleMesh.ts +186 -0
package/src/types.ts +1 -0
package/src/world.ts +1335 -0
package/tests/BodyPairsModule.test.ts +71 -0
package/tests/BvhTree.test.ts +406 -0
package/tests/test.md +642 -0
package/tests/vec3.test.ts +12 -0
package/tsconfig.json +20 -0
package/vite.config.js +40 -0

package/src/physics/broadphase/BvhTree.ts ADDED Viewed

@@ -0,0 +1,803 @@
+import {
+  createClass,
+  LazyReferenceListType,
+  LazyReferenceType,
+  MonomorphInstance,
+  MonomorphType,
+  NumberType,
+  PropertyDefinitionMap,
+  PropertyDefinitionReference,
+  PropertyDefinitionReferenceList,
+  WithPool,
+} from "monomorph";
+import { Aabb } from "../../shape/Aabb";
+import { assert } from "../../helpers";
+import { Vec3 } from "../../math/vec3";
+import { Body } from "../Body";
+import { Ray } from "../../shape/Ray";
+import { shouldPairCollide } from "../CollisionFilter";
+const expandedObjectBounds = /*@__PURE__*/ Aabb.create();
+const leftAabb = /*@__PURE__*/ Aabb.create();
+const rightAabb = /*@__PURE__*/ Aabb.create();
+const centroidBounds = /*@__PURE__*/ Aabb.create();
+const extent = /*@__PURE__*/ Vec3.create();
+const ray = /*@__PURE__*/ Ray.create();
+const halfExtents = /*@__PURE__*/ Vec3.create();
+const nodeBounds = /*@__PURE__*/ Aabb.create();
+const bodyBounds = /*@__PURE__*/ Aabb.create();
+const bvhNodeProps = {
+  parent: LazyReferenceType((() => BvhNode) as () => never) as PropertyDefinitionReference<BvhNode | null, true>,
+  left: LazyReferenceType((() => BvhNode) as () => never) as PropertyDefinitionReference<BvhNode | null, true>,
+  right: LazyReferenceType((() => BvhNode) as () => never) as PropertyDefinitionReference<BvhNode | null, true>,
+  computedBounds: MonomorphType(Aabb, undefined, true),
+  height: NumberType(0),
+  objects: LazyReferenceListType((() => Body) as () => never) as PropertyDefinitionReferenceList<Body, Body extends MonomorphInstance<infer P, infer I> ? P : never, Body extends MonomorphInstance<infer P, infer I> ? I : never>,
+} as const satisfies PropertyDefinitionMap;
+export class BvhNode extends createClass<BvhNode, typeof bvhNodeProps>(bvhNodeProps) {
+  // objects: Body[] = [];
+  isLeaf() {
+    return this.left === null && this.right === null;
+  }
+  isRoot() {
+    return this.parent === null;
+  }
+}
+function sortByX(a: Body, b: Body) {
+  return a.computedBounds.centroid.x - b.computedBounds.centroid.x;
+}
+function sortByY(a: Body, b: Body) {
+  return a.computedBounds.centroid.y - b.computedBounds.centroid.y;
+}
+function sortByZ(a: Body, b: Body) {
+  return a.computedBounds.centroid.z - b.computedBounds.centroid.z;
+}
+const sortByAxisFunctions = {
+  0: sortByX,
+  1: sortByY,
+  2: sortByZ,
+} as const;
+export type BvhTreeOptions = {
+  maxDepth: number;
+  maxObjectsPerLeaf: number;
+  expansionMargin: number;
+};
+const sortedObjects: WithPool<Body>[] = [];
+export class BvhTree {
+  options: BvhTreeOptions;
+  nodes: typeof BvhNode.ReferenceList;
+  bodyPool: typeof Body.Pool;
+  root: BvhNode | null = null;
+  optimizeQueue: BvhNode[];
+  optimizeQueueHead: number;
+  intersectStack: BvhNode[];
+  walkStack: BvhNode[];
+  dirtyObjects: Set<WithPool<Body>>;
+  constructor(options: BvhTreeOptions, bvhNodePool: typeof BvhNode.Pool, bodyPool: typeof Body.Pool) {
+    this.options = options;
+    this.bodyPool = bodyPool;
+    this.nodes = new BvhNode.ReferenceList(bvhNodePool);
+    this.root = null;
+    this.optimizeQueue = [];
+    this.optimizeQueueHead = 0;
+    this.intersectStack = [];
+    this.walkStack = [];
+    this.dirtyObjects = new Set<WithPool<Body>>();
+  }
+  markObjectAsDirty(object: WithPool<Body>) {
+    this.dirtyObjects.add(object);
+  }
+  updateDirtyObjects() {
+    for (const object of this.dirtyObjects) {
+      if (this.update(object, false)) {
+      }
+    }
+    this.dirtyObjects.clear();
+  }
+  rebalance(node: BvhNode): BvhNode {
+    if (node.isLeaf() || node.height < 2) {
+      return node;
+    }
+    const left = node.left!;
+    const right = node.right!;
+    const balance = right.height - left.height;
+    // Rotate right up
+    if (balance > 1) {
+      const rightLeft = right.left!;
+      const rightRight = right.right!;
+      // Swap node and right
+      right.left = node;
+      right.parent = node.parent;
+      node.parent = right;
+      if (right.parent) {
+        if (right.parent.left === node) {
+          right.parent.left = right;
+        } else {
+          right.parent.right = right;
+        }
+      } else {
+        this.root = right;
+      }
+      if (rightLeft.height > rightRight.height) {
+        right.right = rightLeft;
+        node.right = rightRight;
+        rightRight.parent = node;
+        node.computedBounds.unionAabbs(left.computedBounds, rightRight.computedBounds);
+        right.computedBounds.unionAabbs(node.computedBounds, rightLeft.computedBounds);
+        node.height = Math.max(left.height, rightRight.height) + 1;
+        right.height = Math.max(node.height, rightLeft.height) + 1;
+      } else {
+        right.right = rightRight;
+        node.right = rightLeft;
+        rightLeft.parent = node;
+        node.computedBounds.unionAabbs(left.computedBounds, rightLeft.computedBounds);
+        right.computedBounds.unionAabbs(node.computedBounds, rightRight.computedBounds);
+        node.height = Math.max(left.height, rightLeft.height) + 1;
+        right.height = Math.max(node.height, rightRight.height) + 1;
+      }
+      return right;
+    }
+    // Rotate left up
+    if (balance < -1) {
+      const leftLeft = left.left!;
+      const leftRight = left.right!;
+      // Swap node and left
+      left.left = node;
+      left.parent = node.parent;
+      node.parent = left;
+      if (left.parent) {
+        if (left.parent.left === node) {
+          left.parent.left = left;
+        } else {
+          left.parent.right = left;
+        }
+      } else {
+        this.root = left;
+      }
+      if (leftLeft.height > leftRight.height) {
+        left.right = leftLeft;
+        node.left = leftRight;
+        leftRight.parent = node;
+        node.computedBounds.unionAabbs(right.computedBounds, leftRight.computedBounds);
+        left.computedBounds.unionAabbs(node.computedBounds, leftLeft.computedBounds);
+        node.height = Math.max(right.height, leftRight.height) + 1;
+        left.height = Math.max(node.height, leftLeft.height) + 1;
+      } else {
+        left.right = leftRight;
+        node.left = leftLeft;
+        leftLeft.parent = node;
+        node.computedBounds.unionAabbs(right.computedBounds, leftLeft.computedBounds);
+        left.computedBounds.unionAabbs(node.computedBounds, leftRight.computedBounds);
+        node.height = Math.max(right.height, leftLeft.height) + 1;
+        left.height = Math.max(node.height, leftRight.height) + 1;
+      }
+      return left;
+    }
+    return node;
+  }
+  refit(node: BvhNode | null) {
+    let didRefit = false;
+    while (node) {
+      didRefit = true;
+      if (node.isLeaf()) {
+        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.height = 0;
+      } else {
+        const left = node.left!;
+        const right = node.right!;
+        node.computedBounds.unionAabbs(left.computedBounds, right.computedBounds);
+        node.height = Math.max(left.height, right.height) + 1;
+        if (node.height > 2) {
+          // this.tryRotation(node);
+          this.rebalance(node);
+        }
+      }
+      node = node.parent;
+    }
+    return didRefit;
+  }
+  optimizeOncePerFrame(maxNodesToCheck: number) {
+    if (!this.root) {
+      return;
+    }
+    const queue = this.optimizeQueue;
+    let head = this.optimizeQueueHead;
+    let tail = 0;
+    // init the queue if empty
+    if (head === 0 && queue.length === 0) {
+      queue.push(this.root);
+      tail = 1;
+    } else {
+      tail = queue.length;
+    }
+    let count = 0;
+    while (head < tail && count < maxNodesToCheck) {
+      const node = queue[head++];
+      if (!node.isLeaf()) {
+        // this.tryRotation(node);
+        this.rebalance(node);
+        count++;
+        if (node.left) {
+          queue.push(node.left);
+        }
+        if (node.right) {
+          queue.push(node.right);
+        }
+      }
+    }
+    // reset if done or save head for next call
+    if (head >= queue.length) {
+      queue.length = 0;
+      this.optimizeQueueHead = 0;
+    } else {
+      this.optimizeQueueHead = head;
+    }
+  }
+  splitObjects(outLeft: BvhNode, outRight: BvhNode, nodeToSplit: BvhNode) {
+    const objects = nodeToSplit.objects;
+    const leftObjects = outLeft.objects;
+    const rightObjects = outRight.objects;
+    if (objects.length < 2) {
+      throw new Error("Cannot split fewer than 2 objects.");
+    }
+    // expand centroid bounds
+    centroidBounds.min.fromArray([+Infinity, +Infinity, +Infinity]);
+    centroidBounds.max.fromArray([-Infinity, -Infinity, -Infinity]);
+    sortedObjects.length = 0;
+    for (const obj of objects) {
+      centroidBounds.expandToPoint(obj.computedBounds.centroid);
+      sortedObjects.push(obj);
+    }
+    centroidBounds.computeExtents(extent);
+    const axis = centroidBounds.computeLargestAxis();
+    sortedObjects.sort(sortByAxisFunctions[axis]);
+    let mid = Math.floor(sortedObjects.length / 2);
+    if (mid <= 0 || mid >= sortedObjects.length) {
+      mid = 1;
+    }
+    for (let i = 0; i < mid; i++) {
+      leftObjects.push(sortedObjects[i]);
+      sortedObjects[i].node = outLeft;
+    }
+    for (let i = mid; i < sortedObjects.length; i++) {
+      rightObjects.push(sortedObjects[i]);
+      sortedObjects[i].node = outRight;
+    }
+  }
+  createBvhNode() {
+    return this.nodes.create({
+      objects: {
+        pool: this.bodyPool,
+      },
+    });
+  };
+  destroyBvhNode(node: WithPool<BvhNode>) {
+    // this.nodes.remove(node);
+    node.destroy();
+  }
+  insert(object: WithPool<Body>, shouldUpdateDirtyObjects: boolean = true) {
+    expandedObjectBounds.expandAabb(object.computedBounds, this.options.expansionMargin);
+    // case: tree is empty
+    if (!this.root) {
+      const root = this.createBvhNode();
+      root.computedBounds.copy(expandedObjectBounds);
+      root.objects.push(object);
+      root.height = 0;
+      this.root = root;
+      object.node = root;
+      return true;
+    }
+    // find the best-fit leaf node
+    let best = this.root;
+    while (!best.isLeaf()) {
+      const left = best.left!;
+      const right = best.right!;
+      leftAabb.unionAabbs(best.computedBounds, left.computedBounds);
+      rightAabb.unionAabbs(best.computedBounds, right.computedBounds);
+      const leftCost = leftAabb.computeSurfaceArea();
+      const rightCost = rightAabb.computeSurfaceArea();
+      best = leftCost < rightCost ? left : right;
+    }
+    // #v-ifdef DEV
+    // dev assert best.isLeaf();
+    assert(best.isLeaf(), "Expected best node to be a leaf node.");
+    // #v-endif
+    // case: best leaf node is not full
+    if (best.objects.length < this.options.maxObjectsPerLeaf || best.height >= this.options.maxDepth) {
+      best.objects.push(object);
+      best.computedBounds.unionAabb(expandedObjectBounds);
+      object.node = best;
+      return this.refit(best);
+    }
+    // case: best leaf node is full, need to split
+    const left = this.createBvhNode();
+    const right = this.createBvhNode();
+    // partition the objects in the two new leaves
+    // we push the object to best temporarily so it can be included in the split
+    best.objects.push(object);
+    this.splitObjects(left, right, best);
+    // we clear best's objects now
+    best.objects.length = 0;
+    // update left leaf
+    left.computedBounds.copy(left.objects.getAtIndex(0)!.computedBounds);
+    for (let i = 1; i < left.objects.length; i++) {
+      left.computedBounds.unionAabb(left.objects.getAtIndex(i)!.computedBounds);
+    }
+    left.parent = best;
+    left.height = 0;
+    // update right leaf
+    right.computedBounds.copy(right.objects.getAtIndex(0)!.computedBounds);
+    for (let i = 1; i < right.objects.length; i++) {
+      right.computedBounds.unionAabb(right.objects.getAtIndex(i)!.computedBounds);
+    }
+    right.parent = best;
+    right.height = 0;
+    // update best node
+    best.left = left;
+    best.right = right;
+    best.computedBounds.unionAabbs(left.computedBounds, right.computedBounds);
+    best.height = 1;
+    return this.refit(best);
+  }
+  remove(object: WithPool<Body>, shouldRemoveFromDirtyObjects: boolean = false) {
+    const node = object.node as WithPool<BvhNode> | null;
+    if (shouldRemoveFromDirtyObjects) {
+      this.dirtyObjects.delete(object);
+    }
+    if (!node) {
+      return;
+    }
+    const wasFoundAndRemoved = node.objects.remove(object) > -1; // fastRemove(node.objects, object);
+    if (!wasFoundAndRemoved) {
+      return;
+    }
+    object.node = null;
+    // If there are still objects in the node, just refit and exit
+    if (node.objects.length > 0) {
+      return this.refit(node);
+    }
+    // If the node is the root, and it's now empty
+    if (node.isRoot()) {
+      this.destroyBvhNode(node);
+      this.root = null;
+      return false;
+    }
+    const parent = node.parent!;
+    const sibling = parent.left === node ? parent.right! : parent.left!;
+    sibling.parent = parent.parent;
+    if (parent.isRoot()) {
+      this.root = sibling;
+    } else {
+      const grandparent = parent.parent!;
+      if (grandparent.left === parent) {
+        grandparent.left = sibling;
+      } else {
+        grandparent.right = sibling;
+      }
+    }
+    this.destroyBvhNode(parent as WithPool<BvhNode>);
+    this.destroyBvhNode(node);
+    return this.refit(sibling);
+  }
+  update(object: WithPool<Body>, shouldUpdateDirtyObjects: boolean = true) {
+    const node = object.node;
+    if (!node) {
+      this.insert(object);
+      return false;
+    }
+    // avoid refit if there will be no change to node bounds
+    if (node.computedBounds.enclosesAabb(object.computedBounds)) {
+      return false;
+    }
+    this.remove(object);
+    return this.insert(object);
+  }
+  intersectBody(onHit: (Body: Body) => boolean, body: Body, shouldUpdateDirtyObjects: boolean = true) {
+    // console.log("intersect body", body);
+    if (!this.root) {
+      return;
+    }
+    if (shouldUpdateDirtyObjects) {
+      this.updateDirtyObjects();
+    }
+    const stack = this.intersectStack;
+    stack.length = 0;
+    stack.push(this.root);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) {
+        continue;
+      }
+      // skip this node if it doesn't intersect the AABB
+      if (!node.computedBounds.intersectsAabb(body.computedBounds)) {
+        continue;
+      }
+      // if the node is not a leaf, push its children onto the stack and continue
+      if (!node.isLeaf()) {
+        stack.push(node.left!);
+        stack.push(node.right!);
+        continue;
+      }
+      // if the node is a leaf, check its objects
+      for (const otherBody of node.objects) {
+        if (body === otherBody) {
+          // console.log("skipping self");
+          continue;
+        }
+        if (
+          shouldPairCollide(
+            body.belongsToGroups,
+            body.collidesWithGroups,
+            otherBody.belongsToGroups,
+            otherBody.collidesWithGroups
+          ) === false
+        ) {
+          continue;
+        }
+        if (!body.computedBounds.intersectsAabb(otherBody.computedBounds)) {
+          continue;
+        }
+        if (onHit(otherBody)) {
+          return;
+        }
+      }
+    }
+  }
+  walk(onNode: (node: BvhNode) => boolean) {
+    if (!this.root) {
+      return;
+    }
+    const stack = this.walkStack;
+    stack.length = 0;
+    stack.push(this.root);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) {
+        continue;
+      }
+      if (onNode(node)) {
+        return;
+      }
+      if (!node.isLeaf()) {
+        stack.push(node.left!);
+        stack.push(node.right!);
+      }
+    }
+  }
+  isEmpty() {
+    return this.root === null;
+  }
+  visitBodiesWithCollision(
+    bodyVisitor: BodyVisitor,
+    bounds: Aabb,
+    belongsToGroups: number,
+    collidesWithGroups: number,
+    shouldUpdateDirtyObjects: boolean = true
+  ): void {
+    // exit if the tree is empty
+    if (!this.root) {
+      return;
+    }
+    if (shouldUpdateDirtyObjects) {
+      this.updateDirtyObjects();
+    }
+    const stack = this.intersectStack;
+    stack.length = 0;
+    stack.push(this.root);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) {
+        continue;
+      }
+      // skip this node if it doesn't intersect the AABB
+      if (node.computedBounds.intersectsAabb(bounds) === false) {
+        continue;
+      }
+      // if the node is not a leaf, push its children onto the stack and continue
+      if (!node.isLeaf()) {
+        stack.push(node.left!);
+        stack.push(node.right!);
+        continue;
+      }
+      // if the node is a leaf, check its objects
+      for (const body of node.objects) {
+        if (
+          shouldPairCollide(body.belongsToGroups, body.collidesWithGroups, belongsToGroups, collidesWithGroups) ===
+          false
+        ) {
+          continue;
+        }
+        if (!body.computedBounds.intersectsAabb(bounds)) {
+          continue;
+        }
+        // visit the body
+        bodyVisitor.visit(body);
+        // break if visitor requests exit
+        if (bodyVisitor.shouldExit) {
+          return;
+        }
+      }
+    }
+  }
+  raycastBodies(
+    bodyVisitor: BodyVisitor,
+    ray: Ray,
+    belongsToGroups: number,
+    collidesWithGroups: number,
+    shouldUpdateDirtyObjects: boolean = true
+  ) {
+    // exit if the tree is empty
+    if (!this.root) {
+      return;
+    }
+    if (shouldUpdateDirtyObjects) {
+      this.updateDirtyObjects();
+    }
+    const stack = this.intersectStack;
+    stack.length = 0;
+    stack.push(this.root);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) {
+        continue;
+      }
+      // skip branch if the node's aabb does not intersect with the ray
+      nodeBounds.copy(node.computedBounds);
+      if (ray.intersectsAabb(nodeBounds) === false) {
+        continue;
+      }
+      // if the node is not a leaf, push its children onto the stack and continue
+      if (!node.isLeaf()) {
+        stack.push(node.left!);
+        stack.push(node.right!);
+        continue;
+      }
+      // if the node is a leaf, check its objects
+      for (const body of node.objects) {
+        if (
+          shouldPairCollide(body.belongsToGroups, body.collidesWithGroups, belongsToGroups, collidesWithGroups) ===
+          false
+        ) {
+          continue;
+        }
+        // skip if bounds do not collide
+        bodyBounds.copy(body.computedBounds);
+        if (ray.intersectsAabb(bodyBounds) === false) {
+          continue;
+        }
+        // visit the body
+        bodyVisitor.visit(body);
+        // break if visitor requests exit
+        if (bodyVisitor.shouldExit) {
+          return;
+        }
+      }
+    }
+  }
+  visitBodiesWithCast(
+    bodyVisitor: BodyVisitor,
+    bounds: Aabb,
+    displacement: Vec3,
+    belongsToGroups: number,
+    collidesWithGroups: number,
+    shouldUpdateDirtyObjects: boolean = true
+  ): void {
+    // exit if the tree is empty
+    if (!this.root) {
+      return;
+    }
+    if (shouldUpdateDirtyObjects) {
+      this.updateDirtyObjects();
+    }
+    // aabb cast is done by the following method
+    // 1. shrink the shape aabb by its own extents down to a point
+    // 2. expand the block aabb by the extents of the shape aabb
+    // 3. cast the point by the displacement against the expanded block aabb (raycast vs aabb test)
+    bounds.computeCentroid(ray.origin);
+    ray.direction.normalizeVector(displacement);
+    ray.length = displacement.length();
+    bounds.computeHalfExtents(halfExtents);
+    const stack = this.intersectStack;
+    stack.length = 0;
+    stack.push(this.root);
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!node) {
+        continue;
+      }
+      // skip branch if the node's expanded aabb does not intersect with the shape's ray
+      nodeBounds.copy(node.computedBounds);
+      nodeBounds.expandByVector(halfExtents);
+      if (ray.intersectsAabb(nodeBounds) === false) {
+        continue;
+      }
+      // if the node is not a leaf, push its children onto the stack and continue
+      if (!node.isLeaf()) {
+        stack.push(node.left!);
+        stack.push(node.right!);
+        continue;
+      }
+      // if the node is a leaf, check its objects
+      for (const body of node.objects) {
+        if (
+          shouldPairCollide(body.belongsToGroups, body.collidesWithGroups, belongsToGroups, collidesWithGroups) ===
+          false
+        ) {
+          continue;
+        }
+        // expand the object aabb by the shape's aabb
+        // skip if bounds do not collide
+        bodyBounds.copy(body.computedBounds);
+        bodyBounds.expandByVector(halfExtents);
+        if (ray.intersectsAabb(bodyBounds) === false) {
+          continue;
+        }
+        // visit the body
+        bodyVisitor.visit(body);
+        // break if visitor requests exit
+        if (bodyVisitor.shouldExit) {
+          return;
+        }
+      }
+    }
+  }
+}
+export interface BodyVisitor {
+  shouldExit: boolean;
+  visit(body: Body): void;
+}