@inglorious/engine 0.1.0 → 0.2.0

package/src/utils/math/geometry/segment.test.js

@@ -1,183 +1,183 @@
-import { expect, test } from "vitest"
-
-import { isClose } from "../numbers.js"
-import {
-  closestPoint,
-  coefficients,
-  distanceFromPoint,
-  intersectsCircle,
-} from "./segment.js"
-
-expect.extend({
-  toEqualVector(received, expected) {
-    const { isNot } = this
-    return {
-      pass: received.every((coord, index) => isClose(coord, expected[index])),
-      message: () =>
-        `${received} is ${isNot ? "" : "not"} close to ${expected}`,
-    }
-  },
-})
-
-test("it should retrieve values of *a*, *b*, and *c* from a segment, so it looks like a line in the form *ax + by + c = 0*", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [1, 0, 2],
-  }
-  const expectedResult = [-2, 1, 0]
-
-  expect(coefficients(segment)).toEqual(expectedResult)
-})
-
-test("it should find the closest point in a segment to a point projectable on it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [2, 0, 2],
-  }
-  const point = [2, 0, 0]
-  const expectedResult = [1, 0, 1]
-
-  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
-})
-
-test("it should find the closest point as the point itself when resting on the segment", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [2, 0, 2],
-  }
-  const point = [1, 0, 1]
-  const expectedResult = [1, 0, 1]
-
-  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
-})
-
-test("it return the start of a segment when the point is close to its start", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [3, 0, 4],
-  }
-  const point = [-2, 0, 0]
-  const expectedResult = [0, 0, 0]
-
-  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
-})
-
-test("it should return the end of a segment when the point is close to its end", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [3, 0, 4],
-  }
-  const point = [5, 0, 4]
-  const expectedResult = [3, 0, 4]
-
-  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point projectable on it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [3, 0, 4],
-  }
-  const point = [5, 0, 0]
-  const expectedResult = 4
-
-  expect(distanceFromPoint(segment, point)).toBe(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point resting on it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [2, 0, 2],
-  }
-  const point = [1, 0, 1]
-  const expectedResult = 0
-
-  expect(distanceFromPoint(segment, point)).toBeCloseTo(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point close to the start", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [3, 0, 4],
-  }
-  const point = [-2, 0, 0]
-  const expectedResult = 2
-
-  expect(distanceFromPoint(segment, point)).toBe(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point close to the end", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [3, 0, 4],
-  }
-  const point = [5, 0, 4]
-  const expectedResult = 2
-
-  expect(distanceFromPoint(segment, point)).toBeCloseTo(expectedResult)
-})
-
-test("it should prove that a segment that crosses a circle intersects with it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [2, 0, 2],
-  }
-  const circle = {
-    position: [1, 0, 1],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(true)
-})
-
-test("it should prove that a segment tangent to a circle intersects with it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [0, 0, 2],
-  }
-  const circle = {
-    position: [1, 0, 1],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(true)
-})
-
-test("it should prove that a segment inside of a circle intersects with it", () => {
-  const segment = {
-    from: [0.5, 0, 0.5],
-    to: [1.5, 0, 1.5],
-  }
-  const circle = {
-    position: [1, 0, 1],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(true)
-})
-
-test("it should prove that a segment that does not cross a circle does not intersect with it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [-2, 0, 2],
-  }
-  const circle = {
-    position: [1, 0, 1],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(false)
-})
-
-test("it should prove that a segment that reaches outside of a circle does not intersect with it", () => {
-  const segment = {
-    from: [0, 0, 0],
-    to: [-1, 0, -2],
-  }
-  const circle = {
-    position: [1, 0, 1],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(false)
-})
+import { expect, test } from "vitest"
+
+import { isClose } from "../numbers.js"
+import {
+  closestPoint,
+  coefficients,
+  distanceFromPoint,
+  intersectsCircle,
+} from "./segment.js"
+
+expect.extend({
+  toEqualVector(received, expected) {
+    const { isNot } = this
+    return {
+      pass: received.every((coord, index) => isClose(coord, expected[index])),
+      message: () =>
+        `${received} is ${isNot ? "" : "not"} close to ${expected}`,
+    }
+  },
+})
+
+test("it should retrieve values of *a*, *b*, and *c* from a segment, so it looks like a line in the form *ax + by + c = 0*", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [1, 0, 2],
+  }
+  const expectedResult = [-2, 1, 0]
+
+  expect(coefficients(segment)).toEqual(expectedResult)
+})
+
+test("it should find the closest point in a segment to a point projectable on it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [2, 0, 2],
+  }
+  const point = [2, 0, 0]
+  const expectedResult = [1, 0, 1]
+
+  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
+})
+
+test("it should find the closest point as the point itself when resting on the segment", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [2, 0, 2],
+  }
+  const point = [1, 0, 1]
+  const expectedResult = [1, 0, 1]
+
+  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
+})
+
+test("it return the start of a segment when the point is close to its start", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [3, 0, 4],
+  }
+  const point = [-2, 0, 0]
+  const expectedResult = [0, 0, 0]
+
+  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
+})
+
+test("it should return the end of a segment when the point is close to its end", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [3, 0, 4],
+  }
+  const point = [5, 0, 4]
+  const expectedResult = [3, 0, 4]
+
+  expect(closestPoint(segment, point)).toEqualVector(expectedResult)
+})
+
+test("it should compute the distance between a segment and a point projectable on it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [3, 0, 4],
+  }
+  const point = [5, 0, 0]
+  const expectedResult = 4
+
+  expect(distanceFromPoint(segment, point)).toBe(expectedResult)
+})
+
+test("it should compute the distance between a segment and a point resting on it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [2, 0, 2],
+  }
+  const point = [1, 0, 1]
+  const expectedResult = 0
+
+  expect(distanceFromPoint(segment, point)).toBeCloseTo(expectedResult)
+})
+
+test("it should compute the distance between a segment and a point close to the start", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [3, 0, 4],
+  }
+  const point = [-2, 0, 0]
+  const expectedResult = 2
+
+  expect(distanceFromPoint(segment, point)).toBe(expectedResult)
+})
+
+test("it should compute the distance between a segment and a point close to the end", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [3, 0, 4],
+  }
+  const point = [5, 0, 4]
+  const expectedResult = 2
+
+  expect(distanceFromPoint(segment, point)).toBeCloseTo(expectedResult)
+})
+
+test("it should prove that a segment that crosses a circle intersects with it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [2, 0, 2],
+  }
+  const circle = {
+    position: [1, 0, 1],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(segment, circle)).toBe(true)
+})
+
+test("it should prove that a segment tangent to a circle intersects with it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [0, 0, 2],
+  }
+  const circle = {
+    position: [1, 0, 1],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(segment, circle)).toBe(true)
+})
+
+test("it should prove that a segment inside of a circle intersects with it", () => {
+  const segment = {
+    from: [0.5, 0, 0.5],
+    to: [1.5, 0, 1.5],
+  }
+  const circle = {
+    position: [1, 0, 1],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(segment, circle)).toBe(true)
+})
+
+test("it should prove that a segment that does not cross a circle does not intersect with it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [-2, 0, 2],
+  }
+  const circle = {
+    position: [1, 0, 1],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(segment, circle)).toBe(false)
+})
+
+test("it should prove that a segment that reaches outside of a circle does not intersect with it", () => {
+  const segment = {
+    from: [0, 0, 0],
+    to: [-1, 0, -2],
+  }
+  const circle = {
+    position: [1, 0, 1],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(segment, circle)).toBe(false)
+})

package/src/utils/math/geometry/triangle.js

@@ -1,15 +1,15 @@
-/**
- * Calculates the length of the hypothenuse (or magnitude) for a given set of numbers
- * using the Pythagorean theorem.
- *
- * @param {number[]} nums - A list of numbers representing the sides of a right triangle.
- * @returns {number} The length of the hypothenuse.
- */
-export function hypothenuse(...nums) {
-  return Math.hypot(...nums)
-}
-
-/**
- * Alias for the `hypothenuse` function.
- */
-export const pythagoras = hypothenuse
+/**
+ * Calculates the length of the hypothenuse (or magnitude) for a given set of numbers
+ * using the Pythagorean theorem.
+ *
+ * @param {number[]} nums - A list of numbers representing the sides of a right triangle.
+ * @returns {number} The length of the hypothenuse.
+ */
+export function hypothenuse(...nums) {
+  return Math.hypot(...nums)
+}
+
+/**
+ * Alias for the `hypothenuse` function.
+ */
+export const pythagoras = hypothenuse

package/src/utils/math/geometry/triangle.test.js

@@ -1,11 +1,11 @@
-import { expect, test } from "vitest"
-
-import { hypothenuse } from "./triangle.js"
-
-test("it should compute the hypothenuse of two catheti (aka pythagoras)", () => {
-  const cat1 = 3
-  const cat2 = 4
-  const expectedResult = 5
-
-  expect(hypothenuse(cat1, cat2)).toBe(expectedResult)
-})
+import { expect, test } from "vitest"
+
+import { hypothenuse } from "./triangle.js"
+
+test("it should compute the hypothenuse of two catheti (aka pythagoras)", () => {
+  const cat1 = 3
+  const cat2 = 4
+  const expectedResult = 5
+
+  expect(hypothenuse(cat1, cat2)).toBe(expectedResult)
+})

package/src/utils/math/linear-algebra/2d.js

@@ -1,28 +1,28 @@
-/**
- * @typedef {import('../../../types').Vector2} Vector2
- * @typedef {import('../../../types').Vector3} Vector3
- */
-
-const NO_Y = 0 // Default Y-coordinate value for 3D vectors derived from 2D vectors.
-
-/**
- * Converts a 2D vector [x, z] into a 3D vector [x, 0, z].
- *
- * @param {Vector2} vector - A 2D vector represented as [x, z].
- * @returns {Vector3} A 3D vector represented as [x, 0, z].
- */
-export function from2D(vector) {
-  const [x, z] = vector
-  return [x, NO_Y, z]
-}
-
-/**
- * Converts a 3D vector [x, y, z] into a 2D vector [x, z].
- *
- * @param {Vector3} vector - A 3D vector represented as [x, y, z].
- * @returns {Vector2} A 2D vector represented as [x, z].
- */
-export function to2D(vector) {
-  const [x, , z] = vector
-  return [x, z]
-}
+/**
+ * @typedef {import('../../../types').Vector2} Vector2
+ * @typedef {import('../../../types').Vector3} Vector3
+ */
+
+const NO_Y = 0 // Default Y-coordinate value for 3D vectors derived from 2D vectors.
+
+/**
+ * Converts a 2D vector [x, z] into a 3D vector [x, 0, z].
+ *
+ * @param {Vector2} vector - A 2D vector represented as [x, z].
+ * @returns {Vector3} A 3D vector represented as [x, 0, z].
+ */
+export function from2D(vector) {
+  const [x, z] = vector
+  return [x, NO_Y, z]
+}
+
+/**
+ * Converts a 3D vector [x, y, z] into a 2D vector [x, z].
+ *
+ * @param {Vector3} vector - A 3D vector represented as [x, y, z].
+ * @returns {Vector2} A 2D vector represented as [x, z].
+ */
+export function to2D(vector) {
+  const [x, , z] = vector
+  return [x, z]
+}

package/src/utils/math/linear-algebra/2d.test.js

@@ -1,17 +1,17 @@
-import { expect, test } from "vitest"
-
-import { from2D, to2D } from "./2d.js"
-
-test("build a 3D vector from a 2D one", () => {
-  const vector = [3, 4]
-  const expectedResult = [3, 0, 4]
-
-  expect(from2D(vector)).toStrictEqual(expectedResult)
-})
-
-test("build a 2D vector from a 3D one", () => {
-  const vector = [3, 0, 4]
-  const expectedResult = [3, 4]
-
-  expect(to2D(vector)).toStrictEqual(expectedResult)
-})
+import { expect, test } from "vitest"
+
+import { from2D, to2D } from "./2d.js"
+
+test("build a 3D vector from a 2D one", () => {
+  const vector = [3, 4]
+  const expectedResult = [3, 0, 4]
+
+  expect(from2D(vector)).toStrictEqual(expectedResult)
+})
+
+test("build a 2D vector from a 3D one", () => {
+  const vector = [3, 0, 4]
+  const expectedResult = [3, 4]
+
+  expect(to2D(vector)).toStrictEqual(expectedResult)
+})

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

@@ -1,22 +1,22 @@
-/**
- * @typedef {import('../../../types').Vector3} Vector3
- * @typedef {import('../../../types').Quaternion} Quaternion
- */
-
-import { cos, sin } from "@inglorious/utils/math/trigonometry.js"
-
-const DEFAULT_ANGLE = 0
-const HALF = 2 // Constant representing the divisor for halving an angle.
-// eslint-disable-next-line no-magic-numbers
-const Y_AXIS = [0, 1, 0] // Default axis of rotation (Y-axis).
-
-/**
- * Computes a quaternion representing a rotation around a given axis.
- *
- * @param {number} [angle=0] - The angle of rotation in radians. Defaults to 0.
- * @param {Vector3} [axis=Y_AXIS] - The axis of rotation as a 3D vector Defaults to the Y-axis.
- * @returns {Quaternion} The quaternion as an array [w, x, y, z].
- */
-export function quaternion(angle = DEFAULT_ANGLE, axis = Y_AXIS) {
-  return [cos(angle / HALF), ...axis.map((coord) => coord * sin(angle / HALF))]
-}
+/**
+ * @typedef {import('../../../types').Vector3} Vector3
+ * @typedef {import('../../../types').Quaternion} Quaternion
+ */
+
+import { cos, sin } from "@inglorious/utils/math/trigonometry.js"
+
+const DEFAULT_ANGLE = 0
+const HALF = 2 // Constant representing the divisor for halving an angle.
+// eslint-disable-next-line no-magic-numbers
+const Y_AXIS = [0, 1, 0] // Default axis of rotation (Y-axis).
+
+/**
+ * Computes a quaternion representing a rotation around a given axis.
+ *
+ * @param {number} [angle=0] - The angle of rotation in radians. Defaults to 0.
+ * @param {Vector3} [axis=Y_AXIS] - The axis of rotation as a 3D vector Defaults to the Y-axis.
+ * @returns {Quaternion} The quaternion as an array [w, x, y, z].
+ */
+export function quaternion(angle = DEFAULT_ANGLE, axis = Y_AXIS) {
+  return [cos(angle / HALF), ...axis.map((coord) => coord * sin(angle / HALF))]
+}

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

@@ -1,25 +1,25 @@
-import { cos, pi, sin } from "@inglorious/utils/math/trigonometry.js"
-import { expect, test } from "vitest"
-
-import { quaternion } from "./quaternion.js"
-
-test("it should return the quaternion for no rotation", () => {
-  const angle = 0
-  const expectedResult = [1, 0, 0, 0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
-
-test("it should return the quaternion for a rotation of pi/2", () => {
-  const angle = pi() / 2
-  const expectedResult = [cos(pi() / 4), 0, sin(pi() / 4), 0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
-
-test("it should return the quaternion for a rotation of negative pi/2", () => {
-  const angle = -pi() / 2
-  const expectedResult = [cos(-pi() / 4), -0, sin(-pi() / 4), -0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
+import { cos, pi, sin } from "@inglorious/utils/math/trigonometry.js"
+import { expect, test } from "vitest"
+
+import { quaternion } from "./quaternion.js"
+
+test("it should return the quaternion for no rotation", () => {
+  const angle = 0
+  const expectedResult = [1, 0, 0, 0]
+
+  expect(quaternion(angle)).toStrictEqual(expectedResult)
+})
+
+test("it should return the quaternion for a rotation of pi/2", () => {
+  const angle = pi() / 2
+  const expectedResult = [cos(pi() / 4), 0, sin(pi() / 4), 0]
+
+  expect(quaternion(angle)).toStrictEqual(expectedResult)
+})
+
+test("it should return the quaternion for a rotation of negative pi/2", () => {
+  const angle = -pi() / 2
+  const expectedResult = [cos(-pi() / 4), -0, sin(-pi() / 4), -0]
+
+  expect(quaternion(angle)).toStrictEqual(expectedResult)
+})

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

@@ -1,20 +1,20 @@
-/**
- * @typedef {import('./types').Quaternion} Quaternion
- */
-
-import { times } from "./vector.js"
-import { cross, dot, sum } from "./vectors.js"
-
-/**
- * Combines two quaternions using the Hamilton product.
- *
- * @param {Quaternion} q1 - The first quaternion.
- * @param {Quaternion} q2 - The second quaternion.
- * @returns {Quaternion} - The resulting quaternion after combining q1 and q2.
- */
-export function combine(q1, q2) {
-  const [s, ...v] = q1
-  const [t, ...w] = q2
-
-  return [s * t - dot(v, w), ...sum(times(w, s), times(v, t), cross(v, w))]
-}
+/**
+ * @typedef {import('./types').Quaternion} Quaternion
+ */
+
+import { times } from "./vector.js"
+import { cross, dot, sum } from "./vectors.js"
+
+/**
+ * Combines two quaternions using the Hamilton product.
+ *
+ * @param {Quaternion} q1 - The first quaternion.
+ * @param {Quaternion} q2 - The second quaternion.
+ * @returns {Quaternion} - The resulting quaternion after combining q1 and q2.
+ */
+export function combine(q1, q2) {
+  const [s, ...v] = q1
+  const [t, ...w] = q2
+
+  return [s * t - dot(v, w), ...sum(times(w, s), times(v, t), cross(v, w))]
+}