@perplexdotgg/bounce 1.0.0

package/tests/BodyPairsModule.test.ts

@@ -0,0 +1,71 @@
+import { describe, it, expect } from "vitest";
+import { Body, BodyPairNode, BodyPairsModule } from "../src/index";
+
+describe("BodyPairsModule", () => {
+  it("should add body pairs", () => {
+    const bodies = [];
+    for (let i = 0; i < 5; i++) {
+      const body = Body.create({
+        position: { x: i, y: 0, z: 0 },
+        orientation: { x: 0, y: 0, z: 0 },
+      });
+      bodies.push(body);
+    }
+    const pairs = new BodyPairsModule();
+    pairs.createPair(bodies[0], bodies[1]); // AB
+    pairs.createPair(bodies[1], bodies[2]); // BC
+    pairs.createPair(bodies[0], bodies[2]); // AC
+    pairs.createPair(bodies[3], bodies[4]); // DE
+    pairs.createPair(bodies[0], bodies[3]); // AD
+    pairs.createPair(bodies[4], bodies[0]); // AE
+    pairs.destroyPair(bodies[0], bodies[3]); // AD
+    const collectedPairs: BodyPairNode[] = [];
+    collectedPairs.length = 0;
+    for (const pair of pairs.iteratePairsOfOne(bodies[0])) {
+      collectedPairs.push(pair);
+    }
+    collectedPairs.reverse();
+    expect(collectedPairs.length).toBe(3);
+    expect(collectedPairs[0].bodyA! === bodies[0]).toBe(true);
+    expect(collectedPairs[0].bodyB! === bodies[1]).toBe(true);
+    expect(collectedPairs[1].bodyA! === bodies[0]).toBe(true);
+    expect(collectedPairs[1].bodyB! === bodies[2]).toBe(true);
+    expect(collectedPairs[2].bodyA! === bodies[4]).toBe(true);
+    expect(collectedPairs[2].bodyB! === bodies[0]).toBe(true);
+    collectedPairs.length = 0;
+    for (const pair of pairs.iteratePairsOfOne(bodies[1])) {
+      collectedPairs.push(pair);
+    }
+    collectedPairs.reverse();
+    expect(collectedPairs.length).toBe(2);
+    expect(collectedPairs[0].bodyA! === bodies[0]).toBe(true);
+    expect(collectedPairs[0].bodyB! === bodies[1]).toBe(true);
+    expect(collectedPairs[1].bodyA! === bodies[1]).toBe(true);
+    expect(collectedPairs[1].bodyB! === bodies[2]).toBe(true);
+    collectedPairs.length = 0;
+    for (const pair of pairs.iteratePairs()) {
+      collectedPairs.push(pair);
+    }
+    expect(collectedPairs.length).toBe(5);
+    expect(collectedPairs[0].bodyA! === bodies[0]).toBe(true);
+    expect(collectedPairs[0].bodyB! === bodies[1]).toBe(true);
+    expect(collectedPairs[1].bodyA! === bodies[1]).toBe(true);
+    expect(collectedPairs[1].bodyB! === bodies[2]).toBe(true);
+    expect(collectedPairs[2].bodyA! === bodies[0]).toBe(true);
+    expect(collectedPairs[2].bodyB! === bodies[2]).toBe(true);
+    expect(collectedPairs[3].bodyA! === bodies[3]).toBe(true);
+    expect(collectedPairs[3].bodyB! === bodies[4]).toBe(true);
+    expect(collectedPairs[4].bodyA! === bodies[4]).toBe(true);
+    expect(collectedPairs[4].bodyB! === bodies[0]).toBe(true);
+    pairs.destroyAllPairsOfOne(bodies[0]);
+    collectedPairs.length = 0;
+    for (const pair of pairs.iteratePairs()) {
+      collectedPairs.push(pair);
+    }
+    expect(collectedPairs.length).toBe(2);
+    expect(collectedPairs[0].bodyA! === bodies[1]);
+    expect(collectedPairs[0].bodyB! === bodies[2]);
+    expect(collectedPairs[1].bodyA! === bodies[3]);
+    expect(collectedPairs[1].bodyB! === bodies[4]);
+  });
+});

package/tests/BvhTree.test.ts

@@ -0,0 +1,406 @@
+import { describe, it, expect } from "vitest";
+import { World, BvhTree, Aabb, Body } from "../src/index";
+
+interface Vec3Like {
+  x: number;
+  y: number;
+  z: number;
+}
+
+function createTestBody(world: World, x: number, y: number, z: number, radius = 0.5) {
+  const shape = world.createSphere({ radius });
+  return world.createDynamicBody({
+    shape,
+    position: { x, y, z },
+    orientation: { x: 0, y: 0, z: 0 },
+  });
+}
+
+function createTestBodyWithExtents(world: World, min: Vec3Like, max: Vec3Like) {
+  const shape = world.createSphere({ radius: 1.0 });
+  const body = world.createDynamicBody({
+    shape,
+    position: { x: 0, y: 0, z: 0 },
+    orientation: { x: 0, y: 0, z: 0 },
+  });
+  body.computedBounds.setExtents(min, max);
+  return body;
+}
+
+function destroyTestBody(world: World, body: Body) {
+  world.destroyBody(body);
+}
+
+function createSeededRng(seed: number) {
+  let state = seed >>> 0;
+  return () => {
+    state = (1664525 * state + 1013904223) >>> 0;
+    return state / 0x100000000;
+  };
+}
+
+describe("BvhTree", () => {
+  it("inserts and intersects one object", () => {
+    const world = new World();
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    const body = createTestBody(world, 0, 0, 0);
+    tree.insert(body);
+
+    const query = Aabb.create();
+    query.setExtents({ x: -1, y: -1, z: -1 }, { x: 1, y: 1, z: 1 });
+
+    let hitCount = 0;
+    tree.intersectAabb(() => {
+      hitCount++;
+      return false;
+    }, query);
+
+    expect(hitCount).toBe(1);
+  });
+
+  it("removes objects correctly", () => {
+    const world = new World();
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    const body = createTestBody(world, 0, 0, 0);
+    tree.insert(body);
+    tree.remove(body);
+
+    const query = Aabb.create();
+    query.setExtents({ x: -1, y: -1, z: -1 }, { x: 1, y: 1, z: 1 });
+
+    let hitCount = 0;
+    tree.intersectAabb(() => {
+      hitCount++;
+      return false;
+    }, query);
+
+    expect(hitCount).toBe(0);
+  });
+
+  it("updates objects correctly", () => {
+    const world = new World();
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    const body = createTestBody(world, 0, 0, 0);
+    tree.insert(body);
+
+    body.computedBounds.setExtents({ x: 10, y: 10, z: 10 }, { x: 11, y: 11, z: 11 });
+    tree.update(body);
+
+    const nearQuery = Aabb.create();
+    nearQuery.setExtents({ x: -1, y: -1, z: -1 }, { x: 1, y: 1, z: 1 });
+
+    let nearHits = 0;
+    tree.intersectAabb(() => {
+      nearHits++;
+      return false;
+    }, nearQuery);
+    expect(nearHits).toBe(0);
+
+    const farQuery = Aabb.create();
+    farQuery.setExtents({ x: 9, y: 9, z: 9 }, { x: 12, y: 12, z: 12 });
+
+    let farHits = 0;
+    tree.intersectAabb(() => {
+      farHits++;
+      return false;
+    }, farQuery);
+    expect(farHits).toBe(1);
+  });
+
+  it("inserts a single object into the root", () => {
+    const tree = new BvhTree({ maxDepth: 10, maxObjectsPerLeaf: 2, expansionMargin: 0.1 });
+
+    const object = Body.create(undefined);
+    object.computedBounds.setExtents({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+
+    tree.insert(object);
+
+    expect(tree.root).toBeDefined();
+    expect(tree.root!.isLeaf()).toBe(true);
+    expect(tree.root!.objects).toContain(object);
+    expect(object.node).toBe(tree.root);
+  });
+
+  it("inserts two objects into the same leaf", () => {
+    const tree = new BvhTree({ maxDepth: 10, maxObjectsPerLeaf: 2, expansionMargin: 0.1 });
+
+    const a = Body.create(undefined);
+    a.computedBounds.setExtents({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+
+    const b = Body.create(undefined);
+    b.computedBounds.setExtents({ x: 2, y: 2, z: 2 }, { x: 3, y: 3, z: 3 });
+
+    tree.insert(a);
+    tree.insert(b);
+
+    expect(tree.root).toBeDefined();
+    expect(tree.root!.isLeaf()).toBe(true);
+    expect(tree.root!.objects).toContain(a);
+    expect(tree.root!.objects).toContain(b);
+  });
+
+  it("splits root when inserting third object", () => {
+    const tree = new BvhTree({ maxDepth: 10, maxObjectsPerLeaf: 2, expansionMargin: 0.1 });
+
+    const a = Body.create(undefined);
+    a.computedBounds.setExtents({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+    const b = Body.create(undefined);
+    b.computedBounds.setExtents({ x: 2, y: 2, z: 2 }, { x: 3, y: 3, z: 3 });
+    const c = Body.create(undefined);
+    c.computedBounds.setExtents({ x: 4, y: 4, z: 4 }, { x: 5, y: 5, z: 5 });
+
+    tree.insert(a);
+    tree.insert(b);
+    tree.insert(c);
+
+    const root = tree.root!;
+    const rootLeft = root.left!;
+    const rootRight = root.right!;
+    expect(root.isLeaf()).toBe(false);
+    expect(root.left).toBeDefined();
+    expect(root.right).toBeDefined();
+    expect(rootLeft.isLeaf()).toBe(true);
+    expect(rootRight.isLeaf()).toBe(true);
+
+    const all = [...rootLeft.objects, ...rootRight.objects];
+    expect(all).toEqual(expect.arrayContaining([a, b, c]));
+  });
+
+  it("respects early exit from intersectAabb", () => {
+    const world = new World();
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    for (let i = 0; i < 10; i++) {
+      const body = createTestBody(world, i * 2, 0, 0);
+      tree.insert(body);
+    }
+
+    const query = Aabb.create();
+    query.setExtents({ x: 0, y: -1, z: -1 }, { x: 20, y: 1, z: 1 });
+
+    let called = 0;
+    tree.intersectAabb(() => {
+      called++;
+      return true;
+    }, query);
+
+    expect(called).toBe(1);
+  });
+
+  it("handles multiple inserts and finds all", () => {
+    const world = new World();
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    const count = 50;
+    for (let i = 0; i < count; i++) {
+      const body = createTestBody(world, i * 2, 0, 0);
+      tree.insert(body);
+    }
+
+    const query = Aabb.create();
+    query.setExtents({ x: -1, y: -1, z: -1 }, { x: count * 2, y: 1, z: 1 });
+
+    let hits = 0;
+    tree.intersectAabb(() => {
+      hits++;
+      return false;
+    }, query);
+
+    expect(hits).toBe(count);
+  });
+
+  it("removes a middle object", () => {
+    const tree = new BvhTree({ maxDepth: 10, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    const objects = [];
+    for (let i = 0; i < 6; i++) {
+      const obj = Body.create(undefined);
+      obj.computedBounds.setExtents({ x: i * 2, y: 0, z: 0 }, { x: i * 2 + 1, y: 1, z: 1 });
+      objects.push(obj);
+    }
+
+    for (const obj of objects) {
+      tree.insert(obj);
+    }
+
+    // remove a middle object
+    tree.remove(objects[2]);
+
+    const query = Aabb.create();
+    query.setExtents({ x: 0, y: 0, z: 0 }, { x: 20, y: 1, z: 1 });
+
+    let hitCount = 0;
+    tree.intersectAabb(() => {
+      hitCount++;
+      return false;
+    }, query);
+
+    expect(hitCount).toBe(objects.length - 1);
+    expect(objects[2].node).toBe(null);
+  });
+
+  it("removes the only object", () => {
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 1, expansionMargin: 0 });
+
+    const obj = Body.create(undefined);
+    obj.computedBounds.setExtents({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+
+    tree.insert(obj);
+    tree.remove(obj);
+
+    expect(tree.root).toBe(null);
+  });
+
+  it("updates an object to move across the tree", () => {
+    const tree = new BvhTree({ maxDepth: 10, maxObjectsPerLeaf: 1, expansionMargin: 0 });
+
+    const objectA = Body.create(undefined);
+    objectA.computedBounds.setExtents({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+    objectA.node = null;
+
+    const objectB = Body.create(undefined);
+    objectB.computedBounds.setExtents({ x: 10, y: 0, z: 0 }, { x: 11, y: 1, z: 1 });
+    objectB.node = null;
+
+    tree.insert(objectA);
+    tree.insert(objectB);
+
+    objectA.computedBounds.setExtents({ x: 20, y: 0, z: 0 }, { x: 21, y: 1, z: 1 });
+    tree.update(objectA);
+
+    const query1 = Aabb.create();
+    query1.setExtents({ x: 0, y: 0, z: 0 }, { x: 5, y: 1, z: 1 });
+
+    let nearHits = 0;
+    tree.intersectAabb(() => {
+      nearHits++;
+      return false;
+    }, query1);
+
+    expect(nearHits).toBe(0);
+
+    const query2 = Aabb.create();
+    query2.setExtents({ x: 19, y: 0, z: 0 }, { x: 22, y: 1, z: 1 });
+
+    let farHits = 0;
+    tree.intersectAabb(() => {
+      farHits++;
+      return false;
+    }, query2);
+
+    expect(farHits).toBe(1);
+    expect(objectA.node).not.toBe(null);
+  });
+
+  it("updates object with no bounding box change", () => {
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin: 0 });
+
+    const object = Body.create(undefined);
+    object.computedBounds.setExtents({ x: 5, y: 5, z: 5 }, { x: 6, y: 6, z: 6 });
+    object.node = null;
+
+    tree.insert(object);
+    tree.update(object);
+
+    const query = Aabb.create();
+    query.setExtents({ x: 4, y: 4, z: 4 }, { x: 7, y: 7, z: 7 });
+
+    let hits = 0;
+    tree.intersectAabb(() => {
+      hits++;
+      return false;
+    }, query);
+
+    expect(hits).toBe(1);
+  });
+
+  it("does not refit if update is within expansion margin", () => {
+    const expansionMargin = 1.0;
+    const tree = new BvhTree({ maxDepth: 4, maxObjectsPerLeaf: 2, expansionMargin });
+
+    const object = Body.create(undefined);
+    object.computedBounds.setExtents({ x: 0, y: 0, z: 0 }, { x: 1, y: 1, z: 1 });
+    object.node = null;
+
+    tree.insert(object);
+
+    // move the object slightly, within the margin
+    object.computedBounds.setExtents({ x: 0.2, y: 0.2, z: 0.2 }, { x: 1.2, y: 1.2, z: 1.2 });
+
+    const didRefit = tree.update(object);
+    expect(didRefit).toBe(false);
+
+    const query = Aabb.create();
+    query.setExtents({ x: 0, y: 0, z: 0 }, { x: 2, y: 2, z: 2 });
+
+    let hits = 0;
+    tree.intersectAabb(() => {
+      hits++;
+      return false;
+    }, query);
+
+    expect(hits).toBe(1);
+  });
+
+  it("handles many dynamic inserts, updates, and removals", () => {
+    const tree = new BvhTree({ maxDepth: 8, maxObjectsPerLeaf: 4, expansionMargin: 0 });
+    const rng = createSeededRng(42);
+
+    const objects = [];
+    const objectsInTheTree = new Set<Body>();
+
+    const world = new World();
+
+    const numObjects = 100;
+    const numToMove = Math.floor(numObjects / 2);
+    const numToRemove = Math.floor(numObjects / 2);
+
+    for (let i = 0; i < numObjects; i++) {
+      const min = { x: i * 2, y: 0, z: 0 };
+      const max = { x: i * 2 + 1, y: 1, z: 1 };
+      const obj = createTestBodyWithExtents(world, min, max);
+      objects.push(obj);
+      objectsInTheTree.add(obj);
+      tree.insert(obj);
+    }
+
+    for (let i = 0; i < numToMove; i++) {
+      const index = Math.floor(rng() * objects.length);
+      const obj = objects[index];
+
+      if (!obj.node) continue;
+
+      const offset = rng() * numObjects;
+      obj.computedBounds.setExtents({ x: offset, y: 0, z: 0 }, { x: offset + 1, y: 1, z: 1 });
+      tree.update(obj);
+    }
+
+    for (let i = 0; i < numToRemove; i++) {
+      const index = Math.floor(rng() * objects.length);
+      const obj = objects[index];
+      if (obj.node) {
+        tree.remove(obj);
+        objectsInTheTree.delete(obj);
+        expect(obj.node).toBe(null);
+      }
+    }
+
+    const query = Aabb.create();
+    query.setExtents({ x: -10000, y: -10000, z: -10000 }, { x: +10000, y: +10000, z: +10000 });
+
+    const actual: Array<Body> = [];
+    const expected = [...objectsInTheTree];
+    tree.intersectAabb(obj => {
+      actual.push(obj);
+      return false;
+    }, query);
+
+    expect(actual.length).toBe(expected.length);
+    const actualSet = new Set(actual);
+    const expectedSet = new Set(expected);
+    expect(actualSet).toEqual(expectedSet);
+  });
+});