@flighthq/geometry 0.1.0

package/src/capsule.test.ts

@@ -0,0 +1,157 @@
+import {
+  createBoundingSphere,
+  createCapsule,
+  createRay3D,
+  createVector3,
+  getClosestPointOnCapsule,
+  intersectRay3DCapsule,
+  isCapsuleIntersectingCapsule,
+  isCapsuleIntersectingSphere,
+  setCapsule,
+} from '@flighthq/geometry';
+
+describe('createCapsule', () => {
+  it('stores all fields', () => {
+    const c = createCapsule(1, 2, 3, 4, 5, 6, 0.5);
+    expect(c.startX).toBe(1);
+    expect(c.startY).toBe(2);
+    expect(c.startZ).toBe(3);
+    expect(c.endX).toBe(4);
+    expect(c.endY).toBe(5);
+    expect(c.endZ).toBe(6);
+    expect(c.radius).toBe(0.5);
+  });
+});
+
+describe('getClosestPointOnCapsule', () => {
+  it('returns the nearest surface point for a point off the side', () => {
+    // Vertical capsule along Y axis from (0,-1,0) to (0,1,0) with radius 1.
+    const c = createCapsule(0, -1, 0, 0, 1, 0, 1);
+    const out = createVector3();
+    // Point at (5, 0, 0): closest axis point is (0,0,0), surface is (1,0,0).
+    getClosestPointOnCapsule(out, c, createVector3(5, 0, 0));
+    expect(out.x).toBeCloseTo(1, 5);
+    expect(out.y).toBeCloseTo(0, 5);
+    expect(out.z).toBeCloseTo(0, 5);
+  });
+
+  it('returns the start cap surface for a point beyond the start', () => {
+    const c = createCapsule(0, 0, 0, 0, 2, 0, 1);
+    const out = createVector3();
+    // Point at (0,-5,0): closest axis point is (0,0,0) (clamped start), surface is (0,-1,0).
+    getClosestPointOnCapsule(out, c, createVector3(0, -5, 0));
+    expect(out.x).toBeCloseTo(0, 5);
+    expect(out.y).toBeCloseTo(-1, 5);
+    expect(out.z).toBeCloseTo(0, 5);
+  });
+
+  it('returns the end cap surface for a point beyond the end', () => {
+    const c = createCapsule(0, 0, 0, 0, 2, 0, 1);
+    const out = createVector3();
+    // Point at (0,10,0): closest axis point is (0,2,0) (clamped end), surface is (0,3,0).
+    getClosestPointOnCapsule(out, c, createVector3(0, 10, 0));
+    expect(out.x).toBeCloseTo(0, 5);
+    expect(out.y).toBeCloseTo(3, 5);
+    expect(out.z).toBeCloseTo(0, 5);
+  });
+
+  it('supports out === point', () => {
+    const c = createCapsule(0, 0, 0, 0, 0, 0, 1);
+    const p = createVector3(5, 0, 0);
+    getClosestPointOnCapsule(p, c, p);
+    expect(p.x).toBeCloseTo(1, 5);
+    expect(p.y).toBeCloseTo(0, 5);
+  });
+});
+
+describe('intersectRay3DCapsule', () => {
+  it('hits a unit capsule from the side', () => {
+    // Capsule from (0,-1,0) to (0,1,0) with radius 1.
+    const c = createCapsule(0, -1, 0, 0, 1, 0, 1);
+    // Ray from (5,0,0) pointing in -X: should enter at x=1, t=4.
+    const ray = createRay3D(5, 0, 0, -1, 0, 0);
+    const t = intersectRay3DCapsule(ray, c);
+    expect(t).toBeCloseTo(4, 5);
+  });
+
+  it('returns -1 for a ray pointing away from the capsule', () => {
+    const c = createCapsule(0, -1, 0, 0, 1, 0, 1);
+    const ray = createRay3D(5, 0, 0, 1, 0, 0);
+    expect(intersectRay3DCapsule(ray, c)).toBe(-1);
+  });
+
+  it('returns 0 for a ray starting inside the capsule', () => {
+    const c = createCapsule(0, -1, 0, 0, 1, 0, 1);
+    const ray = createRay3D(0, 0, 0, 1, 0, 0);
+    expect(intersectRay3DCapsule(ray, c)).toBe(0);
+  });
+
+  it('hits the end cap from above', () => {
+    // Capsule from (0,0,0) to (0,0,0) (degenerate sphere) with radius 1, hit from +Y.
+    const c = createCapsule(0, 0, 0, 0, 0, 0, 1);
+    const ray = createRay3D(0, 5, 0, 0, -1, 0);
+    const t = intersectRay3DCapsule(ray, c);
+    expect(t).toBeCloseTo(4, 5);
+  });
+});
+
+describe('isCapsuleIntersectingCapsule', () => {
+  it('returns true for two overlapping capsules', () => {
+    const a = createCapsule(0, 0, 0, 0, 2, 0, 1);
+    const b = createCapsule(1, 0, 0, 1, 2, 0, 1);
+    expect(isCapsuleIntersectingCapsule(a, b)).toBe(true);
+  });
+
+  it('returns false for two separated capsules', () => {
+    const a = createCapsule(0, 0, 0, 0, 2, 0, 0.5);
+    const b = createCapsule(10, 0, 0, 10, 2, 0, 0.5);
+    expect(isCapsuleIntersectingCapsule(a, b)).toBe(false);
+  });
+
+  it('returns false if either capsule has a negative radius', () => {
+    const a = createCapsule(0, 0, 0, 0, 2, 0, 1);
+    const empty = createCapsule(0, 0, 0, 0, 2, 0, -1);
+    expect(isCapsuleIntersectingCapsule(a, empty)).toBe(false);
+    expect(isCapsuleIntersectingCapsule(empty, a)).toBe(false);
+  });
+});
+
+describe('isCapsuleIntersectingSphere', () => {
+  it('returns true when the sphere overlaps the capsule', () => {
+    const c = createCapsule(0, -2, 0, 0, 2, 0, 1);
+    const s = createBoundingSphere(2, 0, 0, 1);
+    expect(isCapsuleIntersectingSphere(c, s)).toBe(true);
+  });
+
+  it('returns false when the sphere is separated from the capsule', () => {
+    const c = createCapsule(0, -2, 0, 0, 2, 0, 1);
+    const s = createBoundingSphere(10, 0, 0, 1);
+    expect(isCapsuleIntersectingSphere(c, s)).toBe(false);
+  });
+
+  it('returns false if the sphere radius is negative', () => {
+    const c = createCapsule(0, -2, 0, 0, 2, 0, 1);
+    const empty = createBoundingSphere(0, 0, 0, -1);
+    expect(isCapsuleIntersectingSphere(c, empty)).toBe(false);
+  });
+
+  it('returns false if the capsule radius is negative', () => {
+    const c = createCapsule(0, -2, 0, 0, 2, 0, -1);
+    const s = createBoundingSphere(0, 0, 0, 1);
+    expect(isCapsuleIntersectingSphere(c, s)).toBe(false);
+  });
+});
+
+describe('setCapsule', () => {
+  it('updates all fields in place', () => {
+    const c = createCapsule(0, 0, 0, 0, 0, 0, 0);
+    setCapsule(c, 1, 2, 3, 4, 5, 6, 7);
+    expect(c.startX).toBe(1);
+    expect(c.startY).toBe(2);
+    expect(c.startZ).toBe(3);
+    expect(c.endX).toBe(4);
+    expect(c.endY).toBe(5);
+    expect(c.endZ).toBe(6);
+    expect(c.radius).toBe(7);
+  });
+});

package/src/frustum.test.ts

@@ -0,0 +1,160 @@
+import {
+  createAabb,
+  createBoundingSphere,
+  createFrustum,
+  createMatrix4,
+  createPerspectiveMatrix4,
+  createVector3,
+  getFrustumCorners,
+  inverseMatrix4,
+  isFrustumContainingPoint,
+  isFrustumIntersectingAabb,
+  isFrustumIntersectingSphere,
+  multiplyMatrix4,
+  setFrustumFromMatrix4,
+  setMatrix4LookAt,
+} from '@flighthq/geometry';
+import type { Matrix4 } from '@flighthq/types';
+
+// View-projection for a camera at (0,0,5) looking toward the origin down -z.
+function createTestViewProjection(): Matrix4 {
+  const projection = createPerspectiveMatrix4(0.5, 1, 0.1, 100);
+  const view = createMatrix4();
+  setMatrix4LookAt(view, createVector3(0, 0, 5), createVector3(0, 0, 0), createVector3(0, 1, 0));
+  const vp = createMatrix4();
+  multiplyMatrix4(vp, projection, view);
+  return vp;
+}
+
+describe('createFrustum', () => {
+  it('creates six independent planes', () => {
+    const f = createFrustum();
+    expect(f.left).not.toBe(f.right);
+    expect(f.near).not.toBe(f.far);
+    expect(f.top.a).toBe(0);
+  });
+});
+
+describe('getFrustumCorners', () => {
+  it('writes 8 corners for a perspective frustum', () => {
+    const vp = createTestViewProjection();
+    const inv = createMatrix4();
+    inverseMatrix4(inv, vp);
+    const corners = Array.from({ length: 8 }, () => createVector3());
+    getFrustumCorners(corners, inv);
+    // All 8 corners should be finite and distinct
+    const seen = new Set<string>();
+    for (const c of corners) {
+      expect(isFinite(c.x)).toBe(true);
+      expect(isFinite(c.y)).toBe(true);
+      expect(isFinite(c.z)).toBe(true);
+      seen.add(`${c.x.toFixed(4)},${c.y.toFixed(4)},${c.z.toFixed(4)}`);
+    }
+    expect(seen.size).toBe(8);
+  });
+
+  it('near corners are closer to the camera than far corners', () => {
+    const vp = createTestViewProjection();
+    const inv = createMatrix4();
+    inverseMatrix4(inv, vp);
+    const corners = Array.from({ length: 8 }, () => createVector3());
+    getFrustumCorners(corners, inv);
+    // Camera at (0,0,5) looking toward origin along -z; near z > far z
+    const nearZ = corners.slice(0, 4).map((c) => c.z);
+    const farZ = corners.slice(4, 8).map((c) => c.z);
+    for (const nz of nearZ) {
+      for (const fz of farZ) {
+        expect(nz).toBeGreaterThan(fz);
+      }
+    }
+  });
+
+  it('writes only as many corners as out.length', () => {
+    const vp = createTestViewProjection();
+    const inv = createMatrix4();
+    inverseMatrix4(inv, vp);
+    const corners = [createVector3(), createVector3()];
+    getFrustumCorners(corners, inv);
+    // Only first 2 corners written; rest untouched (default to 0,0,0)
+    expect(isFinite(corners[0].x)).toBe(true);
+    expect(isFinite(corners[1].x)).toBe(true);
+  });
+});
+
+describe('isFrustumContainingPoint', () => {
+  it('contains a point in front of the camera', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumContainingPoint(f, createVector3(0, 0, 0))).toBe(true);
+  });
+
+  it('rejects a point behind the camera', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumContainingPoint(f, createVector3(0, 0, 20))).toBe(false);
+  });
+
+  it('rejects a point far off to the side', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumContainingPoint(f, createVector3(100, 0, 0))).toBe(false);
+  });
+});
+
+describe('isFrustumIntersectingAabb', () => {
+  it('accepts a box straddling the origin', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumIntersectingAabb(f, createAabb(-1, -1, -1, 1, 1, 1))).toBe(true);
+  });
+
+  it('rejects a box entirely behind the camera', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumIntersectingAabb(f, createAabb(-1, -1, 10, 1, 1, 12))).toBe(false);
+  });
+
+  it('rejects a box far off to the side', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumIntersectingAabb(f, createAabb(50, 50, -1, 60, 60, 1))).toBe(false);
+  });
+});
+
+describe('isFrustumIntersectingSphere', () => {
+  it('accepts a sphere centered in front of the camera', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumIntersectingSphere(f, createBoundingSphere(0, 0, 0, 1))).toBe(true);
+  });
+
+  it('rejects a sphere entirely behind the camera', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumIntersectingSphere(f, createBoundingSphere(0, 0, 20, 1))).toBe(false);
+  });
+
+  it('rejects an empty sphere (negative radius)', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    expect(isFrustumIntersectingSphere(f, createBoundingSphere(0, 0, 0, -1))).toBe(false);
+  });
+
+  it('accepts a sphere that straddles the near plane', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    // Near plane is at z ≈ 4.9 (camera at z=5, near=0.1). A sphere centered just behind the
+    // near plane with a radius that crosses it should still intersect.
+    expect(isFrustumIntersectingSphere(f, createBoundingSphere(0, 0, 5.5, 2))).toBe(true);
+  });
+});
+
+describe('setFrustumFromMatrix4', () => {
+  it('produces unit-length plane normals', () => {
+    const f = createFrustum();
+    setFrustumFromMatrix4(f, createTestViewProjection());
+    const near = f.near;
+    const len = Math.sqrt(near.a * near.a + near.b * near.b + near.c * near.c);
+    expect(len).toBeCloseTo(1, 5);
+  });
+});