@flighthq/geometry 0.3.0 → 0.3.1-next.1041.35b950c

package/src/vector4.test.ts

@@ -90,6 +90,33 @@ describe('addVector4', () => {
 });
 
 describe('clampVector4', () => {
+  it('clamps each component to its own bounds, below, above, and not at all', () => {
+    // Every component gets a DIFFERENT min and max, so a component reading a neighbour's bound
+    // comes out as a wrong number instead of the right one by luck. Each component is then run
+    // through all three outcomes — under its floor, over its ceiling, and already in range.
+    const min = createVector4(-1, -2, -3, -4);
+    const max = createVector4(10, 20, 30, 40);
+    const out = createVector4();
+
+    clampVector4(out, createVector4(-5, -6, -7, -8), min, max);
+    expect(out.x).toBe(-1);
+    expect(out.y).toBe(-2);
+    expect(out.z).toBe(-3);
+    expect(out.w).toBe(-4);
+
+    clampVector4(out, createVector4(100, 200, 300, 400), min, max);
+    expect(out.x).toBe(10);
+    expect(out.y).toBe(20);
+    expect(out.z).toBe(30);
+    expect(out.w).toBe(40);
+
+    clampVector4(out, createVector4(0, 1, 2, 3), min, max);
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(1);
+    expect(out.z).toBe(2);
+    expect(out.w).toBe(3);
+  });
+
   it('clamps each component independently', () => {
     const out = createVector4();
     clampVector4(out, createVector4(5, -2, 1, 10), createVector4(0, 0, 0, 0), createVector4(3, 3, 3, 3));
@@ -98,6 +125,29 @@ describe('clampVector4', () => {
     expect(out.z).toBe(1);
     expect(out.w).toBe(3);
   });
+
+  it('supports out aliasing any input', () => {
+    const value = createVector4(5, -2, 1, 10);
+    clampVector4(value, value, createVector4(0, 0, 0, 0), createVector4(3, 3, 3, 3));
+    expect(value).toMatchObject({ x: 3, y: 0, z: 1, w: 3 });
+
+    const min = createVector4(0, 0, 0, 0);
+    clampVector4(min, createVector4(5, -2, 1, 10), min, createVector4(3, 3, 3, 3));
+    expect(min).toMatchObject({ x: 3, y: 0, z: 1, w: 3 });
+
+    const max = createVector4(3, 3, 3, 3);
+    clampVector4(max, createVector4(5, -2, 1, 10), createVector4(0, 0, 0, 0), max);
+    expect(max).toMatchObject({ x: 3, y: 0, z: 1, w: 3 });
+  });
+
+  it('covers low, middle, and high outcomes on every component', () => {
+    const out = createVector4();
+    clampVector4(out, createVector4(-1, 2, 5, -1), createVector4(0, 0, 0, 0), createVector4(3, 3, 3, 3));
+    expect(out).toMatchObject({ x: 0, y: 2, z: 3, w: 0 });
+
+    clampVector4(out, createVector4(1, 5, -1, 2), createVector4(0, 0, 0, 0), createVector4(3, 3, 3, 3));
+    expect(out).toMatchObject({ x: 1, y: 3, z: 0, w: 2 });
+  });
 });
 
 describe('cloneVector4', () => {
@@ -164,6 +214,37 @@ describe('createVector4', () => {
 });
 
 describe('divideVector4', () => {
+  it('gives 0 for a zero divisor on each component in turn', () => {
+    // A zero divisor is answered per component, not for the whole vector, so each component is
+    // zeroed on its own while the others still divide normally.
+    const source = createVector4(6, 8, 9, 10);
+    const out = createVector4();
+
+    divideVector4(out, source, createVector4(0, 4, 3, 5));
+    expect(out.x).toBe(0);
+    expect(out.y).toBe(2);
+    expect(out.z).toBe(3);
+    expect(out.w).toBe(2);
+
+    divideVector4(out, source, createVector4(2, 0, 3, 5));
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(0);
+    expect(out.z).toBe(3);
+    expect(out.w).toBe(2);
+
+    divideVector4(out, source, createVector4(2, 4, 0, 5));
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(2);
+    expect(out.z).toBe(0);
+    expect(out.w).toBe(2);
+
+    divideVector4(out, source, createVector4(2, 4, 3, 0));
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(2);
+    expect(out.z).toBe(3);
+    expect(out.w).toBe(0);
+  });
+
   it('divides component-wise', () => {
     const out = createVector4();
     divideVector4(out, createVector4(6, 8, 9, 12), createVector4(2, 4, 3, 6));
@@ -173,6 +254,16 @@ describe('divideVector4', () => {
     expect(out.w).toBe(2);
   });
 
+  it('supports out === source or divisor', () => {
+    const source = createVector4(6, 8, 9, 12);
+    divideVector4(source, source, createVector4(2, 4, 3, 6));
+    expect(source).toMatchObject({ x: 3, y: 2, z: 3, w: 2 });
+
+    const divisor = createVector4(2, 4, 3, 6);
+    divideVector4(divisor, createVector4(6, 8, 9, 12), divisor);
+    expect(divisor).toMatchObject({ x: 3, y: 2, z: 3, w: 2 });
+  });
+
   it('produces 0 for zero divisor components', () => {
     const out = createVector4();
     divideVector4(out, createVector4(6, 8, 9, 12), createVector4(0, 4, 0, 6));
@@ -181,9 +272,20 @@ describe('divideVector4', () => {
     expect(out.z).toBe(0);
     expect(out.w).toBe(2);
   });
+
+  it('produces 0 for zero y and w divisors', () => {
+    const out = createVector4();
+    divideVector4(out, createVector4(6, 8, 9, 12), createVector4(2, 0, 3, 0));
+    expect(out).toMatchObject({ x: 3, y: 0, z: 3, w: 0 });
+  });
 });
 
 describe('equalsVector4', () => {
+  it('returns false when either vector is absent', () => {
+    expect(equalsVector4(createVector4(), null)).toBe(false);
+    expect(equalsVector4(undefined, createVector4())).toBe(false);
+  });
+
   it('returns true if vectors are equal', () => {
     const a = createVector4(1, 2, 3, 4);
     const b = createVector4(1, 2, 3, 4);
@@ -195,6 +297,36 @@ describe('equalsVector4', () => {
     const b = createVector4(4, 5, 6, 7);
     expect(equalsVector4(a, b)).toBe(false);
   });
+
+  it('compares every component, not just the first', () => {
+    // Four hand-written comparisons in a row: one left reading the wrong field agrees with the
+    // right answer on every pair that differs in more than one place, so each differs alone here.
+    const a = createVector4(1, 2, 3, 4);
+    expect(equalsVector4(a, createVector4(9, 2, 3, 4))).toBe(false);
+    expect(equalsVector4(a, createVector4(1, 9, 3, 4))).toBe(false);
+    expect(equalsVector4(a, createVector4(1, 2, 9, 4))).toBe(false);
+    expect(equalsVector4(a, createVector4(1, 2, 3, 9))).toBe(false);
+  });
+
+  it('returns false when either side is missing', () => {
+    // The signature accepts null and undefined, so absence is an answerable input rather than
+    // misuse: nothing is equal to a vector, including another absence.
+    const v = createVector4(1, 2, 3, 4);
+    expect(equalsVector4(v, null)).toBe(false);
+    expect(equalsVector4(null, v)).toBe(false);
+    expect(equalsVector4(v, undefined)).toBe(false);
+    expect(equalsVector4(undefined, v)).toBe(false);
+    expect(equalsVector4(null, null)).toBe(false);
+    expect(equalsVector4(undefined, undefined)).toBe(false);
+  });
+
+  it('holds a vector equal to itself even with a NaN component', () => {
+    // Comparing field by field would say a vector carrying NaN differs from itself, and a caller
+    // watching for changes would then see one every time it looked.
+    const notANumber = createVector4(NaN, 2, 3, 4);
+    expect(equalsVector4(notANumber, notANumber)).toBe(true);
+    expect(equalsVector4(notANumber, createVector4(NaN, 2, 3, 4))).toBe(false);
+  });
 });
 
 describe('getVector4AngleBetween', () => {
@@ -300,9 +432,36 @@ describe('interpolateVector4', () => {
     expect(a.z).toBe(3);
     expect(a.w).toBe(4);
   });
+
+  it('supports out === b', () => {
+    const b = createVector4(2, 4, 6, 8);
+    interpolateVector4(b, createVector4(0, 0, 0, 0), b, 0.5);
+    expect(b).toMatchObject({ x: 1, y: 2, z: 3, w: 4 });
+  });
 });
 
 describe('maxVector4', () => {
+  it('takes each component from whichever side wins, and gives the same answer either way round', () => {
+    // The winner alternates between the two arguments component by component, and all 8 numbers
+    // are distinct, so a line reading the wrong component or the wrong side cannot land on the
+    // right answer anyway. Running it again with the arguments swapped must not change it.
+    const a = createVector4(1, 5, 2, 9);
+    const b = createVector4(3, 0, 7, 4);
+    const out = createVector4();
+
+    maxVector4(out, a, b);
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(5);
+    expect(out.z).toBe(7);
+    expect(out.w).toBe(9);
+
+    maxVector4(out, b, a);
+    expect(out.x).toBe(3);
+    expect(out.y).toBe(5);
+    expect(out.z).toBe(7);
+    expect(out.w).toBe(9);
+  });
+
   it('returns the component-wise maximum', () => {
     const out = createVector4();
     maxVector4(out, createVector4(1, 5, 2, 9), createVector4(3, 2, 7, 4));
@@ -311,9 +470,46 @@ describe('maxVector4', () => {
     expect(out.z).toBe(7);
     expect(out.w).toBe(9);
   });
+
+  it('supports out === a or b', () => {
+    const a = createVector4(1, 5, 2, 9);
+    maxVector4(a, a, createVector4(3, 2, 7, 4));
+    expect(a).toMatchObject({ x: 3, y: 5, z: 7, w: 9 });
+
+    const b = createVector4(3, 2, 7, 4);
+    maxVector4(b, createVector4(1, 5, 2, 9), b);
+    expect(b).toMatchObject({ x: 3, y: 5, z: 7, w: 9 });
+  });
+
+  it('selects the complementary component outcomes', () => {
+    const out = createVector4();
+    maxVector4(out, createVector4(5, 1, 7, 2), createVector4(2, 3, 4, 9));
+    expect(out).toMatchObject({ x: 5, y: 3, z: 7, w: 9 });
+  });
 });
 
 describe('minVector4', () => {
+  it('takes each component from whichever side wins, and gives the same answer either way round', () => {
+    // The winner alternates between the two arguments component by component, and all 8 numbers
+    // are distinct, so a line reading the wrong component or the wrong side cannot land on the
+    // right answer anyway. Running it again with the arguments swapped must not change it.
+    const a = createVector4(1, 5, 2, 9);
+    const b = createVector4(3, 0, 7, 4);
+    const out = createVector4();
+
+    minVector4(out, a, b);
+    expect(out.x).toBe(1);
+    expect(out.y).toBe(0);
+    expect(out.z).toBe(2);
+    expect(out.w).toBe(4);
+
+    minVector4(out, b, a);
+    expect(out.x).toBe(1);
+    expect(out.y).toBe(0);
+    expect(out.z).toBe(2);
+    expect(out.w).toBe(4);
+  });
+
   it('returns the component-wise minimum', () => {
     const out = createVector4();
     minVector4(out, createVector4(1, 5, 2, 9), createVector4(3, 2, 7, 4));
@@ -322,6 +518,22 @@ describe('minVector4', () => {
     expect(out.z).toBe(2);
     expect(out.w).toBe(4);
   });
+
+  it('supports out === a or b', () => {
+    const a = createVector4(1, 5, 2, 9);
+    minVector4(a, a, createVector4(3, 2, 7, 4));
+    expect(a).toMatchObject({ x: 1, y: 2, z: 2, w: 4 });
+
+    const b = createVector4(3, 2, 7, 4);
+    minVector4(b, createVector4(1, 5, 2, 9), b);
+    expect(b).toMatchObject({ x: 1, y: 2, z: 2, w: 4 });
+  });
+
+  it('selects the complementary component outcomes', () => {
+    const out = createVector4();
+    minVector4(out, createVector4(5, 1, 7, 2), createVector4(2, 3, 4, 9));
+    expect(out).toMatchObject({ x: 2, y: 1, z: 4, w: 2 });
+  });
 });
 
 describe('multiplyVector4', () => {
@@ -333,6 +545,16 @@ describe('multiplyVector4', () => {
     expect(out.z).toBe(32);
     expect(out.w).toBe(45);
   });
+
+  it('supports out === a or b', () => {
+    const a = createVector4(2, 3, 4, 5);
+    multiplyVector4(a, a, createVector4(6, 7, 8, 9));
+    expect(a).toMatchObject({ x: 12, y: 21, z: 32, w: 45 });
+
+    const b = createVector4(6, 7, 8, 9);
+    multiplyVector4(b, createVector4(2, 3, 4, 5), b);
+    expect(b).toMatchObject({ x: 12, y: 21, z: 32, w: 45 });
+  });
 });
 
 describe('nearEqualsVector4', () => {
@@ -486,6 +708,15 @@ describe('reflectVector4', () => {
     reflectVector4(v, v, createVector4(1, 0, 0, 0));
     expect(v.x).toBeCloseTo(-1, 6);
   });
+
+  it('supports out === normal', () => {
+    const normal = createVector4(1, 0, 0, 0);
+    reflectVector4(normal, createVector4(1, 0, 0, 0), normal);
+    expect(normal.x).toBeCloseTo(-1, 6);
+    expect(normal.y).toBeCloseTo(0, 6);
+    expect(normal.z).toBeCloseTo(0, 6);
+    expect(normal.w).toBeCloseTo(0, 6);
+  });
 });
 
 describe('scaleVector4', () => {

package/src/vector4Pool.test.ts

@@ -1,3 +1,4 @@
+import { attachEntityBinding, getEntityBinding } from '@flighthq/entity/contract';
 import type { Vector4 } from '@flighthq/types/contract';
 
 import { acquireEmptyVector4, acquireVector4, clearVector4Pool, releaseVector4 } from './vector4Pool';
@@ -65,6 +66,16 @@ describe('clearVector4Pool', () => {
 });
 
 describe('releaseVector4', () => {
+  it('detaches the previous owner binding before the vector is reused', () => {
+    const v = acquireVector4();
+    attachEntityBinding(v, { owner: 'first' });
+    releaseVector4(v);
+
+    const reused = acquireVector4();
+    expect(reused).toBe(v);
+    expect(getEntityBinding(reused)).toBeNull();
+  });
+
   it('handles null safely', () => {
     expect(() => releaseVector4(null as unknown as Vector4)).not.toThrow();
   });