@fimbul-works/vec 1.0.3 → 2.0.0

package/dist/{vec3.js → esm/vec3.js}

@@ -1,3 +1,7 @@
+/**
+ * Documentation for 3D Vector class.
+ * @module Vec3
+ */
 const { sin, cos, acos, atan2, sqrt, abs } = Math;
 /**
  * Represents a 3D vector with various operations.
@@ -9,9 +13,10 @@ export class Vec3 {
     /**
      * Computes and updates the magnitude of the vector.
      * @private
-     * @param x - The x-component of the vector.
-     * @param y - The y-component of the vector.
-     * @param z - The z-component of the vector.
+     * @param {number} x - The x-component of the vector.
+     * @param {number} y - The y-component of the vector.
+     * @param {number} z - The z-component of the vector.
+     * @returns {void}
      */
     #computeMagnitude(x = this.#xyz[0], y = this.#xyz[1], z = this.#xyz[2]) {
         if (x !== this.#prevXYZ[0] || y !== this.#prevXYZ[1] || z !== this.#prevXYZ[2]) {
@@ -23,9 +28,9 @@ export class Vec3 {
     }
     /**
      * Creates a new Vec3 instance.
-     * @param x - The x-coordinate of the vector.
-     * @param y - The y-coordinate of the vector.
-     * @param z - The z-coordinate of the vector.
+     * @param {number} x - The x-coordinate of the vector.
+     * @param {number} y - The y-coordinate of the vector.
+     * @param {number} z - The z-coordinate of the vector.
      */
     constructor(x = 0, y = 0, z = 0) {
         this.#xyz[0] = x;
@@ -35,18 +40,18 @@ export class Vec3 {
     }
     /**
      * Adds two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns A new Vec3 instance representing the sum.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {Vec3} A new Vec3 instance representing the sum.
      */
     static add(v, w) {
         return new Vec3(v.#xyz[0] + w.#xyz[0], v.#xyz[1] + w.#xyz[1], v.#xyz[2] + w.#xyz[2]);
     }
     /**
      * Subtracts one vector from another.
-     * @param v - The vector to subtract from.
-     * @param w - The vector to subtract.
-     * @returns A new Vec2 instance representing the difference.
+     * @param {Vec3} v - The vector to subtract from.
+     * @param {Vec3} w - The vector to subtract.
+     * @returns {Vec3} A new Vec3 instance representing the difference.
      */
     static subtract(v, w) {
         return new Vec3(v.#xyz[0] - w.#xyz[0], v.#xyz[1] - w.#xyz[1], v.#xyz[2] - w.#xyz[2]);
@@ -71,18 +76,18 @@ export class Vec3 {
     }
     /**
      * Calculates the angle between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The angle between the vectors in radians.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {number} The angle between the vectors in radians.
      */
     static angleBetween(v, w) {
         return acos((v.#xyz[0] * w.#xyz[0] + v.#xyz[1] * w.#xyz[1] + v.#xyz[2] * w.#xyz[2]) / (v.#magnitude * w.#magnitude));
     }
     /**
      * Calculates the cross product of two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The cross product of the two vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {Vec3} The cross product of the two vectors.
      */
     static cross(v, w) {
         const vX = v.#xyz[0];
@@ -107,18 +112,18 @@ export class Vec3 {
     }
     /**
      * Calculates the Euclidean distance between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The distance between the vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {number} The distance between the vectors.
      */
     static distance(v, w) {
         return sqrt((v.#xyz[0] - w.#xyz[0]) ** 2 + (v.#xyz[1] - w.#xyz[1]) ** 2 + (v.#xyz[2] - w.#xyz[2]) ** 2);
     }
     /**
      * Calculates the Chebyshev distance between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The Chebyshev distance between the vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {number} The Chebyshev distance between the vectors.
      */
     static distanceChebyshev(v, w) {
         const absX = abs(v.#xyz[0] - w.#xyz[0]);
@@ -128,66 +133,67 @@ export class Vec3 {
     }
     /**
      * Calculates the Manhattan distance between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The Manhattan distance between the vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {number} The Manhattan distance between the vectors.
      */
     static distanceManhattan(v, w) {
         return abs(v.#xyz[0] - w.#xyz[0]) + abs(v.#xyz[1] - w.#xyz[1]) + abs(v.#xyz[2] - w.#xyz[2]);
     }
     /**
      * Calculates the Minkowski distance between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @param p - The order of the Minkowski distance.
-     * @returns The Minkowski distance between the vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @param {number} p - The order of the Minkowski distance.
+     * @returns {number} The Minkowski distance between the vectors.
      */
     static distanceMinkowski(v, w, p) {
         return ((abs(v.#xyz[0] - w.#xyz[0]) ** p + abs(v.#xyz[1] - w.#xyz[1]) ** p + abs(v.#xyz[2] - w.#xyz[2]) ** p) ** (1 / p));
     }
     /**
      * Calculates the squared Euclidean distance between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The squared distance between the vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {number} The squared distance between the vectors.
      */
     static distanceSq(v, w) {
         return (v.#xyz[0] - w.#xyz[0]) ** 2 + (v.#xyz[1] - w.#xyz[1]) ** 2 + (v.#xyz[2] - w.#xyz[2]) ** 2;
     }
     /**
      * Calculates the dot product of two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns The dot product of the two vectors.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {number} The dot product of the two vectors.
      */
     static dot(v, w) {
         return v.#xyz[0] * w.#xyz[0] + v.#xyz[1] * w.#xyz[1] + v.#xyz[2] * w.#xyz[2];
     }
     /**
      * Creates a Vec3 from cylindrical coordinates.
-     * @param r - Radial distance from the z-axis
-     * @param phi - Azimuthal angle in the x-y plane from the x-axis
-     * @param z - Height above the x-y plane
-     * @returns New Vec3 instance
+     * @param {number} r - Radial distance from the z-axis
+     * @param {number} phi - Azimuthal angle in the x-y plane from the x-axis
+     * @param {number} z - Height above the x-y plane
+     * @returns {Vec3} New Vec3 instance
      */
     static fromCylindricalCoords(r, phi, z) {
         return new Vec3(r * cos(phi), r * sin(phi), z);
     }
     /**
      * Creates a Vec3 from spherical coordinates.
-     * @param r - Radial distance from origin
-     * @param theta - Polar angle from the z-axis
-     * @param phi - Azimuthal angle in the x-y plane from the x-axis
-     * @returns New Vec3 instance
+     * @param {number} r - Radial distance from origin
+     * @param {number} theta - Polar angle from the z-axis
+     * @param {number} phi - Azimuthal angle in the x-y plane from the x-axis
+     * @returns {Vec3} New Vec3 instance
      */
     static fromSphericalCoords(r, theta, phi) {
         return new Vec3(r * sin(theta) * cos(phi), r * sin(theta) * sin(phi), r * cos(theta));
     }
     /**
      * Creates an immutable Vec3-like object.
-     * @param x - The x-coordinate of the vector.
-     * @param y - The y-coordinate of the vector.
-     * @returns An immutable object with Vec3-like properties.
+     * @param {number} x - The x-coordinate of the vector.
+     * @param {number} y - The y-coordinate of the vector.
+     * @param {number} z - The z-coordinate of the vector.
+     * @returns {Readonly<{ x: number; y: number; z: number; xyz: readonly number[]; r: number; g: number; b: number; rgb: readonly number[]; magnitude: number; magnitudeSq: number; angleX: number; angleY: number; angleZ: number; isInfinite: boolean; isNaN: boolean; isZero: boolean }>} An immutable object with Vec3-like properties.
      */
     static immutable(x = 0, y = 0, z = 0) {
         const data = new Float64Array(10);
@@ -223,6 +229,18 @@ export class Vec3 {
             get xyz() {
                 return xyz;
             },
+            get r() {
+                return data[0];
+            },
+            get g() {
+                return data[1];
+            },
+            get b() {
+                return data[2];
+            },
+            get rgb() {
+                return xyz;
+            },
             get magnitude() {
                 return data[8];
             },
@@ -251,8 +269,8 @@ export class Vec3 {
     }
     /**
      * Checks if a vector has infinite components.
-     * @param v - The vector to check.
-     * @returns True if the vector has infinite components, false otherwise.
+     * @param {Vec3} v - The vector to check.
+     * @returns {boolean} True if the vector has infinite components, false otherwise.
      */
     static isInfinite(v) {
         const x = v.#xyz[0];
@@ -267,26 +285,26 @@ export class Vec3 {
     }
     /**
      * Checks if a vector has NaN components.
-     * @param v - The vector to check.
-     * @returns True if the vector has NaN components, false otherwise.
+     * @param {Vec3} v - The vector to check.
+     * @returns {boolean} True if the vector has NaN components, false otherwise.
      */
     static isNaN(v) {
         return Number.isNaN(v.#xyz[0]) || Number.isNaN(v.#xyz[1]) || Number.isNaN(v.#xyz[2]);
     }
     /**
      * Checks if a vector is zero.
-     * @param v - The vector to check.
-     * @returns True if the vector is zero, false otherwise.
+     * @param {Vec3} v - The vector to check.
+     * @returns {boolean} True if the vector is zero, false otherwise.
      */
     static isZero(v) {
         return v.#xyz[0] === 0 && v.#xyz[1] === 0 && v.#xyz[2] === 0;
     }
     /**
      * Performs linear interpolation between two vectors.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @param t - The interpolation parameter (0 to 1).
-     * @returns A new Vec2 instance representing the interpolated vector.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @param {number} t - The interpolation parameter (0 to 1).
+     * @returns {Vec3} A new Vec3 instance representing the interpolated vector.
      */
     static lerp(v, w, t) {
         if (t > 1)
@@ -300,16 +318,16 @@ export class Vec3 {
     }
     /**
      * Negates a vector.
-     * @param v - The vector to negate.
-     * @returns A new Vec2 instance representing the negated vector.
+     * @param {Vec3} v - The vector to negate.
+     * @returns {Vec3} A new Vec3 instance representing the negated vector.
      */
     static negate(v) {
         return new Vec3(-v.#xyz[0], -v.#xyz[1], -v.#xyz[2]);
     }
     /**
      * Normalizes a vector.
-     * @param v - The vector to normalize.
-     * @returns A new Vec2 instance representing the normalized vector.
+     * @param {Vec3} v - The vector to normalize.
+     * @returns {Vec3} A new Vec3 instance representing the normalized vector.
      */
     static normalize(v) {
         const m = v.#magnitude;
@@ -317,9 +335,9 @@ export class Vec3 {
     }
     /**
      * Projects one vector onto another.
-     * @param v - The vector to project.
-     * @param w - The vector to project onto.
-     * @returns A new Vec2 instance representing the projected vector.
+     * @param {Vec3} v - The vector to project.
+     * @param {Vec3} w - The vector to project onto.
+     * @returns {Vec3} A new Vec3 instance representing the projected vector.
      */
     static project(v, w) {
         const vM = v.#magnitude;
@@ -332,33 +350,26 @@ export class Vec3 {
     }
     /**
      * Creates a random unit vector.
-     * @param random - A function that returns a random number between 0 and 1.
-     * @returns A new Vec3 instance representing a random unit vector.
+     * @param {() => number} random - A function that returns a random number between 0 and 1.
+     * @returns {Vec3} A new Vec3 instance representing a random unit vector.
      */
     static random(random = Math.random) {
-        let x1;
-        let x2;
-        do {
-            x1 = random() * 2 - 1;
-            x2 = random() * 2 - 1;
-        } while (x1 ** 2 + x2 ** 2 >= 1);
-        const f = sqrt(1 - x1 ** 2 - x2 ** 2);
-        return new Vec3(2 * x1 * f, 2 * x2 * f, 1 - 2 * (x1 ** 2 + x2 ** 2));
+        return Vec3.fromSphericalCoords(Math.acos(2 * random() - 1), random() * Math.PI * 2, 1);
     }
     /**
      * Checks if two vectors are equal.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns True if the vectors are equal, false otherwise.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {boolean} True if the vectors are equal, false otherwise.
      */
     static satisfyEquality(v, w) {
         return v.#xyz[0] === w.#xyz[0] && v.#xyz[1] === w.#xyz[1] && v.#xyz[2] === w.#xyz[2];
     }
     /**
      * Checks if two vectors are opposite.
-     * @param v - The first vector.
-     * @param w - The second vector.
-     * @returns True if the vectors are opposite, false otherwise.
+     * @param {Vec3} v - The first vector.
+     * @param {Vec3} w - The second vector.
+     * @returns {boolean} True if the vectors are opposite, false otherwise.
      */
     static satisfyOpposition(v, w) {
         return v.#xyz[0] === -w.#xyz[0] && v.#xyz[1] === -w.#xyz[1] && v.#xyz[2] === -w.#xyz[2];
@@ -377,16 +388,16 @@ export class Vec3 {
     }
     /**
      * Scales a vector by a scalar value.
-     * @param v - The vector to scale.
-     * @param c - The scalar value.
-     * @returns A new Vec3 instance representing the scaled vector.
+     * @param {Vec3} v - The vector to scale.
+     * @param {number} c - The scalar value.
+     * @returns {Vec3} A new Vec3 instance representing the scaled vector.
      */
     static scale(v, c) {
         return new Vec3(v.#xyz[0] * c, v.#xyz[1] * c, v.#xyz[2] * c);
     }
     /**
      * Creates a zero vector.
-     * @returns A new Vec3 instance representing a zero vector.
+     * @returns {Vec3} A new Vec3 instance representing a zero vector.
      */
     static zero() {
         return new Vec3();
@@ -400,14 +411,16 @@ export class Vec3 {
     }
     /**
      * Creates a Vec3 from an array.
-     * @returns A new Vec3 instance.
+     * @param {[number, number, number] | number[]} arr - An array containing the x, y, and z coordinates.
+     * @returns {Vec3} A new Vec3 instance.
      */
     static fromArray(arr) {
         return new Vec3(arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0);
     }
     /**
      * Creates a Vec3 from an object with x, y and z properties.
-     * @returns A new Vec3 instance.
+     * @param {{ x: number; y: number; z: number }} obj - An object with x, y, and z properties.
+     * @returns {Vec3} A new Vec3 instance.
      */
     static fromObject(obj) {
         return new Vec3(obj.x, obj.y, obj.z);
@@ -422,14 +435,15 @@ export class Vec3 {
     }
     /**
      * Gets the x-component of the vector.
-     * @returns The x-component.
+     * @returns {number} The x-component.
      */
     get x() {
         return this.#xyz[0];
     }
     /**
      * Sets the x-component of the vector.
-     * @param x - The new x-component.
+     * @param {number} x - The new x-component.
+     * @returns {void}
      */
     set x(x) {
         this.#xyz[0] = x;
@@ -437,14 +451,15 @@ export class Vec3 {
     }
     /**
      * Gets the y-component of the vector.
-     * @returns The y-component.
+     * @returns {number} The y-component.
      */
     get y() {
         return this.#xyz[1];
     }
     /**
      * Sets the y-component of the vector.
-     * @param y - The new y-component.
+     * @param {number} y - The new y-component.
+     * @returns {void}
      */
     set y(y) {
         this.#xyz[1] = y;
@@ -452,14 +467,15 @@ export class Vec3 {
     }
     /**
      * Gets the z-component of the vector.
-     * @returns The z-component.
+     * @returns {number} The z-component.
      */
     get z() {
         return this.#xyz[2];
     }
     /**
      * Sets the z-component of the vector.
-     * @param z - The new z-component.
+     * @param {number} z - The new z-component.
+     * @returns {void}
      */
     set z(z) {
         this.#xyz[2] = z;
@@ -467,14 +483,15 @@ export class Vec3 {
     }
     /**
      * Gets a copy of the vector's components as an array.
-     * @returns An array containing the x, y and z components of the vector.
+     * @returns {[number, number, number]} An array containing the x, y and z components of the vector.
      */
     get xyz() {
         return Array.from(this.#xyz.slice());
     }
     /**
-     * Sets both components of the vector at once.
-     * @param xyz - An array containing the new x, y and z components.
+     * Sets all components of the vector at once.
+     * @param {[number, number, number]} xyz - An array containing the new x, y and z components.
+     * @returns {void}
      */
     set xyz(xyz) {
         this.#xyz[0] = xyz[0];
@@ -482,6 +499,66 @@ export class Vec3 {
         this.#xyz[2] = xyz[2];
         this.#computeMagnitude();
     }
+    /**
+     * Gets the Red-component of a Color.
+     * @returns {number} The Red-component.
+     */
+    get r() {
+        return this.x;
+    }
+    /**
+     * Sets the Red-component of a Color.
+     * @param {number} r - The new Red-component.
+     * @returns {void}
+     */
+    set r(r) {
+        this.x = r;
+    }
+    /**
+     * Gets the Green-component of a Color.
+     * @returns {number} The Green-component.
+     */
+    get g() {
+        return this.y;
+    }
+    /**
+     * Sets the Green-component of the Color.
+     * @param {number} g - The new Green-component.
+     * @returns {void}
+     */
+    set g(g) {
+        this.y = g;
+    }
+    /**
+     * Gets the Blue-component of the color.
+     * @returns {number} The Blue-component.
+     */
+    get b() {
+        return this.z;
+    }
+    /**
+     * Sets the Blue-component of the Color.
+     * @param {number} b - The new Blue-component.
+     * @returns {void}
+     */
+    set b(b) {
+        this.z = b;
+    }
+    /**
+     * Gets a copy of the vector's components as an array.
+     * @returns {[number, number, number]} An array containing the x, y and z components of the vector.
+     */
+    get rgb() {
+        return this.xyz;
+    }
+    /**
+     * Sets all components of the Color at once.
+     * @param {[number, number, number]} rgb - An array containing the new Red, Green and Blue components.
+     * @returns {void}
+     */
+    set rgb(rgb) {
+        this.xyz = rgb;
+    }
     /**
      * Gets the angle between the vector and the positive x-axis in radians.
      * @returns The angle in radians, always in the range [0, 2π).
@@ -531,8 +608,8 @@ export class Vec3 {
     }
     /**
      * Adds another vector to this vector.
-     * @param v - The vector to add.
-     * @returns This Vec3 instance for method chaining.
+     * @param {Vec3} v - The vector to add.
+     * @returns {this} This Vec3 instance for method chaining.
      */
     add(v) {
         this.#xyz[0] += v.#xyz[0];
@@ -610,7 +687,7 @@ export class Vec3 {
     }
     /**
      * Creates a copy of this vector.
-     * @returns A new Vec3 instance with the same components.
+     * @returns {Vec3} A new Vec3 instance with the same components.
      */
     clone() {
         return new Vec3(this.#xyz[0], this.#xyz[1], this.#xyz[2]);
@@ -629,16 +706,16 @@ export class Vec3 {
     }
     /**
      * Calculates the dot product of this vector with another vector.
-     * @param v - The other vector.
-     * @returns The dot product of the vectors.
+     * @param {Vec3} v - The other vector.
+     * @returns {number} The dot product of the vectors.
      */
     dot(v) {
         return this.#xyz[0] * v.#xyz[0] + this.#xyz[1] * v.#xyz[1] + this.#xyz[2] * v.#xyz[2];
     }
     /**
      * Calculates cross product between this vector and another vector.
-     * @param v - The other vector.
-     * @returns The distance between the vectors.
+     * @param {Vec3} v - The other vector.
+     * @returns {this} This Vec3 instance for method chaining.
      */
     cross(v) {
         const x = this.#xyz[0];
@@ -677,8 +754,8 @@ export class Vec3 {
     }
     /**
      * Calculates the Chebyshev distance between vector and another vector.
-     * @param v - The other vector.
-     * @returns The Chebyshev distance between the vectors.
+     * @param {Vec3} v - The other vector.
+     * @returns {number} The Chebyshev distance between the vectors.
      */
     distanceChebyshev(v) {
         const absX = abs(this.#xyz[0] - v.#xyz[0]);
@@ -688,17 +765,17 @@ export class Vec3 {
     }
     /**
      * Calculates the Manhattan distance between vector and another vector.
-     * @param v - The other vector.
-     * @returns The Manhattan distance between the vectors.
+     * @param {Vec3} v - The other vector.
+     * @returns {number} The Manhattan distance between the vectors.
      */
     distanceManhattan(v) {
         return abs(this.#xyz[0] - v.#xyz[0]) + abs(this.#xyz[1] - v.#xyz[1]) + abs(this.#xyz[2] - v.#xyz[2]);
     }
     /**
      * Calculates the Minkowski distance between this vector and another vector.
-     * @param v - The other vector.
-     * @param p - The order of the Minkowski distance.
-     * @returns The Minkowski distance between the vectors.
+     * @param {Vec3} v - The other vector.
+     * @param {number} p - The order of the Minkowski distance.
+     * @returns {number} The Minkowski distance between the vectors.
      */
     distanceMinkowski(v, p) {
         return ((abs(this.#xyz[0] - v.#xyz[0]) ** p + abs(this.#xyz[1] - v.#xyz[1]) ** p + abs(this.#xyz[2] - v.#xyz[2]) ** p) **
@@ -832,18 +909,7 @@ export class Vec3 {
      * @returns This Vec3 instance for method chaining.
      */
     random(random = Math.random) {
-        let x1;
-        let x2;
-        do {
-            x1 = random() * 2 - 1;
-            x2 = random() * 2 - 1;
-        } while (x1 ** 2 + x2 ** 2 >= 1);
-        const f = sqrt(1 - x1 ** 2 - x2 ** 2);
-        const m = this.#magnitude;
-        this.#xyz[0] = m * 2 * x1 * f;
-        this.#xyz[1] = m * 2 * x2 * f;
-        this.#xyz[2] = m * (1 - 2 * (x1 ** 2 + x2 ** 2));
-        this.#computeMagnitude();
+        this.copy(Vec3.fromSphericalCoords(Math.acos(2 * random() - 1), random() * Math.PI * 2, 1));
         return this;
     }
     /**
@@ -962,7 +1028,8 @@ export class Vec3 {
      * @returns An object with x, y and z properties.
      */
     toObject() {
-        return { x: this.#xyz[0], y: this.#xyz[1], z: this.#xyz[2] };
+        const [x, y, z] = this.#xyz;
+        return { x, y, z };
     }
     /**
      * Serializes the vector to a JSON-friendly format.