@inglorious/engine 0.1.0 → 0.2.0

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

@@ -1,81 +1,81 @@
-import { expect, test } from "vitest"
-
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./point.js"
-
-test("it should prove that two equal points intersect", () => {
-  const point1 = [1.5, 1.5, 0]
-  const point2 = [1.5, 1.5, 0]
-
-  expect(intersectsPoint(point1, point2)).toBe(true)
-})
-
-test("it should prove that two different points do not intersect", () => {
-  const point1 = [1.5, 1.5, 0]
-  const point2 = [2, 1, 0]
-
-  expect(intersectsPoint(point1, point2)).toBe(false)
-})
-
-test("it should prove that a point inside of a circle intersects with it", () => {
-  const point = [1.5, 1.5, 0]
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(true)
-})
-
-test("it should prove that a point on the border of a circle intersects with it", () => {
-  const point = [2, 1, 0]
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(true)
-})
-
-test("it should prove that a point outside of a circle does not intersect with it", () => {
-  const point = [2, 2, 0]
-  const circle = {
-    position: [1, 1, 0],
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(false)
-})
-
-test("it should prove that a point inside of a rectangle intersects with it", () => {
-  const point = [1.5, 1.5, 0]
-  const rectangle = {
-    position: [1, 1, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})
-
-test("it should prove that a point on the border of a rectangle intersects with it", () => {
-  const point = [2, 1, 0]
-  const rectangle = {
-    position: [1, 1, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})
-
-test("it should prove that a point outside of a rectangle does not intersect with it", () => {
-  const point = [2.5, 2.5, 0]
-  const rectangle = {
-    position: [1, 1, 0],
-    size: [2, 2, 0],
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(false)
-})
+import { expect, test } from "vitest"
+
+import {
+  intersectsCircle,
+  intersectsPoint,
+  intersectsRectangle,
+} from "./point.js"
+
+test("it should prove that two equal points intersect", () => {
+  const point1 = [1.5, 1.5, 0]
+  const point2 = [1.5, 1.5, 0]
+
+  expect(intersectsPoint(point1, point2)).toBe(true)
+})
+
+test("it should prove that two different points do not intersect", () => {
+  const point1 = [1.5, 1.5, 0]
+  const point2 = [2, 1, 0]
+
+  expect(intersectsPoint(point1, point2)).toBe(false)
+})
+
+test("it should prove that a point inside of a circle intersects with it", () => {
+  const point = [1.5, 1.5, 0]
+  const circle = {
+    position: [1, 1, 0],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(point, circle)).toBe(true)
+})
+
+test("it should prove that a point on the border of a circle intersects with it", () => {
+  const point = [2, 1, 0]
+  const circle = {
+    position: [1, 1, 0],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(point, circle)).toBe(true)
+})
+
+test("it should prove that a point outside of a circle does not intersect with it", () => {
+  const point = [2, 2, 0]
+  const circle = {
+    position: [1, 1, 0],
+    radius: 1,
+  }
+
+  expect(intersectsCircle(point, circle)).toBe(false)
+})
+
+test("it should prove that a point inside of a rectangle intersects with it", () => {
+  const point = [1.5, 1.5, 0]
+  const rectangle = {
+    position: [1, 1, 0],
+    size: [2, 2, 0],
+  }
+
+  expect(intersectsRectangle(point, rectangle)).toBe(true)
+})
+
+test("it should prove that a point on the border of a rectangle intersects with it", () => {
+  const point = [2, 1, 0]
+  const rectangle = {
+    position: [1, 1, 0],
+    size: [2, 2, 0],
+  }
+
+  expect(intersectsRectangle(point, rectangle)).toBe(true)
+})
+
+test("it should prove that a point outside of a rectangle does not intersect with it", () => {
+  const point = [2.5, 2.5, 0]
+  const rectangle = {
+    position: [1, 1, 0],
+    size: [2, 2, 0],
+  }
+
+  expect(intersectsRectangle(point, rectangle)).toBe(false)
+})

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

@@ -1,45 +1,76 @@
-/**
- * @typedef {import("./types").Rectangle} Rectangle
- * @typedef {import("./types").Platform} Platform
- */
-
-import { intersectsRectangle as circleIntersectsRectangle } from "./circle.js"
-import { intersectsRectangle as platformIntersectsRectangle } from "./platform.js"
-
-export function intersectsCircle(rectangle, circle) {
-  return circleIntersectsRectangle(circle, rectangle)
-}
-
-/**
- * Determines whether a rectangle intersects another in 3D space.
- *
- * @param {Rectangle} rectangle1 - The rectangle defined by its position (x, y, z) and size (width, height, depth).
- * @param {Rectangle} rectangle2 - The other rectangle defined by its position (z, y, z) and size (width, height, depth).
- * @returns {boolean} True if the two rectangles intersect, false otherwise.
- */
-export function intersectsRectangle(rectangle1, rectangle2) {
-  const [x1, y1, z1] = rectangle1.position
-  const [w1, h1, d1] = rectangle1.size
-
-  const [x2, y2, z2] = rectangle2.position
-  const [w2, h2, d2] = rectangle2.size
-
-  return (
-    x1 <= x2 + w2 &&
-    x1 + w1 >= x2 &&
-    y1 <= y2 + h2 &&
-    y1 + h1 >= y2 &&
-    z1 <= z2 + d2 &&
-    z1 + d1 >= z2
-  )
-}
-
-/**
- * Checks if a rectangle intersects with a platform.
- * @param {Rectangle} rectangle - The rectangle to check.
- * @param {Platform} platform - The platform to check.
- * @returns {boolean} True if the rectangle intersects the platform, false otherwise.
- */
-export function intersectsPlatform(rectangle, platform) {
-  return platformIntersectsRectangle(platform, rectangle)
-}
+/**
+ * @typedef {import("./types").Circle} Circle
+ * @typedef {import("./types").Rectangle} Rectangle
+ * @typedef {import("./types").Platform} Platform
+ */
+
+import { intersectsRectangle as circleIntersectsRectangle } from "./circle.js"
+import { intersectsRectangle as pointIntersectsRectangle } from "./point.js"
+
+const HALF = 2
+
+/**
+ * Checks if a rectangle intersects with a point.
+ * @param {Rectangle} rectangle - The rectangle to check.
+ * @param {Point} point - The point to check.
+ * @returns {boolean} True if the point intersects the circle, false otherwise.
+ */
+export function intersectsPoint(rectangle, point) {
+  return pointIntersectsRectangle(point, rectangle)
+}
+
+/**
+ * Checks if a rectangle intersects with a circle.
+ *
+ * @param {Rectangle} rectangle - The rectangle to check.
+ * @param {Circle} circle - The circle to check.
+ * @returns {boolean} True if the rectangle intersects the circle, false otherwise.
+ */
+export function intersectsCircle(rectangle, circle) {
+  return circleIntersectsRectangle(circle, rectangle)
+}
+
+/**
+ * Determines whether a rectangle intersects another in 3D space.
+ *
+ * @param {Rectangle} rectangle1 - The first rectangle, defined by its position (x, y, z) and size (width, height, depth).
+ * @param {Rectangle} rectangle2 - The second rectangle, defined by its position (x, y, z) and size (width, height, depth).
+ * @returns {boolean} True if the two rectangles intersect, false otherwise.
+ */
+export function intersectsRectangle(rectangle1, rectangle2) {
+  const [x1, y1, z1] = rectangle1.position
+  const [w1, h1, d1] = rectangle1.size
+  const halfW1 = w1 / HALF
+  const halfH1 = h1 / HALF
+  const halfD1 = d1 / HALF
+
+  const left1 = x1 - halfW1
+  const right1 = x1 + halfW1
+  const bottom1 = y1 - halfH1
+  const top1 = y1 + halfH1
+  const back1 = z1 - halfD1
+  const front1 = z1 + halfD1
+
+  const [x2, y2, z2] = rectangle2.position
+  const [w2, h2, d2] = rectangle2.size
+  const halfW2 = w2 / HALF
+  const halfH2 = h2 / HALF
+  const halfD2 = d2 / HALF
+
+  const left2 = x2 - halfW2
+  const right2 = x2 + halfW2
+  const bottom2 = y2 - halfH2
+  const top2 = y2 + halfH2
+  const back2 = z2 - halfD2
+  const front2 = z2 + halfD2
+
+  // AABB intersection test
+  return (
+    left1 <= right2 &&
+    right1 >= left2 &&
+    bottom1 <= top2 &&
+    top1 >= bottom2 &&
+    back1 <= front2 &&
+    front1 >= back2
+  )
+}

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

@@ -1,42 +1,42 @@
-import { expect, test } from "vitest"
-
-import { intersectsRectangle } from "./rectangle.js"
-
-test("it should prove that a rectangle crossing another one intersects with it", () => {
-  const rectangle1 = {
-    position: [0, 0, 0],
-    size: [2, 2, 2],
-  }
-  const rectangle2 = {
-    position: [1, 1, 1],
-    size: [2, 2, 2],
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
-})
-
-test("it should prove that a rectangle right on top of another intersects with it", () => {
-  const rectangle1 = {
-    position: [0, 0, 0],
-    size: [2, 2, 2],
-  }
-  const rectangle2 = {
-    position: [0, 0, 0],
-    size: [2, 0, 2],
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
-})
-
-test("it should prove that a rectangle not crossing another one does not intersect with it", () => {
-  const rectangle1 = {
-    position: [0, 0, 0],
-    size: [2, 2, 2],
-  }
-  const rectangle2 = {
-    position: [3, 3, 3],
-    size: [2, 2, 2],
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(false)
-})
+import { expect, test } from "vitest"
+
+import { intersectsRectangle } from "./rectangle.js"
+
+test("it should prove that a rectangle crossing another one intersects with it", () => {
+  const rectangle1 = {
+    position: [0, 0, 0],
+    size: [2, 2, 2],
+  }
+  const rectangle2 = {
+    position: [1, 1, 1],
+    size: [2, 2, 2],
+  }
+
+  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
+})
+
+test("it should prove that a rectangle right on top of another intersects with it", () => {
+  const rectangle1 = {
+    position: [0, 0, 0],
+    size: [2, 2, 2],
+  }
+  const rectangle2 = {
+    position: [0, 0, 0],
+    size: [2, 0, 2],
+  }
+
+  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
+})
+
+test("it should prove that a rectangle not crossing another one does not intersect with it", () => {
+  const rectangle1 = {
+    position: [0, 0, 0],
+    size: [2, 2, 2],
+  }
+  const rectangle2 = {
+    position: [3, 3, 3],
+    size: [2, 2, 2],
+  }
+
+  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(false)
+})

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

@@ -1,80 +1,80 @@
-/**
- * @typedef {import("./types").Segment} Segment
- * @typedef {import("./types").Point} Point
- * @typedef {import("./types").Circle} Circle
- */
-
-import {
-  magnitude,
-  setMagnitude,
-} from "@inglorious/utils/math/linear-algebra/vector.js"
-import {
-  distance,
-  dot,
-  subtract,
-  sum,
-} from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-const BEFORE_SEGMENT = 0
-
-/**
- * Calculates the coefficients [a, b, c] of the line equation ax + bz + c = 0
- * for a given segment in 2D space.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @returns {[number, number, number]} An array [a, b, c] representing the line equation.
- */
-export function coefficients(segment) {
-  const [x1, , z1] = segment.from
-  const [x2, , z2] = segment.to
-  return [z1 - z2, x2 - x1, (x1 - x2) * z1 + x1 * (z2 - z1)]
-}
-
-/**
- * Finds the closest point on a segment to a given point in 3D space.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @param {Point} point - The point in 3D space represented as [x, y, z].
- * @returns {Point} The closest point on the segment to the given point.
- */
-export function closestPoint(segment, point) {
-  const shiftedSegment = subtract(segment.to, segment.from)
-  const shiftedPoint = subtract(point, segment.from)
-
-  const projectionLength =
-    dot(shiftedSegment, shiftedPoint) / magnitude(shiftedSegment)
-
-  if (projectionLength < BEFORE_SEGMENT) {
-    return segment.from
-  }
-
-  if (projectionLength > magnitude(shiftedSegment)) {
-    return segment.to
-  }
-
-  const projectedPoint = setMagnitude(shiftedSegment, projectionLength)
-  return sum(segment.from, projectedPoint)
-}
-
-/**
- * Calculates the shortest distance from a point to a segment in 3D space.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @param {Point} point - The point in 3D space represented as [x, y, z].
- * @returns {number} The shortest distance from the point to the segment.
- */
-export function distanceFromPoint(segment, point) {
-  const closest = closestPoint(segment, point)
-  return distance(point, closest)
-}
-
-/**
- * Determines whether a segment intersects with the perimeter of a circle.
- *
- * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
- * @param {Circle} circle - The circle defined by its position (center) and radius.
- * @returns {boolean} `true` if the segment intersects the circle's perimeter, otherwise `false`.
- */
-export function intersectsCircle(segment, circle) {
-  return distanceFromPoint(segment, circle.position) <= circle.radius
-}
+/**
+ * @typedef {import("./types").Segment} Segment
+ * @typedef {import("./types").Point} Point
+ * @typedef {import("./types").Circle} Circle
+ */
+
+import {
+  magnitude,
+  setMagnitude,
+} from "@inglorious/utils/math/linear-algebra/vector.js"
+import {
+  distance,
+  dot,
+  subtract,
+  sum,
+} from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const BEFORE_SEGMENT = 0
+
+/**
+ * Calculates the coefficients [a, b, c] of the line equation ax + bz + c = 0
+ * for a given segment in 2D space.
+ *
+ * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
+ * @returns {[number, number, number]} An array [a, b, c] representing the line equation.
+ */
+export function coefficients(segment) {
+  const [x1, , z1] = segment.from
+  const [x2, , z2] = segment.to
+  return [z1 - z2, x2 - x1, (x1 - x2) * z1 + x1 * (z2 - z1)]
+}
+
+/**
+ * Finds the closest point on a segment to a given point in 3D space.
+ *
+ * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
+ * @param {Point} point - The point in 3D space represented as [x, y, z].
+ * @returns {Point} The closest point on the segment to the given point.
+ */
+export function closestPoint(segment, point) {
+  const shiftedSegment = subtract(segment.to, segment.from)
+  const shiftedPoint = subtract(point, segment.from)
+
+  const projectionLength =
+    dot(shiftedSegment, shiftedPoint) / magnitude(shiftedSegment)
+
+  if (projectionLength < BEFORE_SEGMENT) {
+    return segment.from
+  }
+
+  if (projectionLength > magnitude(shiftedSegment)) {
+    return segment.to
+  }
+
+  const projectedPoint = setMagnitude(shiftedSegment, projectionLength)
+  return sum(segment.from, projectedPoint)
+}
+
+/**
+ * Calculates the shortest distance from a point to a segment in 3D space.
+ *
+ * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
+ * @param {Point} point - The point in 3D space represented as [x, y, z].
+ * @returns {number} The shortest distance from the point to the segment.
+ */
+export function distanceFromPoint(segment, point) {
+  const closest = closestPoint(segment, point)
+  return distance(point, closest)
+}
+
+/**
+ * Determines whether a segment intersects with the perimeter of a circle.
+ *
+ * @param {Segment} segment - The segment defined by its start (`from`) and end (`to`) points.
+ * @param {Circle} circle - The circle defined by its position (center) and radius.
+ * @returns {boolean} `true` if the segment intersects the circle's perimeter, otherwise `false`.
+ */
+export function intersectsCircle(segment, circle) {
+  return distanceFromPoint(segment, circle.position) <= circle.radius
+}