@aura3d/math 1.0.6

package/src/Ray.ts

@@ -0,0 +1,67 @@
+import { Box3 } from "./Box3.js";
+import { Plane } from "./Plane.js";
+import { Sphere } from "./Sphere.js";
+import { Vector3 } from "./Vector3.js";
+
+export class Ray {
+  readonly origin: Vector3;
+  readonly direction: Vector3;
+
+  constructor(origin = Vector3.zero.clone(), direction = Vector3.forward.clone()) {
+    const normalized = direction.normalize();
+    if (normalized.lengthSquared() === 0) throw new RangeError("Ray direction must be non-zero.");
+    this.origin = origin;
+    this.direction = normalized;
+  }
+
+  at(distance: number): Vector3 {
+    return this.origin.add(this.direction.multiplyScalar(distance));
+  }
+
+  intersectPlane(plane: Plane): Vector3 | undefined {
+    const denominator = plane.normal.dot(this.direction);
+    if (Math.abs(denominator) < 1e-12) return undefined;
+    const distance = -(this.origin.dot(plane.normal) + plane.constant) / denominator;
+    return distance < 0 ? undefined : this.at(distance);
+  }
+
+  intersectSphere(sphere: Sphere): Vector3 | undefined {
+    const l = sphere.center.subtract(this.origin);
+    const tca = l.dot(this.direction);
+    const d2 = l.dot(l) - tca * tca;
+    const radius2 = sphere.radius * sphere.radius;
+    if (d2 > radius2) return undefined;
+    const thc = Math.sqrt(radius2 - d2);
+    const t0 = tca - thc;
+    const t1 = tca + thc;
+    const distance = t0 >= 0 ? t0 : t1;
+    return distance < 0 ? undefined : this.at(distance);
+  }
+
+  intersectBox(box: Box3): Vector3 | undefined {
+    if (box.isEmpty()) return undefined;
+    let tmin = Number.NEGATIVE_INFINITY;
+    let tmax = Number.POSITIVE_INFINITY;
+
+    for (const axis of ["x", "y", "z"] as const) {
+      const origin = this.origin[axis];
+      const direction = this.direction[axis];
+      const min = box.min[axis];
+      const max = box.max[axis];
+      if (Math.abs(direction) < 1e-12) {
+        if (origin < min || origin > max) return undefined;
+        continue;
+      }
+      const invD = 1 / direction;
+      let t1 = (min - origin) * invD;
+      let t2 = (max - origin) * invD;
+      if (t1 > t2) [t1, t2] = [t2, t1];
+      tmin = Math.max(tmin, t1);
+      tmax = Math.min(tmax, t2);
+      if (tmin > tmax) return undefined;
+    }
+
+    const distance = tmin >= 0 ? tmin : tmax;
+    return distance < 0 ? undefined : this.at(distance);
+  }
+}

package/src/Sphere.ts

@@ -0,0 +1,18 @@
+import { Vector3 } from "./Vector3.js";
+
+export class Sphere {
+  constructor(
+    readonly center = Vector3.zero.clone(),
+    readonly radius = 0
+  ) {
+    if (!Number.isFinite(radius) || radius < 0) throw new RangeError("Sphere radius must be finite and non-negative.");
+  }
+
+  containsPoint(point: Vector3): boolean {
+    return this.center.distanceTo(point) <= this.radius;
+  }
+
+  intersectsSphere(other: Sphere): boolean {
+    return this.center.distanceTo(other.center) <= this.radius + other.radius;
+  }
+}

package/src/Transform.ts

@@ -0,0 +1,33 @@
+import { Matrix4 } from "./Matrix4.js";
+import { Quaternion } from "./Quaternion.js";
+import { Vector3 } from "./Vector3.js";
+
+export class Transform {
+  constructor(
+    readonly position = Vector3.zero.clone(),
+    readonly rotation = Quaternion.identity.clone(),
+    readonly scale = Vector3.one.clone()
+  ) {}
+
+  static identity(): Transform {
+    return new Transform();
+  }
+
+  toMatrix4(): Matrix4 {
+    return Matrix4.compose(this.position, this.rotation, this.scale);
+  }
+
+  combine(child: Transform): Transform {
+    const scaledPosition = child.position.multiply(this.scale);
+    const rotatedPosition = this.rotation.rotateVector(scaledPosition);
+    return new Transform(
+      this.position.add(rotatedPosition),
+      this.rotation.multiply(child.rotation).normalize(),
+      this.scale.multiply(child.scale)
+    );
+  }
+
+  transformPoint(point: Vector3): Vector3 {
+    return this.toMatrix4().transformPoint(point);
+  }
+}

package/src/Vector2.ts

@@ -0,0 +1,66 @@
+export class Vector2 {
+  static readonly zero = Object.freeze(new Vector2(0, 0));
+  static readonly one = Object.freeze(new Vector2(1, 1));
+
+  constructor(
+    readonly x = 0,
+    readonly y = 0
+  ) {}
+
+  clone(): Vector2 {
+    return new Vector2(this.x, this.y);
+  }
+
+  add(v: Vector2): Vector2 {
+    return new Vector2(this.x + v.x, this.y + v.y);
+  }
+
+  subtract(v: Vector2): Vector2 {
+    return new Vector2(this.x - v.x, this.y - v.y);
+  }
+
+  multiplyScalar(scalar: number): Vector2 {
+    return new Vector2(this.x * scalar, this.y * scalar);
+  }
+
+  divide(v: Vector2): Vector2 {
+    return new Vector2(this.x / v.x, this.y / v.y);
+  }
+
+  divideScalar(scalar: number): Vector2 {
+    return new Vector2(this.x / scalar, this.y / scalar);
+  }
+
+  dot(v: Vector2): number {
+    return this.x * v.x + this.y * v.y;
+  }
+
+  lengthSquared(): number {
+    return this.dot(this);
+  }
+
+  length(): number {
+    return Math.hypot(this.x, this.y);
+  }
+
+  normalize(): Vector2 {
+    const len = this.length();
+    return len === 0 ? Vector2.zero.clone() : this.multiplyScalar(1 / len);
+  }
+
+  distanceTo(v: Vector2): number {
+    return this.subtract(v).length();
+  }
+
+  lerp(v: Vector2, t: number): Vector2 {
+    return new Vector2(this.x + (v.x - this.x) * t, this.y + (v.y - this.y) * t);
+  }
+
+  equals(v: Vector2, epsilon = 1e-10): boolean {
+    return Math.abs(this.x - v.x) <= epsilon && Math.abs(this.y - v.y) <= epsilon;
+  }
+
+  toArray(): [number, number] {
+    return [this.x, this.y];
+  }
+}

package/src/Vector3.ts

@@ -0,0 +1,101 @@
+import type { Matrix4 } from "./Matrix4.js";
+import type { Quaternion } from "./Quaternion.js";
+
+export class Vector3 {
+  static readonly zero = Object.freeze(new Vector3(0, 0, 0));
+  static readonly one = Object.freeze(new Vector3(1, 1, 1));
+  static readonly up = Object.freeze(new Vector3(0, 1, 0));
+  static readonly right = Object.freeze(new Vector3(1, 0, 0));
+  static readonly forward = Object.freeze(new Vector3(0, 0, -1));
+
+  constructor(
+    readonly x = 0,
+    readonly y = 0,
+    readonly z = 0
+  ) {}
+
+  clone(): Vector3 {
+    return new Vector3(this.x, this.y, this.z);
+  }
+
+  add(v: Vector3): Vector3 {
+    return new Vector3(this.x + v.x, this.y + v.y, this.z + v.z);
+  }
+
+  subtract(v: Vector3): Vector3 {
+    return new Vector3(this.x - v.x, this.y - v.y, this.z - v.z);
+  }
+
+  multiplyScalar(scalar: number): Vector3 {
+    return new Vector3(this.x * scalar, this.y * scalar, this.z * scalar);
+  }
+
+  multiply(v: Vector3): Vector3 {
+    return new Vector3(this.x * v.x, this.y * v.y, this.z * v.z);
+  }
+
+  divide(v: Vector3): Vector3 {
+    return new Vector3(this.x / v.x, this.y / v.y, this.z / v.z);
+  }
+
+  divideScalar(scalar: number): Vector3 {
+    return new Vector3(this.x / scalar, this.y / scalar, this.z / scalar);
+  }
+
+  dot(v: Vector3): number {
+    return this.x * v.x + this.y * v.y + this.z * v.z;
+  }
+
+  cross(v: Vector3): Vector3 {
+    return new Vector3(
+      this.y * v.z - this.z * v.y,
+      this.z * v.x - this.x * v.z,
+      this.x * v.y - this.y * v.x
+    );
+  }
+
+  lengthSquared(): number {
+    return this.dot(this);
+  }
+
+  length(): number {
+    return Math.hypot(this.x, this.y, this.z);
+  }
+
+  normalize(): Vector3 {
+    const len = this.length();
+    return len === 0 ? Vector3.zero.clone() : this.multiplyScalar(1 / len);
+  }
+
+  distanceTo(v: Vector3): number {
+    return this.subtract(v).length();
+  }
+
+  lerp(v: Vector3, t: number): Vector3 {
+    return new Vector3(this.x + (v.x - this.x) * t, this.y + (v.y - this.y) * t, this.z + (v.z - this.z) * t);
+  }
+
+  transformMatrix4(matrix: Matrix4): Vector3 {
+    return matrix.transformPoint(this);
+  }
+
+  rotateByQuaternion(rotation: Quaternion): Vector3 {
+    return rotation.rotateVector(this);
+  }
+
+  min(v: Vector3): Vector3 {
+    return new Vector3(Math.min(this.x, v.x), Math.min(this.y, v.y), Math.min(this.z, v.z));
+  }
+
+  max(v: Vector3): Vector3 {
+    return new Vector3(Math.max(this.x, v.x), Math.max(this.y, v.y), Math.max(this.z, v.z));
+  }
+
+  equals(v: Vector3, epsilon = 1e-10): boolean {
+    return Math.abs(this.x - v.x) <= epsilon && Math.abs(this.y - v.y) <= epsilon && Math.abs(this.z - v.z) <= epsilon;
+  }
+
+  toArray(): [number, number, number] {
+    return [this.x, this.y, this.z];
+  }
+}

package/src/Vector4.ts

@@ -0,0 +1,55 @@
+import type { Matrix4 } from "./Matrix4.js";
+
+export class Vector4 {
+  constructor(
+    readonly x = 0,
+    readonly y = 0,
+    readonly z = 0,
+    readonly w = 0
+  ) {}
+
+  add(v: Vector4): Vector4 {
+    return new Vector4(this.x + v.x, this.y + v.y, this.z + v.z, this.w + v.w);
+  }
+
+  subtract(v: Vector4): Vector4 {
+    return new Vector4(this.x - v.x, this.y - v.y, this.z - v.z, this.w - v.w);
+  }
+
+  multiplyScalar(scalar: number): Vector4 {
+    return new Vector4(this.x * scalar, this.y * scalar, this.z * scalar, this.w * scalar);
+  }
+
+  divide(v: Vector4): Vector4 {
+    return new Vector4(this.x / v.x, this.y / v.y, this.z / v.z, this.w / v.w);
+  }
+
+  divideScalar(scalar: number): Vector4 {
+    return new Vector4(this.x / scalar, this.y / scalar, this.z / scalar, this.w / scalar);
+  }
+
+  dot(v: Vector4): number {
+    return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
+  }
+
+  lerp(v: Vector4, t: number): Vector4 {
+    return new Vector4(
+      this.x + (v.x - this.x) * t,
+      this.y + (v.y - this.y) * t,
+      this.z + (v.z - this.z) * t,
+      this.w + (v.w - this.w) * t
+    );
+  }
+
+  transformMatrix4(matrix: Matrix4): Vector4 {
+    return matrix.transformVector4(this);
+  }
+
+  equals(v: Vector4, epsilon = 1e-10): boolean {
+    return Math.abs(this.x - v.x) <= epsilon && Math.abs(this.y - v.y) <= epsilon && Math.abs(this.z - v.z) <= epsilon && Math.abs(this.w - v.w) <= epsilon;
+  }
+
+  toArray(): [number, number, number, number] {
+    return [this.x, this.y, this.z, this.w];
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+export * from "./Vector2.js";
+export * from "./Vector3.js";
+export * from "./Vector4.js";
+export * from "./Matrix3.js";
+export * from "./Matrix4.js";
+export * from "./Quaternion.js";
+export * from "./Euler.js";
+export * from "./Color.js";
+export * from "./Ray.js";
+export * from "./Plane.js";
+export * from "./Box3.js";
+export * from "./Sphere.js";
+export * from "./Frustum.js";
+export * from "./Transform.js";
+export * from "./Interpolation.js";
+export * from "./Easing.js";
+export * from "./Random.js";
+export * from "./Curves.js";