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

@perplexdotgg/bounce 1.0.0 → 1.0.2

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 (138) hide show

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

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

@@ -1,803 +0,0 @@
-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;
-}