@inglorious/engine 0.1.0 → 0.2.0

package/src/utils/math/linear-algebra/vectors.js

@@ -1,122 +1,122 @@
-/**
- * @typedef {import('./types').Vector2} Vector2
- * @typedef {import('./types').Vector3} Vector3
- * @typedef {import('./types').Vector7} Vector7
- */
-
-import { magnitude, shift } from "./vector.js"
-
-/**
- * Alias for the sum function.
- * @type {typeof sum}
- */
-export const add = sum
-
-/**
- * Computes the cross product of multiple vectors.
- * @param {...Vector3 | Vector7} vectors - The vectors to compute the cross product for.
- * @returns {Vector3 | Vector7} The resulting vector after the cross product.
- */
-export function cross(...vectors) {
-  return vectors.reduce(crossMultiplyCoordinates)
-}
-
-/**
- * Computes the distance between multiple vectors.
- * @param {...Vector2 | Vector3} vectors - The vectors to compute the distance between.
- * @returns {number} The distance between the vectors.
- */
-export function distance(...vectors) {
-  return magnitude(subtract(...vectors))
-}
-
-/**
- * Computes the dot product of multiple vectors.
- * @param {...Vector2 | Vector3} vectors - The vectors to compute the dot product for.
- * @returns {number} The resulting scalar value of the dot product.
- */
-export function dot(...vectors) {
-  return vectors
-    .reduce(dotMultiplyCoordinates)
-    .reduce((coord1, coord2) => coord1 + coord2)
-}
-
-/**
- * Alias for the dot product function.
- * @type {typeof dot}
- */
-export const scalarProduct = dot
-
-/**
- * Subtracts multiple vectors.
- * @param {...Vector2 | Vector3} vectors - The vectors to subtract.
- * @returns {Vector2 | Vector3} The resulting vector after subtraction.
- */
-export function subtract(...vectors) {
-  return vectors.reduce(subtractCoordinates)
-}
-
-/**
- * Sums multiple vectors.
- * @param {...Vector2 | Vector3} vectors - The vectors to sum.
- * @returns {Vector2 | Vector3} The resulting vector after summation.
- */
-export function sum(...vectors) {
-  return vectors.reduce(sumCoordinates)
-}
-
-/**
- * Alias for the cross product function.
- * @type {typeof cross}
- */
-export const vectorProduct = cross
-
-/**
- * Adds the coordinates of two vectors.
- * @param {Vector2 | Vector3} vector1 - The first vector.
- * @param {Vector2 | Vector3} vector2 - The second vector.
- * @returns {Vector2 | Vector3} The resulting vector after addition.
- */
-function sumCoordinates(vector1, vector2) {
-  return vector1.map((coordinate, index) => coordinate + vector2[index])
-}
-
-/**
- * Subtracts the coordinates of two vectors.
- * @param {Vector2 | Vector3} vector1 - The first vector.
- * @param {Vector2 | Vector3} vector2 - The second vector.
- * @returns {Vector2 | Vector3} The resulting vector after subtraction.
- */
-function subtractCoordinates(vector1, vector2) {
-  return vector1.map((coordinate, index) => coordinate - vector2[index])
-}
-
-/**
- * Computes the cross product of two vectors' coordinates.
- * @param {Vector3} vector1 - The first vector.
- * @param {Vector3} vector2 - The second vector.
- * @returns {Vector3} The resulting vector after the cross product.
- */
-function crossMultiplyCoordinates(vector1, vector2) {
-  const indexes = Array(vector1.length)
-    .fill(null)
-    .map((_, index) => index)
-
-  return indexes.map((_, index) => {
-    const [index1, index2] = shift(
-      indexes.filter((_, i) => i !== index),
-      index,
-    )
-    return vector1[index1] * vector2[index2] - vector1[index2] * vector2[index1]
-  })
-}
-
-/**
- * Multiplies the coordinates of two vectors.
- * @param {Vector2 | Vector3} vector1 - The first vector.
- * @param {Vector2 | Vector3} vector2 - The second vector.
- * @returns {Vector2 | Vector3} The resulting vector containing multiplied coordinates.
- */
-function dotMultiplyCoordinates(vector1, vector2) {
-  return vector1.map((coordinate, index) => coordinate * vector2[index])
-}
+/**
+ * @typedef {import('./types').Vector2} Vector2
+ * @typedef {import('./types').Vector3} Vector3
+ * @typedef {import('./types').Vector7} Vector7
+ */
+
+import { magnitude, shift } from "./vector.js"
+
+/**
+ * Alias for the sum function.
+ * @type {typeof sum}
+ */
+export const add = sum
+
+/**
+ * Computes the cross product of multiple vectors.
+ * @param {...Vector3 | Vector7} vectors - The vectors to compute the cross product for.
+ * @returns {Vector3 | Vector7} The resulting vector after the cross product.
+ */
+export function cross(...vectors) {
+  return vectors.reduce(crossMultiplyCoordinates)
+}
+
+/**
+ * Computes the distance between multiple vectors.
+ * @param {...Vector2 | Vector3} vectors - The vectors to compute the distance between.
+ * @returns {number} The distance between the vectors.
+ */
+export function distance(...vectors) {
+  return magnitude(subtract(...vectors))
+}
+
+/**
+ * Computes the dot product of multiple vectors.
+ * @param {...Vector2 | Vector3} vectors - The vectors to compute the dot product for.
+ * @returns {number} The resulting scalar value of the dot product.
+ */
+export function dot(...vectors) {
+  return vectors
+    .reduce(dotMultiplyCoordinates)
+    .reduce((coord1, coord2) => coord1 + coord2)
+}
+
+/**
+ * Alias for the dot product function.
+ * @type {typeof dot}
+ */
+export const scalarProduct = dot
+
+/**
+ * Subtracts multiple vectors.
+ * @param {...Vector2 | Vector3} vectors - The vectors to subtract.
+ * @returns {Vector2 | Vector3} The resulting vector after subtraction.
+ */
+export function subtract(...vectors) {
+  return vectors.reduce(subtractCoordinates)
+}
+
+/**
+ * Sums multiple vectors.
+ * @param {...Vector2 | Vector3} vectors - The vectors to sum.
+ * @returns {Vector2 | Vector3} The resulting vector after summation.
+ */
+export function sum(...vectors) {
+  return vectors.reduce(sumCoordinates)
+}
+
+/**
+ * Alias for the cross product function.
+ * @type {typeof cross}
+ */
+export const vectorProduct = cross
+
+/**
+ * Adds the coordinates of two vectors.
+ * @param {Vector2 | Vector3} vector1 - The first vector.
+ * @param {Vector2 | Vector3} vector2 - The second vector.
+ * @returns {Vector2 | Vector3} The resulting vector after addition.
+ */
+function sumCoordinates(vector1, vector2) {
+  return vector1.map((coordinate, index) => coordinate + vector2[index])
+}
+
+/**
+ * Subtracts the coordinates of two vectors.
+ * @param {Vector2 | Vector3} vector1 - The first vector.
+ * @param {Vector2 | Vector3} vector2 - The second vector.
+ * @returns {Vector2 | Vector3} The resulting vector after subtraction.
+ */
+function subtractCoordinates(vector1, vector2) {
+  return vector1.map((coordinate, index) => coordinate - vector2[index])
+}
+
+/**
+ * Computes the cross product of two vectors' coordinates.
+ * @param {Vector3} vector1 - The first vector.
+ * @param {Vector3} vector2 - The second vector.
+ * @returns {Vector3} The resulting vector after the cross product.
+ */
+function crossMultiplyCoordinates(vector1, vector2) {
+  const indexes = Array(vector1.length)
+    .fill(null)
+    .map((_, index) => index)
+
+  return indexes.map((_, index) => {
+    const [index1, index2] = shift(
+      indexes.filter((_, i) => i !== index),
+      index,
+    )
+    return vector1[index1] * vector2[index2] - vector1[index2] * vector2[index1]
+  })
+}
+
+/**
+ * Multiplies the coordinates of two vectors.
+ * @param {Vector2 | Vector3} vector1 - The first vector.
+ * @param {Vector2 | Vector3} vector2 - The second vector.
+ * @returns {Vector2 | Vector3} The resulting vector containing multiplied coordinates.
+ */
+function dotMultiplyCoordinates(vector1, vector2) {
+  return vector1.map((coordinate, index) => coordinate * vector2[index])
+}

package/src/utils/math/linear-algebra/vectors.test.js

@@ -1,65 +1,65 @@
-import { expect, test } from "vitest"
-
-import { cross, distance, dot, subtract, sum } from "./vectors.js"
-
-test("it should compute the cross product between two vectors (aka vectorProduct)", () => {
-  const vector1 = [1, 2, 3]
-  const vector2 = [4, 5, 6]
-  const expectedResult = [-3, 6, -3]
-
-  expect(cross(vector1, vector2)).toStrictEqual(expectedResult)
-})
-
-test("it should compute the cross product of multiple vectors (aka vectorProduct)", () => {
-  const vectors = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9],
-  ]
-  const expectedResult = [78, 6, -66]
-
-  expect(cross(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should compute the distance between multiple vectors", () => {
-  const vectors = [
-    [0, 0, 0],
-    [4, 0, 3],
-  ]
-  const expectedResult = 5
-
-  expect(distance(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should compute the dot product of multiple vectors (aka scalarProduct)", () => {
-  const vectors = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9],
-  ]
-  const expectedResult = 270
-
-  expect(dot(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should subtract multiple vectors", () => {
-  const vectors = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9],
-  ]
-  const expectedResult = [-10, -11, -12]
-
-  expect(subtract(...vectors)).toStrictEqual(expectedResult)
-})
-
-test("it should sum multiple vectors (aka add)", () => {
-  const vectors = [
-    [1, 2, 3],
-    [4, 5, 6],
-    [7, 8, 9],
-  ]
-  const expectedResult = [12, 15, 18]
-
-  expect(sum(...vectors)).toStrictEqual(expectedResult)
-})
+import { expect, test } from "vitest"
+
+import { cross, distance, dot, subtract, sum } from "./vectors.js"
+
+test("it should compute the cross product between two vectors (aka vectorProduct)", () => {
+  const vector1 = [1, 2, 3]
+  const vector2 = [4, 5, 6]
+  const expectedResult = [-3, 6, -3]
+
+  expect(cross(vector1, vector2)).toStrictEqual(expectedResult)
+})
+
+test("it should compute the cross product of multiple vectors (aka vectorProduct)", () => {
+  const vectors = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+  ]
+  const expectedResult = [78, 6, -66]
+
+  expect(cross(...vectors)).toStrictEqual(expectedResult)
+})
+
+test("it should compute the distance between multiple vectors", () => {
+  const vectors = [
+    [0, 0, 0],
+    [4, 0, 3],
+  ]
+  const expectedResult = 5
+
+  expect(distance(...vectors)).toStrictEqual(expectedResult)
+})
+
+test("it should compute the dot product of multiple vectors (aka scalarProduct)", () => {
+  const vectors = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+  ]
+  const expectedResult = 270
+
+  expect(dot(...vectors)).toStrictEqual(expectedResult)
+})
+
+test("it should subtract multiple vectors", () => {
+  const vectors = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+  ]
+  const expectedResult = [-10, -11, -12]
+
+  expect(subtract(...vectors)).toStrictEqual(expectedResult)
+})
+
+test("it should sum multiple vectors (aka add)", () => {
+  const vectors = [
+    [1, 2, 3],
+    [4, 5, 6],
+    [7, 8, 9],
+  ]
+  const expectedResult = [12, 15, 18]
+
+  expect(sum(...vectors)).toStrictEqual(expectedResult)
+})

package/src/utils/math/linear-interpolation.js

@@ -0,0 +1,9 @@
+/**
+ * Performs linear interpolation between two numbers.
+ *
+ * @param {number} a - The start value.
+ * @param {number} b - The end value.
+ * @param {number} t - The interpolation factor, typically in the range [0, 1].
+ * @returns {number} The interpolated value.
+ */
+export const lerp = (a, b, t) => a + (b - a) * t

package/src/utils/math/numbers.js

@@ -1,90 +1,90 @@
-const DEFAULT_PRECISION = 1 // Default precision used for snapping numbers.
-const DEFAULT_TOLERANCE = 0.1 // Default tolerance used for comparing numbers.
-const SQUARE_ROOT = 0.5 // Exponent used for calculating square roots.
-
-/**
- * Returns the absolute value of a number.
- * @param {number} num - The number to get the absolute value of.
- * @returns {number} The absolute value of the input number.
- */
-export function abs(num) {
-  return Math.abs(num)
-}
-
-/**
- * Clamps a number within the inclusive range specified by min and max.
- * @param {number} num - The number to clamp.
- * @param {number} min - The minimum value.
- * @param {number} max - The maximum value.
- * @returns {number} The clamped value.
- */
-export function clamp(num, min, max) {
-  if (num < min) {
-    return min
-  }
-
-  if (num > max) {
-    return max
-  }
-
-  return num
-}
-
-/**
- * Checks if two numbers are close to each other within a given tolerance.
- * @param {number} num1 - The first number.
- * @param {number} num2 - The second number.
- * @param {number} [tolerance=DEFAULT_TOLERANCE] - The tolerance for comparison.
- * @returns {boolean} True if the numbers are close, false otherwise.
- */
-export function isClose(num1, num2, tolerance = DEFAULT_TOLERANCE) {
-  return abs(num1 - num2) <= tolerance
-}
-
-/**
- * Computes the modulus of two numbers, ensuring a positive result.
- * @param {number} dividend - The number to be divided.
- * @param {number} divisor - The number to divide by.
- * @returns {number} The modulus result.
- */
-export function mod(dividend, divisor) {
-  return ((dividend % divisor) + divisor) % divisor
-}
-
-/**
- * Snaps a number to the nearest multiple of a given precision.
- * @param {number} num - The number to snap.
- * @param {number} [precision=DEFAULT_PRECISION] - The precision to snap to.
- * @returns {number} The snapped value.
- */
-export function snap(num, precision = DEFAULT_PRECISION) {
-  return Math.round(num / precision) * precision
-}
-
-/**
- * Alias for the `mod` function.
- * @type {typeof mod}
- */
-export const remainder = mod
-
-/**
- * Returns the sign of a number: 1 for positive, -1 for negative, and 0 for zero.
- * @param {number} num - The number to get the sign of.
- * @returns {number} The sign of the number.
- */
-export function sign(num) {
-  if (!num) {
-    return num
-  }
-
-  return num / abs(num)
-}
-
-/**
- * Computes the square root of a number.
- * @param {number} num - The number to compute the square root of.
- * @returns {number} The square root of the number.
- */
-export function sqrt(num) {
-  return num ** SQUARE_ROOT
-}
+const DEFAULT_PRECISION = 1 // Default precision used for snapping numbers.
+const DEFAULT_TOLERANCE = 0.1 // Default tolerance used for comparing numbers.
+const SQUARE_ROOT = 0.5 // Exponent used for calculating square roots.
+
+/**
+ * Returns the absolute value of a number.
+ * @param {number} num - The number to get the absolute value of.
+ * @returns {number} The absolute value of the input number.
+ */
+export function abs(num) {
+  return Math.abs(num)
+}
+
+/**
+ * Clamps a number within the inclusive range specified by min and max.
+ * @param {number} num - The number to clamp.
+ * @param {number} min - The minimum value.
+ * @param {number} max - The maximum value.
+ * @returns {number} The clamped value.
+ */
+export function clamp(num, min, max) {
+  if (num < min) {
+    return min
+  }
+
+  if (num > max) {
+    return max
+  }
+
+  return num
+}
+
+/**
+ * Checks if two numbers are close to each other within a given tolerance.
+ * @param {number} num1 - The first number.
+ * @param {number} num2 - The second number.
+ * @param {number} [tolerance=DEFAULT_TOLERANCE] - The tolerance for comparison.
+ * @returns {boolean} True if the numbers are close, false otherwise.
+ */
+export function isClose(num1, num2, tolerance = DEFAULT_TOLERANCE) {
+  return abs(num1 - num2) <= tolerance
+}
+
+/**
+ * Computes the modulus of two numbers, ensuring a positive result.
+ * @param {number} dividend - The number to be divided.
+ * @param {number} divisor - The number to divide by.
+ * @returns {number} The modulus result.
+ */
+export function mod(dividend, divisor) {
+  return ((dividend % divisor) + divisor) % divisor
+}
+
+/**
+ * Snaps a number to the nearest multiple of a given precision.
+ * @param {number} num - The number to snap.
+ * @param {number} [precision=DEFAULT_PRECISION] - The precision to snap to.
+ * @returns {number} The snapped value.
+ */
+export function snap(num, precision = DEFAULT_PRECISION) {
+  return Math.round(num / precision) * precision
+}
+
+/**
+ * Alias for the `mod` function.
+ * @type {typeof mod}
+ */
+export const remainder = mod
+
+/**
+ * Returns the sign of a number: 1 for positive, -1 for negative, and 0 for zero.
+ * @param {number} num - The number to get the sign of.
+ * @returns {number} The sign of the number.
+ */
+export function sign(num) {
+  if (!num) {
+    return num
+  }
+
+  return num / abs(num)
+}
+
+/**
+ * Computes the square root of a number.
+ * @param {number} num - The number to compute the square root of.
+ * @returns {number} The square root of the number.
+ */
+export function sqrt(num) {
+  return num ** SQUARE_ROOT
+}