glmaths 0.0.1

package/tests/vec4.test.ts

@@ -0,0 +1,390 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import glmaths, { Vec4, vec4, Mat4, Quat } 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('Vec4', () => {
+  describe('constructor', () => {
+    it('creates zero vector by default', () => {
+      const v = new Vec4()
+      assert.strictEqual(v[0], 0)
+      assert.strictEqual(v[1], 0)
+      assert.strictEqual(v[2], 0)
+      assert.strictEqual(v[3], 0)
+    })
+    it('creates with given values', () => {
+      const v = new Vec4(1, 2, 3, 4)
+      assert.strictEqual(v[0], 1)
+      assert.strictEqual(v[1], 2)
+      assert.strictEqual(v[2], 3)
+      assert.strictEqual(v[3], 4)
+    })
+    it('extends Float32Array with length 4', () => {
+      assert.ok(new Vec4() instanceof Float32Array)
+      assert.strictEqual(new Vec4().length, 4)
+    })
+  })
+
+  describe('x/y/z/w getters and setters', () => {
+    it('gets and sets', () => {
+      const v = new Vec4()
+      v.x = 1; v.y = 2; v.z = 3; v.w = 4
+      assert.strictEqual(v.x, 1)
+      assert.strictEqual(v.y, 2)
+      assert.strictEqual(v.z, 3)
+      assert.strictEqual(v.w, 4)
+    })
+  })
+
+  describe('static constants', () => {
+    it('ZERO', () => {
+      const v = Vec4.ZERO
+      assert.strictEqual(v[0], 0)
+      assert.strictEqual(v[1], 0)
+      assert.strictEqual(v[2], 0)
+      assert.strictEqual(v[3], 0)
+    })
+    it('ONE', () => {
+      const v = Vec4.ONE
+      assert.strictEqual(v[0], 1)
+      assert.strictEqual(v[1], 1)
+      assert.strictEqual(v[2], 1)
+      assert.strictEqual(v[3], 1)
+    })
+  })
+
+  describe('arithmetic', () => {
+    it('plus with vector', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const b = new Vec4(5, 6, 7, 8)
+      const out = new Vec4()
+      a.plus(b, out)
+      assert.strictEqual(out[0], 6)
+      assert.strictEqual(out[1], 8)
+      assert.strictEqual(out[2], 10)
+      assert.strictEqual(out[3], 12)
+    })
+    it('plus with scalar', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const r = a.plus(10)
+      assert.strictEqual(r[0], 11)
+      assert.strictEqual(r[1], 12)
+      assert.strictEqual(r[2], 13)
+      assert.strictEqual(r[3], 14)
+    })
+    it('minus', () => {
+      const a = new Vec4(5, 7, 9, 11)
+      const b = new Vec4(1, 2, 3, 4)
+      const out = new Vec4()
+      a.minus(b, out)
+      assert.strictEqual(out[0], 4)
+      assert.strictEqual(out[1], 5)
+      assert.strictEqual(out[2], 6)
+      assert.strictEqual(out[3], 7)
+    })
+    it('mult with vector', () => {
+      const a = new Vec4(2, 3, 4, 5)
+      const b = new Vec4(6, 7, 8, 9)
+      const out = new Vec4()
+      a.mult(b, out)
+      assert.strictEqual(out[0], 12)
+      assert.strictEqual(out[1], 21)
+      assert.strictEqual(out[2], 32)
+      assert.strictEqual(out[3], 45)
+    })
+    it('div with scalar', () => {
+      const a = new Vec4(10, 20, 30, 40)
+      const r = a.div(10)
+      assert.strictEqual(r[0], 1)
+      assert.strictEqual(r[1], 2)
+      assert.strictEqual(r[2], 3)
+      assert.strictEqual(r[3], 4)
+    })
+    it('scale with number', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const r = a.scale(2)
+      assert.strictEqual(r[0], 2)
+      assert.strictEqual(r[1], 4)
+      assert.strictEqual(r[2], 6)
+      assert.strictEqual(r[3], 8)
+    })
+    it('scale with vector', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const r = a.scale(new Vec4(2, 3, 4, 5))
+      assert.strictEqual(r[0], 2)
+      assert.strictEqual(r[1], 6)
+      assert.strictEqual(r[2], 12)
+      assert.strictEqual(r[3], 20)
+    })
+  })
+
+  describe('negate', () => {
+    it('negates all components', () => {
+      const a = new Vec4(1, -2, 3, -4)
+      const r = a.negate()
+      assert.strictEqual(r[0], -1)
+      assert.strictEqual(r[1], 2)
+      assert.strictEqual(r[2], -3)
+      assert.strictEqual(r[3], 4)
+    })
+  })
+
+  describe('normalize', () => {
+    it('normalizes to unit length', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const r = a.normalize()
+      closeTo(r.len(), 1)
+    })
+    it('handles zero vector', () => {
+      const a = new Vec4(0, 0, 0, 0)
+      a.normalize()
+      assert.strictEqual(a[0], 0)
+    })
+  })
+
+  describe('len / squaredLength', () => {
+    it('length of (1,0,0,0) is 1', () => {
+      assert.strictEqual(new Vec4(1, 0, 0, 0).len(), 1)
+    })
+    it('squared length', () => {
+      assert.strictEqual(new Vec4(1, 2, 3, 4).squaredLength(), 30)
+    })
+  })
+
+  describe('floor / round / ceil', () => {
+    it('floor', () => {
+      const v = new Vec4(1.7, 2.3, 3.9, 4.1)
+      const r = v.floor()
+      assert.strictEqual(r[0], 1)
+      assert.strictEqual(r[1], 2)
+      assert.strictEqual(r[2], 3)
+      assert.strictEqual(r[3], 4)
+    })
+    it('round', () => {
+      const v = new Vec4(1.4, 2.6, 3.5, 4.1)
+      const r = v.round()
+      assert.strictEqual(r[0], 1)
+      assert.strictEqual(r[1], 3)
+      assert.strictEqual(r[2], 4)
+      assert.strictEqual(r[3], 4)
+    })
+    it('ceil', () => {
+      const v = new Vec4(1.1, 2.0, 3.9, 4.01)
+      const r = v.ceil()
+      assert.strictEqual(r[0], 2)
+      assert.strictEqual(r[1], 2)
+      assert.strictEqual(r[2], 4)
+      assert.strictEqual(r[3], 5)
+    })
+  })
+
+  describe('inverse', () => {
+    it('inverts components', () => {
+      const v = new Vec4(2, 4, 5, 10)
+      const r = v.inverse()
+      closeTo(r[0], 0.5)
+      closeTo(r[1], 0.25)
+      closeTo(r[2], 0.2)
+      closeTo(r[3], 0.1)
+    })
+  })
+
+  describe('clone / toString', () => {
+    it('clones independently', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const b = a.clone()
+      b[0] = 99
+      assert.strictEqual(a[0], 1)
+    })
+    it('toString', () => {
+      assert.strictEqual(new Vec4(1, 2, 3, 4).toString(), 'vec4(1, 2, 3, 4)')
+    })
+  })
+
+  describe('equals / exactEquals', () => {
+    it('exactEquals', () => {
+      assert.strictEqual(new Vec4(1, 2, 3, 4).exactEquals(new Vec4(1, 2, 3, 4)), true)
+      assert.strictEqual(new Vec4(1, 2, 3, 4).exactEquals(new Vec4(1, 2, 3, 5)), false)
+    })
+    it('equals with epsilon', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const b = new Vec4(1 + EPSILON * 0.1, 2, 3, 4)
+      assert.strictEqual(a.equals(b), true)
+    })
+  })
+
+  describe('static dot', () => {
+    it('calculates dot product', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const b = new Vec4(5, 6, 7, 8)
+      assert.strictEqual(Vec4.dot(a, b), 70)
+    })
+  })
+
+  describe('static lerp', () => {
+    it('interpolates at t=0.5', () => {
+      const out = Vec4.lerp(new Vec4(0, 0, 0, 0), new Vec4(10, 20, 30, 40), 0.5)
+      assert.strictEqual(out[0], 5)
+      assert.strictEqual(out[1], 10)
+      assert.strictEqual(out[2], 15)
+      assert.strictEqual(out[3], 20)
+    })
+  })
+
+  describe('static distance / squaredDistance', () => {
+    it('distance', () => {
+      const a = new Vec4(0, 0, 0, 0)
+      const b = new Vec4(1, 0, 0, 0)
+      assert.strictEqual(Vec4.distance(a, b), 1)
+    })
+    it('squaredDistance', () => {
+      const a = new Vec4(0, 0, 0, 0)
+      const b = new Vec4(1, 2, 3, 4)
+      assert.strictEqual(Vec4.squaredDistance(a, b), 30)
+    })
+  })
+
+  describe('static max / min', () => {
+    it('max', () => {
+      const out = Vec4.max(new Vec4(1, 5, 3, 7), new Vec4(3, 2, 6, 4))
+      assert.strictEqual(out[0], 3)
+      assert.strictEqual(out[1], 5)
+      assert.strictEqual(out[2], 6)
+      assert.strictEqual(out[3], 7)
+    })
+    it('min', () => {
+      const out = Vec4.min(new Vec4(1, 5, 3, 7), new Vec4(3, 2, 6, 4))
+      assert.strictEqual(out[0], 1)
+      assert.strictEqual(out[1], 2)
+      assert.strictEqual(out[2], 3)
+      assert.strictEqual(out[3], 4)
+    })
+  })
+
+  describe('scaleAndAdd', () => {
+    it('adds scaled vector', () => {
+      const a = new Vec4(1, 2, 3, 4)
+      const b = new Vec4(1, 1, 1, 1)
+      const out = new Vec4()
+      a.scaleAndAdd(b, 3, out)
+      closeTo(out[0], 4)
+      closeTo(out[1], 5)
+      closeTo(out[2], 6)
+      closeTo(out[3], 7)
+    })
+    it('static version', () => {
+      const out = Vec4.scaleAndAdd(new Vec4(1, 2, 3, 4), new Vec4(2, 2, 2, 2), 0.5)
+      closeTo(out[0], 2)
+      closeTo(out[1], 3)
+      closeTo(out[2], 4)
+      closeTo(out[3], 5)
+    })
+  })
+
+  describe('abs', () => {
+    it('absolute value of components', () => {
+      const v = new Vec4(-1, -2, 3, -4)
+      const out = new Vec4()
+      v.abs(out)
+      assert.strictEqual(out[0], 1)
+      assert.strictEqual(out[1], 2)
+      assert.strictEqual(out[2], 3)
+      assert.strictEqual(out[3], 4)
+    })
+  })
+
+  describe('transformMat4', () => {
+    it('identity transform', () => {
+      const v = new Vec4(1, 2, 3, 1)
+      const out = new Vec4()
+      v.transformMat4(Mat4.identity, out)
+      closeTo(out[0], 1)
+      closeTo(out[1], 2)
+      closeTo(out[2], 3)
+      closeTo(out[3], 1)
+    })
+  })
+
+  describe('transformQuat', () => {
+    it('identity quat leaves vector unchanged', () => {
+      const v = new Vec4(1, 2, 3, 4)
+      const out = new Vec4()
+      v.transformQuat(Quat.identity, out)
+      closeTo(out[0], 1)
+      closeTo(out[1], 2)
+      closeTo(out[2], 3)
+      closeTo(out[3], 4) // w preserved
+    })
+  })
+
+  describe('GLSL functions', () => {
+    it('clamp', () => {
+      const v = new Vec4(-1, 0.5, 2, 0.5)
+      const out = new Vec4()
+      v.clamp(0, 1, out)
+      assert.strictEqual(out[0], 0)
+      closeTo(out[1], 0.5)
+      assert.strictEqual(out[2], 1)
+      closeTo(out[3], 0.5)
+    })
+    it('mix', () => {
+      const a = new Vec4(0, 0, 0, 0)
+      const b = new Vec4(10, 20, 30, 40)
+      const out = new Vec4()
+      a.mix(b, 0.5, out)
+      closeTo(out[0], 5)
+      closeTo(out[1], 10)
+      closeTo(out[2], 15)
+      closeTo(out[3], 20)
+    })
+    it('step', () => {
+      const v = new Vec4(0.3, 0.5, 0.7, 1.0)
+      const out = new Vec4()
+      v.step(0.5, out)
+      assert.strictEqual(out[0], 0)
+      assert.strictEqual(out[1], 1)
+      assert.strictEqual(out[2], 1)
+      assert.strictEqual(out[3], 1)
+    })
+    it('fract', () => {
+      const v = new Vec4(1.7, 2.3, 3.9, 0.1)
+      const out = new Vec4()
+      v.fract(out)
+      closeTo(out[0], 0.7)
+      closeTo(out[1], 0.3)
+      closeTo(out[2], 0.9)
+      closeTo(out[3], 0.1)
+    })
+    it('sign', () => {
+      const v = new Vec4(-5, 0, 3, -1)
+      const out = new Vec4()
+      v.sign(out)
+      assert.strictEqual(out[0], -1)
+      assert.strictEqual(out[1], 0)
+      assert.strictEqual(out[2], 1)
+      assert.strictEqual(out[3], -1)
+    })
+    it('saturate', () => {
+      const v = new Vec4(-0.5, 0.5, 1.5, 0)
+      const out = new Vec4()
+      v.saturate(out)
+      assert.strictEqual(out[0], 0)
+      closeTo(out[1], 0.5)
+      assert.strictEqual(out[2], 1)
+      assert.strictEqual(out[3], 0)
+    })
+  })
+
+  describe('factory function', () => {
+    it('creates Vec4', () => {
+      const v = vec4(1, 2, 3, 4)
+      assert.ok(v instanceof Vec4)
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "importHelpers": false,
+    "types": ["node"],
+    "lib": ["ES2020", "DOM"]
+  },
+  "include": ["src", "tests"]
+}

package/tsconfig.test.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "node"
+  },
+  "include": ["src", "tests"]
+}