glmaths 0.0.1

package/tests/vec2.test.ts

@@ -0,0 +1,617 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import glmaths, { Vec2, vec2, Vec3, Mat2, Mat2x3, Mat3, Mat4 } from '../dist/esm/glmaths'
+
+function closeTo(actual: number, expected: number, numDigits = 5) {
+  const pass = Math.abs(actual - expected) < Math.pow(10, -numDigits) / 2
+  assert.ok(pass, `expected ${actual} to be close to ${expected}`)
+}
+
+const EPSILON = glmaths.EPSILON
+
+describe('Vec2', () => {
+  describe('constructor', () => {
+    it('creates a zero vector by default', () => {
+      const v = vec2()
+      assert.strictEqual(v[0], 0)
+      assert.strictEqual(v[1], 0)
+    })
+    it('creates a vector with given values', () => {
+      const v = vec2(3, 4)
+      assert.strictEqual(v[0], 3)
+      assert.strictEqual(v[1], 4)
+    })
+    it('extends Float32Array with length 2', () => {
+      const v = vec2()
+      assert.ok(v instanceof Float32Array)
+      assert.strictEqual(v.length, 2)
+    })
+  })
+
+  describe('x/y getters and setters', () => {
+    it('gets x and y', () => {
+      const v = vec2(5, 6)
+      assert.strictEqual(v.x, 5)
+      assert.strictEqual(v.y, 6)
+    })
+    it('sets x and y', () => {
+      const v = vec2()
+      v.x = 10
+      v.y = 20
+      assert.strictEqual(v[0], 10)
+      assert.strictEqual(v[1], 20)
+    })
+  })
+
+  describe('static constants', () => {
+    it('ZERO returns (0,0)', () => {
+      const v = Vec2.ZERO
+      assert.strictEqual(v[0], 0)
+      assert.strictEqual(v[1], 0)
+    })
+    it('ONE returns (1,1)', () => {
+      const v = Vec2.ONE
+      assert.strictEqual(v[0], 1)
+      assert.strictEqual(v[1], 1)
+    })
+  })
+
+  describe('plus / add', () => {
+    it('adds two vectors in-place', () => {
+      const a = vec2(1, 2)
+      const b = vec2(3, 4)
+      const result = a.plus(b)
+      assert.strictEqual(result[0], 4)
+      assert.strictEqual(result[1], 6)
+    })
+    it('adds a scalar to both components', () => {
+      const a = vec2(1, 2)
+      const r = a.plus(5)
+      assert.strictEqual(r[0], 6)
+      assert.strictEqual(r[1], 7)
+    })
+    it('writes to out parameter without modifying this', () => {
+      const a = vec2(1, 2)
+      const b = vec2(3, 4)
+      const out = vec2()
+      const result = a.plus(b, out)
+      assert.strictEqual(result, out)
+      assert.strictEqual(out[0], 4)
+      assert.strictEqual(out[1], 6)
+      assert.strictEqual(a[0], 1)
+      assert.strictEqual(a[1], 2)
+    })
+    it('add alias works', () => {
+      const a = vec2(1, 2)
+      const b = vec2(3, 4)
+      const out = vec2()
+      a.add(b, out)
+      assert.strictEqual(out[0], 4)
+      assert.strictEqual(out[1], 6)
+    })
+  })
+
+  describe('minus / sub / subtract', () => {
+    it('subtracts two vectors', () => {
+      const a = vec2(5, 7)
+      const b = vec2(2, 3)
+      const out = vec2()
+      a.minus(b, out)
+      assert.strictEqual(out[0], 3)
+      assert.strictEqual(out[1], 4)
+    })
+    it('subtracts a scalar', () => {
+      const a = vec2(5, 7)
+      const r = a.minus(2)
+      assert.strictEqual(r[0], 3)
+      assert.strictEqual(r[1], 5)
+    })
+  })
+
+  describe('mult / mul / multiply / times', () => {
+    it('multiplies component-wise', () => {
+      const a = vec2(2, 3)
+      const b = vec2(4, 5)
+      const out = vec2()
+      a.mult(b, out)
+      assert.strictEqual(out[0], 8)
+      assert.strictEqual(out[1], 15)
+    })
+    it('multiplies by scalar', () => {
+      const a = vec2(2, 3)
+      const r = a.mult(3)
+      assert.strictEqual(r[0], 6)
+      assert.strictEqual(r[1], 9)
+    })
+  })
+
+  describe('div / divide', () => {
+    it('divides component-wise', () => {
+      const a = vec2(10, 20)
+      const b = vec2(2, 5)
+      const out = vec2()
+      a.div(b, out)
+      assert.strictEqual(out[0], 5)
+      assert.strictEqual(out[1], 4)
+    })
+    it('divides by scalar', () => {
+      const a = vec2(10, 20)
+      const r = a.div(2)
+      assert.strictEqual(r[0], 5)
+      assert.strictEqual(r[1], 10)
+    })
+  })
+
+  describe('invDiv', () => {
+    it('divides scalar by vector components', () => {
+      const a = vec2(2, 4)
+      const out = vec2()
+      a.invDiv(8, out)
+      assert.strictEqual(out[0], 4)
+      assert.strictEqual(out[1], 2)
+    })
+  })
+
+  describe('scale', () => {
+    it('scales by a number', () => {
+      const a = vec2(2, 3)
+      const r = a.scale(3)
+      assert.strictEqual(r[0], 6)
+      assert.strictEqual(r[1], 9)
+    })
+    it('scales by a vector', () => {
+      const a = vec2(2, 3)
+      const r = a.scale(vec2(4, 5))
+      assert.strictEqual(r[0], 8)
+      assert.strictEqual(r[1], 15)
+    })
+  })
+
+  describe('negate', () => {
+    it('negates components', () => {
+      const a = vec2(3, -4)
+      const r = a.negate()
+      assert.strictEqual(r[0], -3)
+      assert.strictEqual(r[1], 4)
+    })
+  })
+
+  describe('normalize', () => {
+    it('normalizes a vector to unit length', () => {
+      const a = vec2(3, 4)
+      const r = a.normalize()
+      closeTo(r[0], 0.6)
+      closeTo(r[1], 0.8)
+      closeTo(r.len(), 1)
+    })
+    it('handles zero vector', () => {
+      const a = vec2(0, 0)
+      a.normalize()
+      assert.strictEqual(a[0], 0)
+      assert.strictEqual(a[1], 0)
+    })
+  })
+
+  describe('len / squaredLength', () => {
+    it('calculates length', () => {
+      const a = vec2(3, 4)
+      closeTo(a.len(), 5)
+    })
+    it('calculates squared length', () => {
+      const a = vec2(3, 4)
+      assert.strictEqual(a.squaredLength(), 25)
+    })
+    it('sqrLen alias works', () => {
+      const a = vec2(3, 4)
+      assert.strictEqual(a.sqrLen(), 25)
+    })
+  })
+
+  describe('floor / round / ceil', () => {
+    it('floors components', () => {
+      const a = vec2(1.7, 2.3)
+      const r = a.floor()
+      assert.strictEqual(r[0], 1)
+      assert.strictEqual(r[1], 2)
+    })
+    it('rounds components', () => {
+      const a = vec2(1.4, 2.6)
+      const r = a.round()
+      assert.strictEqual(r[0], 1)
+      assert.strictEqual(r[1], 3)
+    })
+    it('ceils components', () => {
+      const a = vec2(1.1, 2.9)
+      const r = a.ceil()
+      assert.strictEqual(r[0], 2)
+      assert.strictEqual(r[1], 3)
+    })
+  })
+
+  describe('equals / exactEquals', () => {
+    it('returns true for equal vectors', () => {
+      const a = vec2(1, 2)
+      const b = vec2(1, 2)
+      assert.strictEqual(a.exactEquals(b), true)
+      assert.strictEqual(a.equals(b), true)
+    })
+    it('returns false for different vectors', () => {
+      const a = vec2(1, 2)
+      const b = vec2(1, 3)
+      assert.strictEqual(a.exactEquals(b), false)
+      assert.strictEqual(a.equals(b), false)
+    })
+    it('equals allows epsilon difference', () => {
+      const a = vec2(1, 2)
+      const b = vec2(1 + EPSILON * 0.5, 2)
+      assert.strictEqual(a.exactEquals(b), false)
+      assert.strictEqual(a.equals(b), true)
+    })
+  })
+
+  describe('toString', () => {
+    it('returns string representation', () => {
+      const a = vec2(1, 2)
+      assert.strictEqual(a.toString(), 'vec2(1, 2)')
+    })
+  })
+
+  describe('clone', () => {
+    it('creates an independent copy', () => {
+      const a = vec2(1, 2)
+      const b = a.clone()
+      assert.strictEqual(b[0], 1)
+      assert.strictEqual(b[1], 2)
+      b[0] = 99
+      assert.strictEqual(a[0], 1)
+    })
+  })
+
+  describe('static methods', () => {
+    it('dot product', () => {
+      const a = vec2(1, 2)
+      const b = vec2(3, 4)
+      assert.strictEqual(Vec2.dot(a, b), 11)
+    })
+    it('cross product returns Vec3 with z = determinant', () => {
+      const a = vec2(1, 0)
+      const b = vec2(0, 1)
+      const out = Vec2.cross(a, b)
+      assert.strictEqual(out[0], 0)
+      assert.strictEqual(out[1], 0)
+      assert.strictEqual(out[2], 1)
+    })
+    it('cross product of parallel vectors is zero', () => {
+      const a = vec2(2, 0)
+      const b = vec2(5, 0)
+      const out = Vec2.cross(a, b)
+      assert.strictEqual(out[2], 0)
+    })
+    it('distance', () => {
+      const a = vec2(0, 0)
+      const b = vec2(3, 4)
+      closeTo(Vec2.distance(a, b), 5)
+    })
+    it('squaredDistance', () => {
+      const a = vec2(0, 0)
+      const b = vec2(3, 4)
+      assert.strictEqual(Vec2.squaredDistance(a, b), 25)
+    })
+    it('lerp', () => {
+      const a = vec2(0, 0)
+      const b = vec2(10, 20)
+      const out = Vec2.lerp(a, b, 0.5)
+      assert.strictEqual(out[0], 5)
+      assert.strictEqual(out[1], 10)
+    })
+    it('lerp at t=0 returns a', () => {
+      const a = vec2(1, 2)
+      const b = vec2(10, 20)
+      const out = Vec2.lerp(a, b, 0)
+      assert.strictEqual(out[0], 1)
+      assert.strictEqual(out[1], 2)
+    })
+    it('lerp at t=1 returns b', () => {
+      const a = vec2(1, 2)
+      const b = vec2(10, 20)
+      const out = Vec2.lerp(a, b, 1)
+      assert.strictEqual(out[0], 10)
+      assert.strictEqual(out[1], 20)
+    })
+    it('max', () => {
+      const a = vec2(1, 5)
+      const b = vec2(3, 2)
+      const out = Vec2.max(a, b)
+      assert.strictEqual(out[0], 3)
+      assert.strictEqual(out[1], 5)
+    })
+    it('min', () => {
+      const a = vec2(1, 5)
+      const b = vec2(3, 2)
+      const out = Vec2.min(a, b)
+      assert.strictEqual(out[0], 1)
+      assert.strictEqual(out[1], 2)
+    })
+    it('angle between two vectors', () => {
+      const a = vec2(1, 0)
+      const b = vec2(0, 1)
+      closeTo(Vec2.angle(a, b), Math.PI / 2)
+    })
+    it('angle between parallel vectors is 0', () => {
+      const a = vec2(1, 0)
+      const b = vec2(5, 0)
+      closeTo(Vec2.angle(a, b), 0)
+    })
+    it('rotate by 90 degrees', () => {
+      const v = vec2(1, 0)
+      const out = vec2()
+      v.rotate(Math.PI / 2, Vec2.ZERO, out)
+      closeTo(out[0], 0)
+      closeTo(out[1], 1)
+    })
+    it('rotate with origin', () => {
+      const v = vec2(2, 0)
+      const origin = vec2(1, 0)
+      const out = vec2()
+      v.rotate(Math.PI / 2, origin, out)
+      closeTo(out[0], 1)
+      closeTo(out[1], 1)
+    })
+    it('rotate by 180 degrees', () => {
+      const v = vec2(1, 0)
+      const out = vec2()
+      v.rotate(Math.PI, Vec2.ZERO, out)
+      closeTo(out[0], -1)
+      closeTo(out[1], 0)
+    })
+  })
+
+  describe('factory function', () => {
+    it('creates Vec2 with vec2()', () => {
+      const v = vec2(3, 4)
+      assert.ok(v instanceof Vec2)
+      assert.strictEqual(v[0], 3)
+      assert.strictEqual(v[1], 4)
+    })
+  })
+
+  describe('unaryMinus / unaryPlus', () => {
+    it('unaryMinus negates', () => {
+      const a = vec2(3, -4)
+      const out = vec2()
+      a.unaryMinus(out)
+      assert.strictEqual(out[0], -3)
+      assert.strictEqual(out[1], 4)
+    })
+    it('unaryPlus returns this', () => {
+      const a = vec2(3, -4)
+      const r = a.unaryPlus()
+      assert.strictEqual(r[0], 3)
+      assert.strictEqual(r[1], -4)
+    })
+  })
+
+  describe('scaleAndAdd', () => {
+    it('adds scaled vector', () => {
+      const a = vec2(1, 2)
+      const b = vec2(3, 4)
+      const out = vec2()
+      a.scaleAndAdd(b, 2, out)
+      closeTo(out[0], 7)
+      closeTo(out[1], 10)
+    })
+    it('static version', () => {
+      const out = Vec2.scaleAndAdd(vec2(1, 2), vec2(3, 4), 0.5)
+      closeTo(out[0], 2.5)
+      closeTo(out[1], 4)
+    })
+  })
+
+  describe('abs', () => {
+    it('absolute value of components', () => {
+      const v = vec2(-3, -4)
+      const out = vec2()
+      v.abs(out)
+      assert.strictEqual(out[0], 3)
+      assert.strictEqual(out[1], 4)
+    })
+  })
+
+  describe('transformMat2', () => {
+    it('transforms by 2x2 matrix', () => {
+      const v = vec2(1, 0)
+      const m = new Mat2(0, 1, -1, 0) // 90 degree rotation
+      const out = vec2()
+      v.transformMat2(m, out)
+      closeTo(out[0], 0)
+      closeTo(out[1], 1)
+    })
+  })
+
+  describe('transformMat2x3', () => {
+    it('transforms by 2x3 affine matrix', () => {
+      const v = vec2(1, 0)
+      const m = Mat2x3.fromTranslation(vec2(10, 20))
+      const out = vec2()
+      v.transformMat2x3(m, out)
+      closeTo(out[0], 11)
+      closeTo(out[1], 20)
+    })
+  })
+
+  describe('transformMat3', () => {
+    it('transforms by 3x3 matrix', () => {
+      const v = vec2(1, 0)
+      const m = Mat3.fromTranslation(vec2(5, 10))
+      const out = vec2()
+      v.transformMat3(m, out)
+      closeTo(out[0], 6)
+      closeTo(out[1], 10)
+    })
+  })
+
+  describe('transformMat4', () => {
+    it('transforms by 4x4 matrix', () => {
+      const v = vec2(1, 2)
+      const m = Mat4.fromTranslation(new Vec3(10, 20, 0))
+      const out = vec2()
+      v.transformMat4(m, out)
+      closeTo(out[0], 11)
+      closeTo(out[1], 22)
+    })
+  })
+
+  describe('reflect', () => {
+    it('reflects a vector', () => {
+      const I = vec2(1, -1)
+      const N = vec2(0, 1)
+      const out = Vec2.reflect(I, N)
+      closeTo(out[0], 1)
+      closeTo(out[1], 1)
+    })
+  })
+
+  describe('GLSL functions', () => {
+    it('clamp', () => {
+      const v = vec2(-1, 5)
+      const out = vec2()
+      v.clamp(0, 1, out)
+      assert.strictEqual(out[0], 0)
+      assert.strictEqual(out[1], 1)
+    })
+    it('clamp with vectors', () => {
+      const v = vec2(-1, 5)
+      const out = Vec2.clamp(v, vec2(0, 0), vec2(2, 3))
+      assert.strictEqual(out[0], 0)
+      assert.strictEqual(out[1], 3)
+    })
+    it('mix', () => {
+      const a = vec2(0, 0)
+      const b = vec2(10, 20)
+      const out = vec2()
+      a.mix(b, 0.5, out)
+      closeTo(out[0], 5)
+      closeTo(out[1], 10)
+    })
+    it('static mix', () => {
+      const out = Vec2.mix(vec2(0, 0), vec2(10, 20), 0.25)
+      closeTo(out[0], 2.5)
+      closeTo(out[1], 5)
+    })
+    it('step', () => {
+      const v = vec2(0.3, 0.7)
+      const out = vec2()
+      v.step(0.5, out)
+      assert.strictEqual(out[0], 0)
+      assert.strictEqual(out[1], 1)
+    })
+    it('smoothstep', () => {
+      const v = vec2(0.5, 1.5)
+      const out = vec2()
+      v.smoothstep(0, 1, out)
+      closeTo(out[0], 0.5)
+      closeTo(out[1], 1)
+    })
+    it('fract', () => {
+      const v = vec2(1.7, 2.3)
+      const out = vec2()
+      v.fract(out)
+      closeTo(out[0], 0.7)
+      closeTo(out[1], 0.3)
+    })
+    it('sign', () => {
+      const v = vec2(-5, 3)
+      const out = vec2()
+      v.sign(out)
+      assert.strictEqual(out[0], -1)
+      assert.strictEqual(out[1], 1)
+    })
+    it('saturate', () => {
+      const v = vec2(-0.5, 1.5)
+      const out = vec2()
+      v.saturate(out)
+      assert.strictEqual(out[0], 0)
+      assert.strictEqual(out[1], 1)
+    })
+  })
+  describe('operators', () => {
+    it('+', () => {
+      const a = vec2(0, 1)
+      const b = vec2(2, 3)
+      const c = a + b
+      assert.strictEqual(c.x, 2)
+      assert.strictEqual(c.y, 4)
+      let d = vec2(4, 5)
+      d += vec2(8, 8)
+      assert.strictEqual(d.x, 12)
+      assert.strictEqual(d.y, 13)
+    })
+    it('-', () => {
+      const a = vec2(0, 1)
+      const b = vec2(2, 3)
+      let c = a - b
+      assert.strictEqual(c.x, -2)
+      assert.strictEqual(c.y, -2)
+      c -= vec2(10, 20)
+      assert.strictEqual(c.x, -12)
+      assert.strictEqual(c.y, -22)
+    })
+    it('*', () => {
+      const a = vec2(0, 1)
+      const b = vec2(2, 3)
+      let c = a * b
+      assert.strictEqual(c.x, 0)
+      assert.strictEqual(c.y, 3)
+      c *= vec2(10)
+      assert.strictEqual(c.x, 0)
+      assert.strictEqual(c.y, 30)
+    })
+    it('/', () => {
+      const a = vec2(0, 1)
+      const b = vec2(2, 3)
+      let c = a / b
+      assert.strictEqual(c.x, 0)
+      closeTo(c.y, 1 / 3)
+      c /= 1 / 3
+      assert.strictEqual(c.x, 0)
+      closeTo(c.y, 1)
+    })
+    it('%', () => {
+      const a = vec2(0, 3)
+      const b = vec2(2, 2)
+      const c = a % b
+      assert.strictEqual(c.x, 0)
+      assert.strictEqual(c.y, 1)
+      let d = vec2(2, 5)
+      d %= b
+      assert.strictEqual(d.x, 0)
+      assert.strictEqual(d.y, 1)
+    })
+    it('==', () => {
+      const a = vec2(0, 3)
+      assert.strictEqual(a == a, true)
+      assert.strictEqual(vec2(0, 3) == vec2(0, 3), true)
+      assert.strictEqual(vec2(0, 3.0000005) == vec2(0, 3), true)
+      assert.strictEqual(vec2(0, 30) == vec2(0, 3), false)
+
+      assert.strictEqual(a != a, false)
+      assert.strictEqual(vec2(0, 3) != vec2(0, 3), false)
+      assert.strictEqual(vec2(0, 3.0000005) != vec2(0, 3), false)
+      assert.strictEqual(vec2(0, 30) != vec2(0, 3), true)
+    })
+    it('===', () => {
+      const a = vec2(0, 3)
+      assert.strictEqual(a === a, true)
+      assert.strictEqual(vec2(0, 3) === vec2(0, 3), true)
+      assert.strictEqual(vec2(3, 0) === vec2(0, 3), false)
+      assert.strictEqual(vec2(0, 3.0000005) === vec2(0, 3), false)
+      assert.strictEqual(vec2(0, 30) === vec2(0, 3), false)
+
+      assert.strictEqual(a !== a, false)
+      assert.strictEqual(vec2(0, 3) !== vec2(0, 3), false)
+      assert.strictEqual(vec2(3, 0) !== vec2(0, 3), true)
+      assert.strictEqual(vec2(0, 3.0000005) !== vec2(0, 3), true)
+      assert.strictEqual(vec2(0, 30) !== vec2(0, 3), true)
+    })
+  })
+})