@lakuna/umath 1.3.4 → 1.3.6

package/dist/linalg/Vector3.js

@@ -1,16 +1,34 @@
-import Quaternion, {} from "#Quaternion";
-import { normalize as normalizeVector4 } from "#Vector4";
-import epsilon from "#epsilon";
-export function createVector3Like() {
+import Quaternion, {} from "./Quaternion.js";
+import epsilon from "../utility/epsilon.js";
+import { normalize as normalizeVector4 } from "./Vector4.js";
+/**
+ * Creates a 3x1 vector-like object.
+ * @returns A 3x1 vector-like object.
+ */
+export const createVector3Like = () => {
     return new Float32Array(3);
-}
-export function fromValues(x, y, z, out) {
+};
+/**
+ * Create a vector with the given values.
+ * @param x - The first component.
+ * @param y - The second component.
+ * @param z - The third component.
+ * @param out - The vector to store the result in.
+ * @returns A new vector.
+ */
+export const fromValues = (x, y, z, out) => {
     out[0] = x;
     out[1] = y;
     out[2] = z;
     return out;
-}
-export function equals(a, b) {
+};
+/**
+ * Determine whether or not two vectors are roughly equivalent.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @returns Whether or not the vectors are equivalent.
+ */
+export const equals = (a, b) => {
     const a0 = a[0];
     const a1 = a[1];
     const a2 = a[2];
@@ -20,119 +38,249 @@ export function equals(a, b) {
     return (Math.abs(a0 - b0) <= epsilon * Math.max(1, Math.abs(a0), Math.abs(b0)) &&
         Math.abs(a1 - b1) <= epsilon * Math.max(1, Math.abs(a1), Math.abs(b1)) &&
         Math.abs(a2 - b2) <= epsilon * Math.max(1, Math.abs(a2), Math.abs(b2)));
-}
-export function exactEquals(a, b) {
-    return a[0] == b[0] && a[1] == b[1] && a[2] == b[2];
-}
-export function add(a, b, out) {
+};
+/**
+ * Determine whether two vectors are exactly equivalent.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @returns Whether the vectors are equivalent.
+ */
+export const exactEquals = (a, b) => {
+    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
+};
+/**
+ * Add two vectors.
+ * @param a - The augend.
+ * @param b - The addend.
+ * @param out - The vector to store the result in.
+ * @returns The sum.
+ */
+export const add = (a, b, out) => {
     out[0] = a[0] + b[0];
     out[1] = a[1] + b[1];
     out[2] = a[2] + b[2];
     return out;
-}
-export function copy(vector, out) {
+};
+/**
+ * Copy the values from one vector to another.
+ * @param vector - The vector to copy.
+ * @param out - The vector to store the result in.
+ * @returns The copy.
+ */
+export const copy = (vector, out) => {
     out[0] = vector[0];
     out[1] = vector[1];
     out[2] = vector[2];
     return out;
-}
-export function multiply(a, b, out) {
+};
+/**
+ * Multiply two vectors.
+ * @param a - The multiplier.
+ * @param b - The multiplicand.
+ * @param out - The vector to store the result in.
+ * @returns The product.
+ */
+export const multiply = (a, b, out) => {
     out[0] = a[0] * b[0];
     out[1] = a[1] * b[1];
     out[2] = a[2] * b[2];
     return out;
-}
-export function divide(a, b, out) {
+};
+/**
+ * Divide two vectors.
+ * @param a - The dividend.
+ * @param b - The divisor.
+ * @param out - The vector to store the result in.
+ * @returns The quotient.
+ */
+export const divide = (a, b, out) => {
     out[0] = a[0] / b[0];
     out[1] = a[1] / b[1];
     out[2] = a[2] / b[2];
     return out;
-}
-export function subtract(a, b, out) {
+};
+/**
+ * Subtract two vectors.
+ * @param a - The minuend.
+ * @param b - The subtrahend.
+ * @param out - The vector to store the result in.
+ * @returns The difference.
+ */
+export const subtract = (a, b, out) => {
     out[0] = a[0] - b[0];
     out[1] = a[1] - b[1];
     out[2] = a[2] - b[2];
     return out;
-}
-export function ceil(vector, out) {
+};
+/**
+ * Round up the components of a vector.
+ * @param vector - The vector.
+ * @param out - The vector to store the result in.
+ * @returns The rounded vector.
+ */
+export const ceil = (vector, out) => {
     out[0] = Math.ceil(vector[0]);
     out[1] = Math.ceil(vector[1]);
     out[2] = Math.ceil(vector[2]);
     return out;
-}
-export function floor(vector, out) {
+};
+/**
+ * Round down the components of a vector.
+ * @param vector - The vector.
+ * @param out - The vector to store the result in.
+ * @returns The rounded vector.
+ */
+export const floor = (vector, out) => {
     out[0] = Math.floor(vector[0]);
     out[1] = Math.floor(vector[1]);
     out[2] = Math.floor(vector[2]);
     return out;
-}
-export function round(vector, out) {
+};
+/**
+ * Round the components of a vector.
+ * @param vector - The vector.
+ * @param out - The vector to store the result in.
+ * @returns The rounded vector.
+ */
+export const round = (vector, out) => {
     out[0] = Math.round(vector[0]);
     out[1] = Math.round(vector[1]);
     out[2] = Math.round(vector[2]);
     return out;
-}
-export function min(a, b, out) {
+};
+/**
+ * Return the minimum of two vectors.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @param out - The vector to store the result in.
+ * @returns The minimum.
+ */
+export const min = (a, b, out) => {
     out[0] = Math.min(a[0], b[0]);
     out[1] = Math.min(a[1], b[1]);
     out[2] = Math.min(a[2], b[2]);
     return out;
-}
-export function max(a, b, out) {
+};
+/**
+ * Return the maximum of two vectors.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @param out - The vector to store the result in.
+ * @returns The maximum.
+ */
+export const max = (a, b, out) => {
     out[0] = Math.max(a[0], b[0]);
     out[1] = Math.max(a[1], b[1]);
     out[2] = Math.max(a[2], b[2]);
     return out;
-}
-export function scale(vector, scalar, out) {
+};
+/**
+ * Scale a vector by a scalar.
+ * @param vector - The multiplier.
+ * @param scalar - The multiplicand.
+ * @param out - The vector to store the result in.
+ * @returns The product.
+ */
+export const scale = (vector, scalar, out) => {
     out[0] = vector[0] * scalar;
     out[1] = vector[1] * scalar;
     out[2] = vector[2] * scalar;
     return out;
-}
-export function scaleAndAdd(a, b, scalar, out) {
+};
+/**
+ * Add two vectors after scaling the second by a scalar.
+ * @param a - The augend.
+ * @param b - The addend.
+ * @param scalar - The multiplicand.
+ * @param out - The vector to store the result in.
+ * @returns The sum.
+ */
+export const scaleAndAdd = (a, b, scalar, out) => {
     out[0] = a[0] + b[0] * scalar;
     out[1] = a[1] + b[1] * scalar;
     out[2] = a[2] + b[2] * scalar;
     return out;
-}
-export function distance(a, b) {
+};
+/**
+ * Calculate the Euclidean distance between two vectors.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @returns The distance.
+ * @see [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance)
+ */
+export const distance = (a, b) => {
     const x = b[0] - a[0];
     const y = b[1] - a[1];
     const z = b[2] - a[2];
     return Math.hypot(x, y, z);
-}
-export function squaredDistance(a, b) {
+};
+/**
+ * Calculate the squared Euclidean distance between this vector and another.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @returns The squared distance.
+ * @see [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance)
+ */
+export const squaredDistance = (a, b) => {
     const x = b[0] - a[0];
     const y = b[1] - a[1];
     const z = b[2] - a[2];
     return x * x + y * y + z * z;
-}
-export function getMagnitude(vector) {
+};
+/**
+ * Calculate the magnitude (length) of a vector.
+ * @param vector - The vector.
+ * @returns The magnitude.
+ */
+export const getMagnitude = (vector) => {
     const x = vector[0];
     const y = vector[1];
     const z = vector[2];
     return Math.hypot(x, y, z);
-}
-export function getSquaredMagnitude(vector) {
+};
+/**
+ * Calculate the squared magnitude (length) of a vector.
+ * @param vector - The vector.
+ * @returns The squared magnitude.
+ */
+export const getSquaredMagnitude = (vector) => {
     const x = vector[0];
     const y = vector[1];
     const z = vector[2];
     return x * x + y * y + z * z;
-}
-export function negate(vector, out) {
+};
+/**
+ * Negate a vector.
+ * @param vector - The vector.
+ * @param out - The vector to store the result in.
+ * @returns The negated vector.
+ */
+export const negate = (vector, out) => {
     out[0] = -vector[0];
     out[1] = -vector[1];
     out[2] = -vector[2];
     return out;
-}
-export function invert(vector, out) {
+};
+/**
+ * Calculate the multiplicative inverse of the components of a vector.
+ * @param vector - The vector.
+ * @param out - The vector to store the result in.
+ * @returns The inverted vector.
+ */
+export const invert = (vector, out) => {
     out[0] = 1 / vector[0];
     out[1] = 1 / vector[1];
     out[2] = 1 / vector[2];
     return out;
-}
-export function normalize(vector, out) {
+};
+/**
+ * Normalize a vector.
+ * @param vector - The vector.
+ * @param out - The vector to store the result in.
+ * @returns The normalized vector.
+ * @see [Unit vector](https://en.wikipedia.org/wiki/Unit_vector)
+ */
+export const normalize = (vector, out) => {
     const x = vector[0];
     const y = vector[1];
     const z = vector[2];
@@ -144,11 +292,26 @@ export function normalize(vector, out) {
     out[1] = y * len;
     out[2] = z * len;
     return out;
-}
-export function dot(a, b) {
+};
+/**
+ * Calculate the dot product of two vectors.
+ * @param a - The multiplier.
+ * @param b - The multiplicand.
+ * @returns The dot product.
+ * @see [Dot product](https://en.wikipedia.org/wiki/Dot_product)
+ */
+export const dot = (a, b) => {
     return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-export function cross(a, b, out) {
+};
+/**
+ * Calculate the cross product of two vectors.
+ * @param a - The multiplier.
+ * @param b - The mutliplicand.
+ * @param out - The vector to store the result in.
+ * @returns The cross product.
+ * @see [Cross product](https://en.wikipedia.org/wiki/Cross_product)
+ */
+export const cross = (a, b, out) => {
     const ax = a[0];
     const ay = a[1];
     const az = a[2];
@@ -159,8 +322,17 @@ export function cross(a, b, out) {
     out[1] = az * bx - ax * bz;
     out[2] = ax * by - ay * bx;
     return out;
-}
-export function lerp(a, b, t, out) {
+};
+/**
+ * Perform a linear interpolation between two vectors.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @param t - The interpolation amount (in `[0,1]`).
+ * @param out - The vector to store the result in.
+ * @returns The interpolated vector.
+ * @see [Linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation)
+ */
+export const lerp = (a, b, t, out) => {
     const ax = a[0];
     const ay = a[1];
     const az = a[2];
@@ -168,8 +340,14 @@ export function lerp(a, b, t, out) {
     out[1] = ay + t * (b[1] - ay);
     out[2] = az + t * (b[2] - az);
     return out;
-}
-export function random(magnitude, out) {
+};
+/**
+ * Set a vector to a random value with the given magnitude.
+ * @param magnitude - The magnitude.
+ * @param out - The vector to store the result in.
+ * @returns This vector.
+ */
+export const random = (magnitude, out) => {
     const r = Math.random() * 2 * Math.PI;
     const z = Math.random() * 2 - 1;
     const zScale = Math.sqrt(1 - z * z) * magnitude;
@@ -177,8 +355,16 @@ export function random(magnitude, out) {
     out[1] = Math.sin(r) * zScale;
     out[2] = z * magnitude;
     return out;
-}
-export function transformMatrix3(vector, matrix, out) {
+};
+/**
+ * Transform a vector by a three-by-three matrix.
+ * @param vector - The vector (multiplier).
+ * @param matrix - The matrix (multiplicand).
+ * @param out - The vector to store the result in.
+ * @returns The transformed vector.
+ * @see [Transformation matrix](https://en.wikipedia.org/wiki/Transformation_matrix)
+ */
+export const transformMatrix3 = (vector, matrix, out) => {
     const x = vector[0];
     const y = vector[1];
     const z = vector[2];
@@ -186,8 +372,16 @@ export function transformMatrix3(vector, matrix, out) {
     out[1] = x * matrix[1] + y * matrix[4] + z * matrix[7];
     out[2] = x * matrix[2] + y * matrix[5] + z * matrix[8];
     return out;
-}
-export function transformMatrix4(vector, matrix, out) {
+};
+/**
+ * Transform a vector by a four-by-four matrix.
+ * @param vector - The vector (multiplier).
+ * @param matrix - The matrix (multiplicand).
+ * @param out - The vector to store the result in.
+ * @returns The transformed vector.
+ * @see [Transformation matrix](https://en.wikipedia.org/wiki/Transformation_matrix)
+ */
+export const transformMatrix4 = (vector, matrix, out) => {
     const x = vector[0];
     const y = vector[1];
     const z = vector[2];
@@ -196,56 +390,71 @@ export function transformMatrix4(vector, matrix, out) {
     out[1] = (matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13]) / w;
     out[2] = (matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14]) / w;
     return out;
-}
-export function rotateX(vector, origin, radians, out) {
-    const p = [
-        vector[0] - origin[0],
-        vector[1] - origin[1],
-        vector[2] - origin[2]
-    ];
-    const r = [
-        p[0],
-        p[1] * Math.cos(radians) - p[2] * Math.sin(radians),
-        p[1] * Math.sin(radians) + p[2] * Math.cos(radians)
-    ];
-    out[0] = r[0] + origin[0];
-    out[1] = r[1] + origin[1];
-    out[2] = r[2] + origin[2];
+};
+/**
+ * Rotate a vector around the X-axis.
+ * @param vector - The vector.
+ * @param origin - The origin of the rotation.
+ * @param r - The angle of rotation in radians.
+ * @param out - The vector to store the result in.
+ * @returns The rotated vector.
+ */
+export const rotateX = (vector, origin, r, out) => {
+    const p0 = vector[0] - origin[0];
+    const p1 = vector[1] - origin[1];
+    const p2 = vector[2] - origin[2];
+    const r1 = p1 * Math.cos(r) - p2 * Math.sin(r);
+    const r2 = p1 * Math.sin(r) + p2 * Math.cos(r);
+    out[0] = p0 + origin[0];
+    out[1] = r1 + origin[1];
+    out[2] = r2 + origin[2];
     return out;
-}
-export function rotateY(vector, origin, radians, out) {
-    const p = [
-        vector[0] - origin[0],
-        vector[1] - origin[1],
-        vector[2] - origin[2]
-    ];
-    const r = [
-        p[2] * Math.sin(radians) + p[0] * Math.cos(radians),
-        p[1],
-        p[2] * Math.cos(radians) - p[0] * Math.sin(radians)
-    ];
-    out[0] = r[0] + origin[0];
-    out[1] = r[1] + origin[1];
-    out[2] = r[2] + origin[2];
+};
+/**
+ * Rotate a vector around the Y-axis.
+ * @param vector - The vector.
+ * @param origin - The origin of the rotation.
+ * @param r - The angle of rotation in radians.
+ * @param out - The vector to store the result in.
+ * @returns The rotated vector.
+ */
+export const rotateY = (vector, origin, r, out) => {
+    const p0 = vector[0] - origin[0];
+    const p1 = vector[1] - origin[1];
+    const p2 = vector[2] - origin[2];
+    const r0 = p2 * Math.sin(r) + p0 * Math.cos(r);
+    const r2 = p2 * Math.cos(r) - p0 * Math.sin(r);
+    out[0] = r0 + origin[0];
+    out[1] = p1 + origin[1];
+    out[2] = r2 + origin[2];
     return out;
-}
-export function rotateZ(vector, origin, radians, out) {
-    const p = [
-        vector[0] - origin[0],
-        vector[1] - origin[1],
-        vector[2] - origin[2]
-    ];
-    const r = [
-        p[0] * Math.cos(radians) - p[1] * Math.sin(radians),
-        p[0] * Math.sin(radians) + p[1] * Math.cos(radians),
-        p[2]
-    ];
-    out[0] = r[0] + origin[0];
-    out[1] = r[1] + origin[1];
-    out[2] = r[2] + origin[2];
+};
+/**
+ * Rotate a vector around the Z-axis.
+ * @param vector - The vector.
+ * @param origin - The origin of the rotation.
+ * @param r - The angle of rotation in radians.
+ * @param out - The vector to store the result in.
+ * @returns The rotated vector.
+ */
+export const rotateZ = (vector, origin, r, out) => {
+    const p0 = vector[0] - origin[0];
+    const p1 = vector[1] - origin[1];
+    const p2 = vector[2] - origin[2];
+    const r0 = p0 * Math.cos(r) - p1 * Math.sin(r);
+    const r1 = p0 * Math.sin(r) + p1 * Math.cos(r);
+    out[0] = r0 + origin[0];
+    out[1] = r1 + origin[1];
+    out[2] = p2 + origin[2];
     return out;
-}
-export function angle(a, b) {
+};
+/**
+ * Get the angle between two vectors in radians.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @returns The angular distance from the first vector to the second.
+ */
+export const angle = (a, b) => {
     const ax = a[0];
     const ay = a[1];
     const az = a[2];
@@ -257,14 +466,30 @@ export function angle(a, b) {
     const mag = mag1 * mag2;
     const cosine = mag && dot(a, b) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
-}
-export function zero(out) {
+};
+/**
+ * Set a vector to the zero vector.
+ * @param out - The vector to store the result in.
+ * @returns This vector.
+ */
+export const zero = (out) => {
     out[0] = 0;
     out[1] = 0;
     out[2] = 0;
     return out;
-}
-export function hermite(a, b, c, d, t, out) {
+};
+/**
+ * Perform a Hermite interpolation with two control points between two vectors.
+ * @param a - The first vector.
+ * @param b - The first control point.
+ * @param c - The second control point.
+ * @param d - The second vector.
+ * @param t - The interpolation amount in the range `[0,1]`.
+ * @param out - The vector to store the result in.
+ * @returns The interpolated vector.
+ * @see [Hermite interpolation](https://en.wikipedia.org/wiki/Hermite_interpolation)
+ */
+export const hermite = (a, b, c, d, t, out) => {
     const factorTimes2 = t * t;
     const factor1 = factorTimes2 * (2 * t - 3) + 1;
     const factor2 = factorTimes2 * (t - 2) + t;
@@ -274,21 +499,40 @@ export function hermite(a, b, c, d, t, out) {
     out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
     out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
     return out;
-}
-export function bezier(a, b, c, d, t, out) {
+};
+/**
+ * Perform a Bézier interpolation with two control points between two vectors.
+ * @param a - The first vector.
+ * @param b - The first control point.
+ * @param c - The second control point.
+ * @param d - The second vector.
+ * @param t - The interpolation amount in the range `[0,1]`.
+ * @param out - The vector to store the result in.
+ * @returns The interpolated vector.
+ * @see [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+ */
+export const bezier = (a, b, c, d, t, out) => {
     const inverseFactor = 1 - t;
     const inverseFactorTimesTwo = inverseFactor * inverseFactor;
-    const factorTimes2 = t * t;
+    const factorSq = t * t;
     const factor1 = inverseFactorTimesTwo * inverseFactor;
     const factor2 = 3 * t * inverseFactorTimesTwo;
-    const factor3 = 3 * factorTimes2 * inverseFactor;
-    const factor4 = factorTimes2 * t;
+    const factor3 = 3 * factorSq * inverseFactor;
+    const factor4 = factorSq * t;
     out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;
     out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;
     out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;
     return out;
-}
-export function transformQuaternion(vector, quaternion, out) {
+};
+/**
+ * Transform a vector by a quaternion.
+ * @param vector - The vector.
+ * @param quaternion - The quaternion.
+ * @param out - The vector to store the result in.
+ * @returns The transformed vector.
+ * @see [Quaternion](https://en.wikipedia.org/wiki/Quaternion)
+ */
+export const transformQuaternion = (vector, quaternion, out) => {
     const qx = quaternion[0];
     const qy = quaternion[1];
     const qz = quaternion[2];
@@ -313,11 +557,21 @@ export function transformQuaternion(vector, quaternion, out) {
     out[1] = y + uvy + uuvy;
     out[2] = z + uvz + uuvz;
     return out;
-}
-const xAxis = new Float32Array([1, 0, 0]);
-const yAxis = new Float32Array([0, 1, 0]);
-const intermediary = new Float32Array(3);
-export function rotationTo(a, b, out) {
+};
+// The unit three-dimensional vector that represents the X-axis.
+const xAxis = fromValues(1, 0, 0, createVector3Like());
+// The unit three-dimensional vector that represents the Y-axis.
+const yAxis = fromValues(0, 1, 0, createVector3Like());
+// Used to store intermediary values for some functions.
+const intermediary = createVector3Like();
+/**
+ * Create a quaternion that represents the shortest rotation from one unit vector to another.
+ * @param a - The first vector.
+ * @param b - The second vector.
+ * @param out - The quaternion to store the result in.
+ * @returns The quaternion.
+ */
+export const rotationTo = (a, b, out) => {
     const dp = dot(a, b);
     if (dp < epsilon - 1) {
         cross(xAxis, a, intermediary);
@@ -344,122 +598,359 @@ export function rotationTo(a, b, out) {
     out[2] = intermediary[2];
     out[3] = 1 + dp;
     return normalizeVector4(out, out);
-}
+};
+/**
+ * A quantity with magnitude and direction in three dimensions.
+ * @see [Euclidean vector](https://en.wikipedia.org/wiki/Euclidean_vector)
+ */
 export default class Vector3 extends Float32Array {
+    /**
+     * Create a vector with the given values.
+     * @param x - The first component.
+     * @param y - The second component.
+     * @param z - The third component.
+     * @param out - The vector to store the result in.
+     * @returns A new vector.
+     */
     static fromValues(x, y, z, out = new Vector3()) {
         return fromValues(x, y, z, out);
     }
+    /**
+     * Create a three-dimensional zero vector.
+     * @see [Euclidean vector](https://en.wikipedia.org/wiki/Euclidean_vector)
+     */
     constructor() {
         super(3);
     }
+    /** The first component of this vector. */
+    0;
+    /** The second component of this vector. */
+    1;
+    /** The third component of this vector. */
+    2;
+    /**
+     * Determine whether or not this vector is roughly equivalent to another.
+     * @param vector - The other vector.
+     * @returns Whether or not the vectors are equivalent.
+     */
     equals(vector) {
         return equals(this, vector);
     }
+    /**
+     * Determine whether or not this vector is exactly equivalent to another.
+     * @param vector - The other vector.
+     * @returns Whether or not the vectors are equivalent.
+     */
     exactEquals(vector) {
         return exactEquals(this, vector);
     }
+    /**
+     * Add two vectors of the same size.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The sum of the vectors.
+     */
     add(vector, out = new Vector3()) {
         return add(this, vector, out);
     }
+    /**
+     * Copy the values from this vector to another one.
+     * @param out - The vector to store the result in.
+     * @returns The copy.
+     */
     clone(out = new Vector3()) {
         return copy(this, out);
     }
+    /**
+     * Copy the values of another vector into this one.
+     * @param vector - The vector to copy.
+     * @returns This vector.
+     */
     copy(vector) {
         return copy(vector, this);
     }
+    /**
+     * Multiply this vector by another.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The product of the vectors.
+     */
     multiply(vector, out = new Vector3()) {
         return multiply(this, vector, out);
     }
+    /**
+     * Divide this vector by another.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The quotient of the vectors.
+     */
     divide(vector, out = new Vector3()) {
         return divide(this, vector, out);
     }
+    /**
+     * Subtract another vector from this one.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The difference between the vectors.
+     */
     subtract(vector, out = new Vector3()) {
         return subtract(this, vector, out);
     }
+    /**
+     * Round up the components of this vector.
+     * @param out - The vector to store the result in.
+     * @returns The rounded vector.
+     */
     ceil(out = new Vector3()) {
         return ceil(this, out);
     }
+    /**
+     * Round down the components of this vector.
+     * @param out - The vector to store the result in.
+     * @returns The rounded vector.
+     */
     floor(out = new Vector3()) {
         return floor(this, out);
     }
+    /**
+     * Round the components of this vector.
+     * @param out - The vector to store the result in.
+     * @returns The rounded vector.
+     */
     round(out = new Vector3()) {
         return round(this, out);
     }
+    /**
+     * Return the minimum of this and another vector.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The minimum.
+     */
     min(vector, out = new Vector3()) {
         return min(this, vector, out);
     }
+    /**
+     * Return the maximum of this and another vector.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The maximum.
+     */
     max(vector, out = new Vector3()) {
         return max(this, vector, out);
     }
+    /**
+     * Scale this vector by a scalar.
+     * @param scalar - The scalar.
+     * @param out - The vector to store the result in.
+     * @returns The scaled vector.
+     */
     scale(scalar, out = new Vector3()) {
         return scale(this, scalar, out);
     }
+    /**
+     * Add another vector to this one after scaling the other by a scalar.
+     * @param vector - The other vector.
+     * @param scalar - The scalar.
+     * @param out - The vector to store the result in.
+     * @returns The sum.
+     */
     scaleAndAdd(vector, scalar, out = new Vector3()) {
         return scaleAndAdd(this, vector, scalar, out);
     }
+    /**
+     * Calculate the Euclidean distance between this vector and another.
+     * @param vector - The other vector.
+     * @returns The distance.
+     * @see [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance)
+     */
     distance(vector) {
         return distance(this, vector);
     }
+    /**
+     * Calculate the squared Euclidean distance between this vector and another.
+     * @param vector - The other vector.
+     * @returns The squared distance.
+     * @see [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance)
+     */
     squaredDistance(vector) {
         return squaredDistance(this, vector);
     }
+    /** Get the magnitude (length) of this vector. */
     get magnitude() {
         return getMagnitude(this);
     }
+    /** Get the squared magnitude (length) of this vector. */
     get squaredMagnitude() {
         return getSquaredMagnitude(this);
     }
+    /**
+     * Negate this vector.
+     * @param out - The vector to store the result in.
+     * @returns The negated vector.
+     */
     negate(out = new Vector3()) {
         return negate(this, out);
     }
+    /**
+     * Calculate the multiplicative inverse of the components of this vector.
+     * @param out - The vector to store the result in.
+     * @returns The inverted vector.
+     */
     invert(out = new Vector3()) {
         return invert(this, out);
     }
+    /**
+     * Normalize this vector.
+     * @param out - The vector to store the result in.
+     * @returns The normalized vector.
+     * @see [Unit vector](https://en.wikipedia.org/wiki/Unit_vector)
+     */
     normalize(out = new Vector3()) {
         return normalize(this, out);
     }
+    /**
+     * Calculate the dot product of this and another vector.
+     * @param vector - The other vector.
+     * @returns The dot product.
+     * @see [Dot product](https://en.wikipedia.org/wiki/Dot_product)
+     */
     dot(vector) {
         return dot(this, vector);
     }
+    /**
+     * Calculate the cross product of this and another vector.
+     * @param vector - The other vector.
+     * @param out - The vector to store the result in.
+     * @returns The cross product.
+     * @see [Cross product](https://en.wikipedia.org/wiki/Cross_product)
+     */
     cross(vector, out = new Vector3()) {
         return cross(this, vector, out);
     }
+    /**
+     * Perform a linear interpolation between this and another vector.
+     * @param vector - The other vector.
+     * @param t - The interpolation amount (in `[0,1]`).
+     * @param out - The vector to store the result in.
+     * @returns The interpolated vector.
+     * @see [Linear interpolation](https://en.wikipedia.org/wiki/Linear_interpolation)
+     */
     lerp(vector, t, out = new Vector3()) {
         return lerp(this, vector, t, out);
     }
+    /**
+     * Set this vector to a random value with the given magnitude.
+     * @param magnitude - The magnitude.
+     * @returns This vector.
+     */
     random(magnitude = 1) {
         return random(magnitude, this);
     }
+    /**
+     * Transform this vector by a three-by-three matrix.
+     * @param matrix - The matrix.
+     * @param out - The vector to store the result in.
+     * @returns The transformed vector.
+     */
     transformMatrix3(matrix, out = new Vector3()) {
         return transformMatrix3(this, matrix, out);
     }
+    /**
+     * Transform this vector by a four-by-four matrix.
+     * @param matrix - The matrix.
+     * @param out - The vector to store the result in.
+     * @returns The transformed vector.
+     */
     transformMatrix4(matrix, out = new Vector3()) {
         return transformMatrix4(this, matrix, out);
     }
-    rotateX(origin, radians, out = new Vector3()) {
-        return rotateX(this, origin, radians, out);
-    }
-    rotateY(origin, radians, out = new Vector3()) {
-        return rotateY(this, origin, radians, out);
-    }
-    rotateZ(origin, radians, out = new Vector3()) {
-        return rotateZ(this, origin, radians, out);
-    }
+    /**
+     * Rotate this vector around the X-axis.
+     * @param origin - The origin of the rotation.
+     * @param r - The angle of rotation in radians.
+     * @param out - The vector to store the result in.
+     * @returns The rotated vector.
+     */
+    rotateX(origin, r, out = new Vector3()) {
+        return rotateX(this, origin, r, out);
+    }
+    /**
+     * Rotate this vector around the Y-axis.
+     * @param origin - The origin of the rotation.
+     * @param r - The angle of rotation in radians.
+     * @param out - The vector to store the result in.
+     * @returns The rotated vector.
+     */
+    rotateY(origin, r, out = new Vector3()) {
+        return rotateY(this, origin, r, out);
+    }
+    /**
+     * Rotate this vector around the Z-axis.
+     * @param origin - The origin of the rotation.
+     * @param r - The angle of rotation in radians.
+     * @param out - The vector to store the result in.
+     * @returns The rotated vector.
+     */
+    rotateZ(origin, r, out = new Vector3()) {
+        return rotateZ(this, origin, r, out);
+    }
+    /**
+     * Get the angle from this vector to another in radians.
+     * @param vector - The other vector.
+     * @returns The angular distance from this vector to the other.
+     */
     angle(vector) {
         return angle(this, vector);
     }
+    /**
+     * Set this to the zero vector.
+     * @returns This vector.
+     */
     zero() {
         return zero(this);
     }
+    /**
+     * Perform a Hermite interpolation with two control points between this vector and another.
+     * @param a - The first control point.
+     * @param b - The second control point.
+     * @param end - The other vector.
+     * @param t - The interpolation amount in the range `[0,1]`.
+     * @param out - The vector to store the result in.
+     * @returns The interpolated vector.
+     * @see [Hermite interpolation](https://en.wikipedia.org/wiki/Hermite_interpolation)
+     */
     hermite(a, b, end, t, out = new Vector3()) {
         return hermite(this, a, b, end, t, out);
     }
+    /**
+     * Perform a Bézier interpolation with two control points between this vector and another.
+     * @param a - The first control point.
+     * @param b - The second control point.
+     * @param end - The other vector.
+     * @param t - The interpolation amount in the range `[0,1]`.
+     * @param out - The vector to store the result in.
+     * @returns The interpolated vector.
+     * @see [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+     */
     bezier(a, b, end, t, out = new Vector3()) {
         return bezier(this, a, b, end, t, out);
     }
+    /**
+     * Transform this vector by a quaternion.
+     * @param quaternion - The quaternion.
+     * @param out - The vector to store the result in.
+     * @returns The transformed vector.
+     * @see [Quaternion](https://en.wikipedia.org/wiki/Quaternion)
+     */
     transformQuaternion(quaternion, out = new Vector3()) {
         return transformQuaternion(this, quaternion, out);
     }
+    /**
+     * Create a quaternion that represents the shortest rotation from this unit vector to another.
+     * @param vector - The other vector.
+     * @param out - The quaternion to store the result in.
+     * @returns The quaternion.
+     */
     rotationTo(vector, out = new Quaternion()) {
         return rotationTo(this, vector, out);
     }