@flighthq/collision 0.4.0-next.1663.d9c5746 → 0.4.0-next.1695.181dea5

package/src/shapeContact.test.ts

@@ -1,8 +1,8 @@
-import type { CollisionAabb, CollisionCircle, CollisionObb, CollisionPolygon } from '@flighthq/types/contract';
+import type { CollisionAabb2D, CollisionCircle2D, CollisionObb2D, CollisionPolygon2D } from '@flighthq/types/contract';
 import { describe, expect, it } from 'vitest';
 
-import { createCollisionContactManifold } from './contactManifold';
-import { createCollisionManifold } from './manifold';
+import { createCollisionContactManifold2D } from './contactManifold';
+import { createCollisionManifold2D } from './manifold';
 import {
   testAabbAabbCollision,
   testCircleCircleCollision,
@@ -23,24 +23,24 @@ import {
 } from './shapeContact';
 
 // A wide, shallow ground slab every resting-contact case sits on.
-const ground: CollisionAabb = { minX: -5, minY: -1, maxX: 5, maxY: 0 };
+const ground: CollisionAabb2D = { minX: -5, minY: -1, maxX: 5, maxY: 0 };
 
 // A square collider as a flat convex polygon, corners counter-clockwise from the min corner.
-function square(minX: number, minY: number, size: number): CollisionPolygon {
+function square(minX: number, minY: number, size: number): CollisionPolygon2D {
   return { points: [minX, minY, minX + size, minY, minX + size, minY + size, minX, minY + size] };
 }
 
 // The contact points that are actually valid this call, in order. Reading past `pointCount` is
 // outside the contract, so every assertion goes through this.
-function livePoints(manifold: ReturnType<typeof createCollisionContactManifold>) {
+function livePoints(manifold: ReturnType<typeof createCollisionContactManifold2D>) {
   return manifold.points.slice(0, manifold.pointCount);
 }
 
 describe('collideAabbAabbContactManifold', () => {
   it('resolves a box resting on the ground to two points spanning the overlap', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     // The box's underside dips 0.1 below the ground's top face across x[0,2].
-    const box: CollisionAabb = { minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 };
+    const box: CollisionAabb2D = { minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 };
     expect(collideAabbAabbContactManifold(box, ground, out)).toBe(true);
     expect(out.overlapping).toBe(true);
     expect(out.normalX).toBeCloseTo(0);
@@ -62,8 +62,8 @@ describe('collideAabbAabbContactManifold', () => {
   });
 
   it('gives the two points distinct feature ids that survive the box sliding along the ground', () => {
-    const first = createCollisionContactManifold();
-    const second = createCollisionContactManifold();
+    const first = createCollisionContactManifold2D();
+    const second = createCollisionContactManifold2D();
     expect(collideAabbAabbContactManifold({ minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 }, ground, first)).toBe(true);
     expect(collideAabbAabbContactManifold({ minX: 0.3, minY: -0.12, maxX: 2.3, maxY: 1.88 }, ground, second)).toBe(
       true,
@@ -76,10 +76,10 @@ describe('collideAabbAabbContactManifold', () => {
   });
 
   it('agrees with the lean overlap test on normal and depth', () => {
-    const contact = createCollisionContactManifold();
-    const lean = createCollisionManifold();
-    const a: CollisionAabb = { minX: 0, minY: 0, maxX: 10, maxY: 10 };
-    const b: CollisionAabb = { minX: 2, minY: 8, maxX: 8, maxY: 20 };
+    const contact = createCollisionContactManifold2D();
+    const lean = createCollisionManifold2D();
+    const a: CollisionAabb2D = { minX: 0, minY: 0, maxX: 10, maxY: 10 };
+    const b: CollisionAabb2D = { minX: 2, minY: 8, maxX: 8, maxY: 20 };
     expect(collideAabbAabbContactManifold(a, b, contact)).toBe(true);
     expect(testAabbAabbCollision(a, b, lean)).toBe(true);
     expect(contact.normalX).toBeCloseTo(lean.normalX);
@@ -93,9 +93,9 @@ describe('collideAabbAabbContactManifold', () => {
     // (same xs) and the pair-level answer (normal negated, depth equal) while moving the points one
     // penetration depth down, onto the other body's face. Both are correct contacts; which one you get
     // is the caller's argument order, and this pins that rather than averting its eyes from it.
-    const forward = createCollisionContactManifold();
-    const reversed = createCollisionContactManifold();
-    const box: CollisionAabb = { minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 };
+    const forward = createCollisionContactManifold2D();
+    const reversed = createCollisionContactManifold2D();
+    const box: CollisionAabb2D = { minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 };
     expect(collideAabbAabbContactManifold(box, ground, forward)).toBe(true);
     expect(collideAabbAabbContactManifold(ground, box, reversed)).toBe(true);
 
@@ -116,7 +116,7 @@ describe('collideAabbAabbContactManifold', () => {
   });
 
   it('clears the manifold on a miss, so no stale point is left readable', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(collideAabbAabbContactManifold({ minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 }, ground, out)).toBe(true);
     expect(out.pointCount).toBe(2);
 
@@ -127,7 +127,7 @@ describe('collideAabbAabbContactManifold', () => {
   });
 
   it('treats exactly touching boxes as not overlapping, matching the lean test', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(collideAabbAabbContactManifold({ minX: 0, minY: 0, maxX: 2, maxY: 2 }, ground, out)).toBe(false);
     expect(out.pointCount).toBe(0);
   });
@@ -135,9 +135,9 @@ describe('collideAabbAabbContactManifold', () => {
 
 describe('collideAabbObbContactManifold', () => {
   it('resolves a flat-lying oriented box under a box to a two-point face contact', () => {
-    const out = createCollisionContactManifold();
-    const box: CollisionAabb = { minX: -1, minY: -0.1, maxX: 1, maxY: 2 };
-    const platform: CollisionObb = { x: 0, y: -1, halfW: 3, halfH: 1, rotation: 0 };
+    const out = createCollisionContactManifold2D();
+    const box: CollisionAabb2D = { minX: -1, minY: -0.1, maxX: 1, maxY: 2 };
+    const platform: CollisionObb2D = { x: 0, y: -1, halfW: 3, halfH: 1, rotation: 0 };
     expect(collideAabbObbContactManifold(box, platform, out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -148,11 +148,11 @@ describe('collideAabbObbContactManifold', () => {
   });
 
   it('resolves a corner-first oriented box to a single deepest point', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     const half = Math.SQRT2 / 2;
     // A unit-ish diamond whose lowest corner just dips under the box's top face.
-    const diamond: CollisionObb = { x: 0, y: 1 + half - 0.05, halfW: 0.5, halfH: 0.5, rotation: Math.PI / 4 };
-    const box: CollisionAabb = { minX: -3, minY: -1, maxX: 3, maxY: 1 };
+    const diamond: CollisionObb2D = { x: 0, y: 1 + half - 0.05, halfW: 0.5, halfH: 0.5, rotation: Math.PI / 4 };
+    const box: CollisionAabb2D = { minX: -3, minY: -1, maxX: 3, maxY: 1 };
     expect(collideAabbObbContactManifold(box, diamond, out)).toBe(true);
     expect(out.pointCount).toBe(1);
     expect(out.points[0].x).toBeCloseTo(0);
@@ -161,7 +161,7 @@ describe('collideAabbObbContactManifold', () => {
   });
 
   it('is separated when the boxes are disjoint', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(
       collideAabbObbContactManifold(
         { minX: 0, minY: 0, maxX: 1, maxY: 1 },
@@ -175,11 +175,11 @@ describe('collideAabbObbContactManifold', () => {
 
 describe('collideAabbPolygonContactManifold', () => {
   it('matches the all-polygon result for the same geometry', () => {
-    const viaAabb = createCollisionContactManifold();
-    const viaPolygon = createCollisionContactManifold();
-    const box: CollisionAabb = { minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 };
+    const viaAabb = createCollisionContactManifold2D();
+    const viaPolygon = createCollisionContactManifold2D();
+    const box: CollisionAabb2D = { minX: 0, minY: -0.1, maxX: 2, maxY: 1.9 };
     // The ground slab restated as a polygon, so both routes see identical geometry.
-    const slab: CollisionPolygon = { points: [-5, -1, 5, -1, 5, 0, -5, 0] };
+    const slab: CollisionPolygon2D = { points: [-5, -1, 5, -1, 5, 0, -5, 0] };
     expect(collideAabbPolygonContactManifold(box, slab, viaAabb)).toBe(true);
     expect(collidePolygonPolygonContactManifold(square(0, -0.1, 2), slab, viaPolygon)).toBe(true);
 
@@ -190,8 +190,8 @@ describe('collideAabbPolygonContactManifold', () => {
   });
 
   it('reports a clean miss rather than NaN for a degenerate polygon', () => {
-    const out = createCollisionContactManifold();
-    const degenerate: CollisionPolygon = { points: [0, 0, 1, 1] };
+    const out = createCollisionContactManifold2D();
+    const degenerate: CollisionPolygon2D = { points: [0, 0, 1, 1] };
     expect(collideAabbPolygonContactManifold({ minX: -1, minY: -1, maxX: 2, maxY: 2 }, degenerate, out)).toBe(false);
     expect(out.overlapping).toBe(false);
     expect(out.pointCount).toBe(0);
@@ -202,8 +202,8 @@ describe('collideAabbPolygonContactManifold', () => {
 
 describe('collideCircleAabbContactManifold', () => {
   it('places the single point on the circle surface at its deepest penetration', () => {
-    const out = createCollisionContactManifold();
-    const circle: CollisionCircle = { x: 0, y: 0.9, radius: 1 };
+    const out = createCollisionContactManifold2D();
+    const circle: CollisionCircle2D = { x: 0, y: 0.9, radius: 1 };
     expect(collideCircleAabbContactManifold(circle, ground, out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -214,7 +214,7 @@ describe('collideCircleAabbContactManifold', () => {
   });
 
   it('is separated when the circle clears the box', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(collideCircleAabbContactManifold({ x: 0, y: 4, radius: 1 }, ground, out)).toBe(false);
     expect(out.pointCount).toBe(0);
   });
@@ -224,7 +224,7 @@ describe('collideCircleCircleContactManifold', () => {
   it('keeps the lean manifold isolated from a nested contact triggered after the lean test', () => {
     let xReads = 0;
     let nestedCalls = 0;
-    const a: CollisionCircle = {
+    const a: CollisionCircle2D = {
       get x() {
         xReads++;
         if (xReads === 3) {
@@ -232,7 +232,7 @@ describe('collideCircleCircleContactManifold', () => {
           collideCircleCircleContactManifold(
             { x: 0, y: 0, radius: 1 },
             { x: 0.5, y: 0, radius: 1 },
-            createCollisionContactManifold(),
+            createCollisionContactManifold2D(),
           );
         }
         return 0;
@@ -240,7 +240,7 @@ describe('collideCircleCircleContactManifold', () => {
       y: 0,
       radius: 1,
     };
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
 
     expect(collideCircleCircleContactManifold(a, { x: 1.5, y: 0, radius: 1 }, out)).toBe(true);
     expect(nestedCalls).toBe(1);
@@ -250,9 +250,9 @@ describe('collideCircleCircleContactManifold', () => {
   });
 
   it('places the point on A surface along the contact normal', () => {
-    const out = createCollisionContactManifold();
-    const a: CollisionCircle = { x: 0, y: 0, radius: 1 };
-    const b: CollisionCircle = { x: 1.5, y: 0, radius: 1 };
+    const out = createCollisionContactManifold2D();
+    const a: CollisionCircle2D = { x: 0, y: 0, radius: 1 };
+    const b: CollisionCircle2D = { x: 1.5, y: 0, radius: 1 };
     expect(collideCircleCircleContactManifold(a, b, out)).toBe(true);
     expect(out.normalX).toBeCloseTo(-1);
     expect(out.depth).toBeCloseTo(0.5);
@@ -263,10 +263,10 @@ describe('collideCircleCircleContactManifold', () => {
   });
 
   it('agrees with the lean overlap test on normal and depth', () => {
-    const contact = createCollisionContactManifold();
-    const lean = createCollisionManifold();
-    const a: CollisionCircle = { x: 1, y: 2, radius: 3 };
-    const b: CollisionCircle = { x: 4, y: 6, radius: 4 };
+    const contact = createCollisionContactManifold2D();
+    const lean = createCollisionManifold2D();
+    const a: CollisionCircle2D = { x: 1, y: 2, radius: 3 };
+    const b: CollisionCircle2D = { x: 4, y: 6, radius: 4 };
     expect(collideCircleCircleContactManifold(a, b, contact)).toBe(true);
     expect(testCircleCircleCollision(a, b, lean)).toBe(true);
     expect(contact.normalX).toBeCloseTo(lean.normalX);
@@ -275,7 +275,7 @@ describe('collideCircleCircleContactManifold', () => {
   });
 
   it('clears a previously populated manifold on a miss', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(collideCircleCircleContactManifold({ x: 0, y: 0, radius: 1 }, { x: 1.5, y: 0, radius: 1 }, out)).toBe(true);
     expect(collideCircleCircleContactManifold({ x: 0, y: 0, radius: 1 }, { x: 9, y: 0, radius: 1 }, out)).toBe(false);
     expect(out.pointCount).toBe(0);
@@ -285,10 +285,10 @@ describe('collideCircleCircleContactManifold', () => {
 
 describe('collideCircleObbContactManifold', () => {
   it('places the point on the circle surface in the rotated box frame', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     // The box is rotated a quarter turn, so its half-extents swap: it spans y[-1,1] about the origin.
-    const box: CollisionObb = { x: 0, y: 0, halfW: 1, halfH: 4, rotation: Math.PI / 2 };
-    const circle: CollisionCircle = { x: 0, y: 1.9, radius: 1 };
+    const box: CollisionObb2D = { x: 0, y: 0, halfW: 1, halfH: 4, rotation: Math.PI / 2 };
+    const circle: CollisionCircle2D = { x: 0, y: 1.9, radius: 1 };
     expect(collideCircleObbContactManifold(circle, box, out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -297,7 +297,7 @@ describe('collideCircleObbContactManifold', () => {
   });
 
   it('is separated when the circle clears the rotated box', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(
       collideCircleObbContactManifold(
         { x: 0, y: 20, radius: 1 },
@@ -311,8 +311,8 @@ describe('collideCircleObbContactManifold', () => {
 
 describe('collideCirclePolygonContactManifold', () => {
   it('places the point on the circle surface below the polygon face', () => {
-    const out = createCollisionContactManifold();
-    const circle: CollisionCircle = { x: 2.5, y: 5.9, radius: 1 };
+    const out = createCollisionContactManifold2D();
+    const circle: CollisionCircle2D = { x: 2.5, y: 5.9, radius: 1 };
     expect(collideCirclePolygonContactManifold(circle, square(0, 0, 5), out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -322,9 +322,9 @@ describe('collideCirclePolygonContactManifold', () => {
   });
 
   it('resolves a corner contact to one point without reporting a face', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     // Sitting diagonally off the square's top-right corner, just inside the radius.
-    const circle: CollisionCircle = { x: 5.6, y: 5.6, radius: 1 };
+    const circle: CollisionCircle2D = { x: 5.6, y: 5.6, radius: 1 };
     expect(collideCirclePolygonContactManifold(circle, square(0, 0, 5), out)).toBe(true);
     expect(out.pointCount).toBe(1);
     expect(out.normalX).toBeCloseTo(Math.SQRT1_2);
@@ -334,9 +334,9 @@ describe('collideCirclePolygonContactManifold', () => {
 
 describe('collideObbObbContactManifold', () => {
   it('resolves two aligned oriented boxes to a two-point face contact', () => {
-    const out = createCollisionContactManifold();
-    const upper: CollisionObb = { x: 0, y: 0.9, halfW: 1, halfH: 1, rotation: 0 };
-    const lower: CollisionObb = { x: 0, y: -1, halfW: 1, halfH: 1, rotation: 0 };
+    const out = createCollisionContactManifold2D();
+    const upper: CollisionObb2D = { x: 0, y: 0.9, halfW: 1, halfH: 1, rotation: 0 };
+    const lower: CollisionObb2D = { x: 0, y: -1, halfW: 1, halfH: 1, rotation: 0 };
     expect(collideObbObbContactManifold(upper, lower, out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -349,10 +349,10 @@ describe('collideObbObbContactManifold', () => {
   });
 
   it('agrees with the lean overlap test on normal and depth for a rotated pair', () => {
-    const contact = createCollisionContactManifold();
-    const lean = createCollisionManifold();
-    const a: CollisionObb = { x: 0, y: 0, halfW: 2, halfH: 1, rotation: 0.4 };
-    const b: CollisionObb = { x: 2.5, y: 0.5, halfW: 1, halfH: 1.5, rotation: -0.2 };
+    const contact = createCollisionContactManifold2D();
+    const lean = createCollisionManifold2D();
+    const a: CollisionObb2D = { x: 0, y: 0, halfW: 2, halfH: 1, rotation: 0.4 };
+    const b: CollisionObb2D = { x: 2.5, y: 0.5, halfW: 1, halfH: 1.5, rotation: -0.2 };
     expect(collideObbObbContactManifold(a, b, contact)).toBe(true);
     expect(testObbObbCollision(a, b, lean)).toBe(true);
     expect(contact.normalX).toBeCloseTo(lean.normalX);
@@ -361,9 +361,9 @@ describe('collideObbObbContactManifold', () => {
   });
 
   it('keeps every contact point at or behind the contact plane', () => {
-    const out = createCollisionContactManifold();
-    const a: CollisionObb = { x: 0, y: 0, halfW: 2, halfH: 1, rotation: 0.4 };
-    const b: CollisionObb = { x: 2.5, y: 0.5, halfW: 1, halfH: 1.5, rotation: -0.2 };
+    const out = createCollisionContactManifold2D();
+    const a: CollisionObb2D = { x: 0, y: 0, halfW: 2, halfH: 1, rotation: 0.4 };
+    const b: CollisionObb2D = { x: 2.5, y: 0.5, halfW: 1, halfH: 1.5, rotation: -0.2 };
     expect(collideObbObbContactManifold(a, b, out)).toBe(true);
     expect(out.pointCount).toBeGreaterThan(0);
     for (const point of livePoints(out)) {
@@ -375,8 +375,8 @@ describe('collideObbObbContactManifold', () => {
 
 describe('collideObbPolygonContactManifold', () => {
   it('resolves an oriented box resting on a polygon slab to two points', () => {
-    const out = createCollisionContactManifold();
-    const box: CollisionObb = { x: 2.5, y: 5.9, halfW: 1, halfH: 1, rotation: 0 };
+    const out = createCollisionContactManifold2D();
+    const box: CollisionObb2D = { x: 2.5, y: 5.9, halfW: 1, halfH: 1, rotation: 0 };
     expect(collideObbPolygonContactManifold(box, square(0, 0, 5), out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -384,7 +384,7 @@ describe('collideObbPolygonContactManifold', () => {
   });
 
   it('is separated when the box clears the polygon', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(
       collideObbPolygonContactManifold({ x: 50, y: 50, halfW: 1, halfH: 1, rotation: 0 }, square(0, 0, 5), out),
     ).toBe(false);
@@ -394,7 +394,7 @@ describe('collideObbPolygonContactManifold', () => {
 
 describe('collidePolygonPolygonContactManifold', () => {
   it('resolves a square resting on a slab to two points spanning the overlap', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(collidePolygonPolygonContactManifold(square(0, 4.9, 2), square(0, 0, 5), out)).toBe(true);
     expect(out.normalY).toBeCloseTo(1);
     expect(out.depth).toBeCloseTo(0.1);
@@ -407,8 +407,8 @@ describe('collidePolygonPolygonContactManifold', () => {
   });
 
   it('agrees with the lean overlap test on normal and depth', () => {
-    const contact = createCollisionContactManifold();
-    const lean = createCollisionManifold();
+    const contact = createCollisionContactManifold2D();
+    const lean = createCollisionManifold2D();
     const a = square(0, 4.9, 2);
     const b = square(0, 0, 5);
     expect(collidePolygonPolygonContactManifold(a, b, contact)).toBe(true);
@@ -419,8 +419,8 @@ describe('collidePolygonPolygonContactManifold', () => {
   });
 
   it('resolves a triangle tip pressed into a face to a single point', () => {
-    const out = createCollisionContactManifold();
-    const triangle: CollisionPolygon = { points: [2, 4.9, 3, 7, 1, 7] };
+    const out = createCollisionContactManifold2D();
+    const triangle: CollisionPolygon2D = { points: [2, 4.9, 3, 7, 1, 7] };
     expect(collidePolygonPolygonContactManifold(triangle, square(0, 0, 5), out)).toBe(true);
     expect(out.pointCount).toBe(1);
     expect(out.points[0].x).toBeCloseTo(2);
@@ -429,10 +429,10 @@ describe('collidePolygonPolygonContactManifold', () => {
   });
 
   it('resolves the same contact whichever winding the polygons are given in', () => {
-    const counterClockwise = createCollisionContactManifold();
-    const clockwise = createCollisionContactManifold();
+    const counterClockwise = createCollisionContactManifold2D();
+    const clockwise = createCollisionContactManifold2D();
     const slab = square(0, 0, 5);
-    const reversedSlab: CollisionPolygon = { points: [0, 0, 0, 5, 5, 5, 5, 0] };
+    const reversedSlab: CollisionPolygon2D = { points: [0, 0, 0, 5, 5, 5, 5, 0] };
     expect(collidePolygonPolygonContactManifold(square(0, 4.9, 2), slab, counterClockwise)).toBe(true);
     expect(collidePolygonPolygonContactManifold(square(0, 4.9, 2), reversedSlab, clockwise)).toBe(true);
 
@@ -442,7 +442,7 @@ describe('collidePolygonPolygonContactManifold', () => {
   });
 
   it('reports a clean miss rather than NaN for a polygon with too few vertices', () => {
-    const out = createCollisionContactManifold();
+    const out = createCollisionContactManifold2D();
     expect(collidePolygonPolygonContactManifold({ points: [0, 0] }, square(0, 0, 5), out)).toBe(false);
     expect(out.pointCount).toBe(0);
     expect(Number.isNaN(out.depth)).toBe(false);

package/src/{sweepCollisionShape.test.ts → sweepCollisionShape2D.test.ts}

@@ -1,16 +1,16 @@
 import { describe, expect, it } from 'vitest';
 
-import { createCollisionTimeOfImpact, sweepCollisionShape } from './sweepCollisionShape';
+import { createCollisionTimeOfImpact2D, sweepCollisionShape2D } from './sweepCollisionShape2D';
 
-describe('createCollisionTimeOfImpact', () => {
+describe('createCollisionTimeOfImpact2D', () => {
   it('creates a cleared reusable output record', () => {
-    expect(createCollisionTimeOfImpact()).toEqual({ fraction: 0, x: 0, y: 0, normalX: 0, normalY: 0 });
+    expect(createCollisionTimeOfImpact2D()).toEqual({ fraction: 0, x: 0, y: 0, normalX: 0, normalY: 0 });
   });
 });
 
-describe('sweepCollisionShape', () => {
+describe('sweepCollisionShape2D', () => {
   it('keeps continuous-SAT state isolated from a nested sweep triggered by the output setter', () => {
-    const out = createCollisionTimeOfImpact();
+    const out = createCollisionTimeOfImpact2D();
     let fraction = 0;
     let fractionWrites = 0;
     let nestedCalls = 0;
@@ -23,20 +23,20 @@ describe('sweepCollisionShape', () => {
         fractionWrites++;
         if (fractionWrites !== 2) return;
         nestedCalls++;
-        sweepCollisionShape(
+        sweepCollisionShape2D(
           { kind: 'aabb', minX: -1, minY: 0, maxX: 1, maxY: 2 },
           0,
           10,
           { kind: 'aabb', minX: -1, minY: 5, maxX: 1, maxY: 7 },
           0,
           0,
-          createCollisionTimeOfImpact(),
+          createCollisionTimeOfImpact2D(),
         );
       },
     });
 
     expect(
-      sweepCollisionShape(
+      sweepCollisionShape2D(
         { kind: 'obb', x: 0, y: 0, halfW: 1, halfH: 1, rotation: 0 },
         10,
         0,
@@ -53,9 +53,9 @@ describe('sweepCollisionShape', () => {
   });
 
   it('finds the exact circle-circle root under relative motion', () => {
-    const out = createCollisionTimeOfImpact();
+    const out = createCollisionTimeOfImpact2D();
     expect(
-      sweepCollisionShape(
+      sweepCollisionShape2D(
         { kind: 'circle', x: 0, y: 0, radius: 1 },
         10,
         0,
@@ -72,22 +72,22 @@ describe('sweepCollisionShape', () => {
 
   it('sweeps a circle exactly against polygon faces and rounded corners', () => {
     const box = { kind: 'aabb', minX: 5, minY: 5, maxX: 7, maxY: 7 } as const;
-    const face = createCollisionTimeOfImpact();
-    expect(sweepCollisionShape({ kind: 'circle', x: 0, y: 6, radius: 1 }, 10, 0, box, 0, 0, face)).toBe(true);
+    const face = createCollisionTimeOfImpact2D();
+    expect(sweepCollisionShape2D({ kind: 'circle', x: 0, y: 6, radius: 1 }, 10, 0, box, 0, 0, face)).toBe(true);
     expect(face.fraction).toBeCloseTo(0.4);
     expect([face.normalX, face.normalY]).toEqual([-1, 0]);
 
-    const corner = createCollisionTimeOfImpact();
-    expect(sweepCollisionShape({ kind: 'circle', x: 0, y: 0, radius: 1 }, 10, 10, box, 0, 0, corner)).toBe(true);
+    const corner = createCollisionTimeOfImpact2D();
+    expect(sweepCollisionShape2D({ kind: 'circle', x: 0, y: 0, radius: 1 }, 10, 10, box, 0, 0, corner)).toBe(true);
     expect(corner.fraction).toBeCloseTo((5 - Math.SQRT1_2) / 10);
     expect(corner.normalX).toBeCloseTo(-Math.SQRT1_2);
     expect(corner.normalY).toBeCloseTo(-Math.SQRT1_2);
   });
 
   it('reverses the normal when the polygon is shape A and still writes a point on A', () => {
-    const out = createCollisionTimeOfImpact();
+    const out = createCollisionTimeOfImpact2D();
     expect(
-      sweepCollisionShape(
+      sweepCollisionShape2D(
         { kind: 'aabb', minX: 5, minY: -1, maxX: 7, maxY: 1 },
         0,
         0,
@@ -105,20 +105,20 @@ describe('sweepCollisionShape', () => {
   it('uses continuous SAT for polygon pairs and honours maxFraction', () => {
     const moving = { kind: 'obb', x: 0, y: 0, halfW: 1, halfH: 1, rotation: 0 } as const;
     const fixed = { kind: 'aabb', minX: 5, minY: -1, maxX: 7, maxY: 1 } as const;
-    const out = createCollisionTimeOfImpact();
+    const out = createCollisionTimeOfImpact2D();
 
-    expect(sweepCollisionShape(moving, 10, 0, fixed, 0, 0, out, 0.3)).toBe(false);
+    expect(sweepCollisionShape2D(moving, 10, 0, fixed, 0, 0, out, 0.3)).toBe(false);
     expect(out).toEqual({ fraction: 0, x: 0, y: 0, normalX: 0, normalY: 0 });
-    expect(sweepCollisionShape(moving, 10, 0, fixed, 0, 0, out)).toBe(true);
+    expect(sweepCollisionShape2D(moving, 10, 0, fixed, 0, 0, out)).toBe(true);
     expect(out.fraction).toBeCloseTo(0.4);
     expect(out.normalX).toBe(-1);
     expect(out.x).toBeCloseTo(5);
   });
 
   it('reports an initial overlap at zero and ignores a touching pair moving apart', () => {
-    const out = createCollisionTimeOfImpact();
+    const out = createCollisionTimeOfImpact2D();
     expect(
-      sweepCollisionShape(
+      sweepCollisionShape2D(
         { kind: 'circle', x: 0, y: 0, radius: 1 },
         1,
         0,
@@ -132,7 +132,7 @@ describe('sweepCollisionShape', () => {
     expect(out.normalX).toBe(-1);
 
     expect(
-      sweepCollisionShape(
+      sweepCollisionShape2D(
         { kind: 'circle', x: 0, y: 0, radius: 1 },
         -1,
         0,
@@ -145,8 +145,8 @@ describe('sweepCollisionShape', () => {
   });
 
   it('fails closed and clears reused output for unsupported or invalid input', () => {
-    const out = createCollisionTimeOfImpact();
-    sweepCollisionShape(
+    const out = createCollisionTimeOfImpact2D();
+    sweepCollisionShape2D(
       { kind: 'circle', x: 0, y: 0, radius: 1 },
       10,
       0,
@@ -156,11 +156,11 @@ describe('sweepCollisionShape', () => {
       out,
     );
     expect(
-      sweepCollisionShape({ kind: 'point', x: 0, y: 0 }, 1, 0, { kind: 'circle', x: 2, y: 0, radius: 1 }, 0, 0, out),
+      sweepCollisionShape2D({ kind: 'point', x: 0, y: 0 }, 1, 0, { kind: 'circle', x: 2, y: 0, radius: 1 }, 0, 0, out),
     ).toBe(false);
     expect(out).toEqual({ fraction: 0, x: 0, y: 0, normalX: 0, normalY: 0 });
     expect(
-      sweepCollisionShape(
+      sweepCollisionShape2D(
         { kind: 'circle', x: 0, y: 0, radius: 1 },
         Number.NaN,
         0,