@vived/app 2.20.0 → 2.21.1

package/lib/ValueObjects/Quaternion.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Quaternion = void 0;
+const Angle_1 = require("./Angle");
+const Matrix_1 = require("./Matrix");
+const Vector3_1 = require("./Vector3");
+class Quaternion {
+    constructor(x, y, z, w) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.w = w;
+    }
+    /**
+     * Checks to see if two Quaternions are equal
+     * @param a Quaternion A
+     * @param b Quaternion B
+     * @returns True if they are equal, otherwise false
+     */
+    static Equal(a, b) {
+        if (a.x === b.x && a.y === b.y && a.z === b.z && a.w === b.w) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * Checks two quaternions to see if they are close
+     * @param a Quaterion A
+     * @param b Quaterion B
+     * @param threshold "Close" threshold. Defaults to 0.001
+     * @returns True if each of Quaterion's components are within the threshold of each other
+     */
+    static Close(a, b, threshold = 0.001) {
+        const aArray = a.toArray();
+        const bArray = b.toArray();
+        let areClose = true;
+        for (let i = 0; i < 4; i++) {
+            let diff = aArray[i] - bArray[i];
+            if (diff < 0) {
+                diff = -diff;
+            }
+            if (diff > threshold) {
+                areClose = false;
+                break;
+            }
+        }
+        return areClose;
+    }
+    /**
+     * Multiplies A*B
+     * @param a Quaterion A
+     * @param b Quaternion B
+     * @returns The result of A*B
+     */
+    static Multiply(a, b) {
+        const x = a.x * b.w + a.y * b.z - a.z * b.y + a.w * b.x;
+        const y = -a.x * b.z + a.y * b.w + a.z * b.x + a.w * b.y;
+        const z = a.x * b.y - a.y * b.x + a.z * b.w + a.w * b.z;
+        const w = -a.x * b.x - a.y * b.y - a.z * b.z + a.w * b.w;
+        return Quaternion.FromArray([x, y, z, w]);
+    }
+    /**
+     * Creates a new Quaterion from an array of values
+     * @param values The four values of the Quaterion: [x,y,z,w]
+     * @returns A Quaterion
+     */
+    static FromArray(values) {
+        return new Quaternion(values[0], values[1], values[2], values[3]);
+    }
+    /**
+     * Creates an Identity Quaternion
+     * @returns An Identity Quaternion
+     */
+    static Identity() {
+        return new Quaternion(0, 0, 0, 1);
+    }
+    /**
+     * Creates an quaterion about an axis for a given angle
+     * @param axis The rotation axis
+     * @param angle The rotation angle
+     * @returns The resulting Quaterion
+     */
+    static FromAngleAxis(axis, angle) {
+        const sin = Math.sin(angle.radians / 2);
+        const axisUnit = axis.unit;
+        const w = Math.cos(angle.radians / 2);
+        const x = axisUnit.x * sin;
+        const y = axisUnit.y * sin;
+        const z = axisUnit.z * sin;
+        return new Quaternion(x, y, z, w);
+    }
+    /**
+     * Froms up a Quaternion from the Yaw-Pitch-Roll (Tait-Bryan) convetion
+     * @param yaw defines the rotation around the y axis
+     * @param pitch defines the rotation around the x axis
+     * @param roll defines the rotation around the z axis
+     * @returns the resulting quaterion
+     */
+    static FromYawPitchRoll(yaw, pitch, roll) {
+        const halfRoll = roll.radians * 0.5;
+        const halfPitch = pitch.radians * 0.5;
+        const halfYaw = yaw.radians * 0.5;
+        const sinRoll = Math.sin(halfRoll);
+        const cosRoll = Math.cos(halfRoll);
+        const sinPitch = Math.sin(halfPitch);
+        const cosPitch = Math.cos(halfPitch);
+        const sinYaw = Math.sin(halfYaw);
+        const cosYaw = Math.cos(halfYaw);
+        const x = cosYaw * sinPitch * cosRoll + sinYaw * cosPitch * sinRoll;
+        const y = sinYaw * cosPitch * cosRoll - cosYaw * sinPitch * sinRoll;
+        const z = cosYaw * cosPitch * sinRoll - sinYaw * sinPitch * cosRoll;
+        const w = cosYaw * cosPitch * cosRoll + sinYaw * sinPitch * sinRoll;
+        return new Quaternion(x, y, z, w);
+    }
+    /**
+     * Creates a Quaternion from three euler angles.
+     * @param x Rotation about the x axis
+     * @param y Rotation about the y axis
+     * @param z Rotation about the z axis
+     * @returns The Quaterion
+     */
+    static FromEuler(x, y, z) {
+        return this.FromYawPitchRoll(y, x, z);
+    }
+    /**
+     * Returns a new Quaternion that is an invert of A
+     * @param a The quaternion to invert
+     * @returns The inverted Quaternion
+     */
+    static Inverse(a) {
+        return new Quaternion(-a.x, -a.y, -a.z, a.w);
+    }
+    /**
+     * Spherically interpolates between two quaternions
+     * @param initial The initial quaternion
+     * @param final The final quaterion
+     * @param percent The percent along the slerp. 0 will return the initial quaterion and 1 will return the final quaterion
+     * @returns The interpolated quaterion
+     */
+    static Slerp(initial, final, percent) {
+        let A;
+        let B;
+        let C = initial.x * final.x +
+            initial.y * final.y +
+            initial.z * final.z +
+            initial.w * final.w;
+        let flip = false;
+        if (C < 0) {
+            flip = true;
+            C = -C;
+        }
+        if (C > 0.999999) {
+            B = 1 - percent;
+            A = flip ? -percent : percent;
+        }
+        else {
+            const D = Math.acos(C);
+            const E = 1.0 / Math.sin(D);
+            B = Math.sin((1.0 - percent) * D) * E;
+            A = flip ? -Math.sin(percent * D) * E : Math.sin(percent * D) * E;
+        }
+        const x = B * initial.x + A * final.x;
+        const y = B * initial.y + A * final.y;
+        const z = B * initial.z + A * final.z;
+        const w = B * initial.w + A * final.w;
+        return new Quaternion(x, y, z, w);
+    }
+    /**
+     * Calculates a Quaternion from a rotation matrix
+     * @param rotationMatrix A normalized, non-scaled rotation matrix
+     * @returns The Quaterion
+     */
+    static FromRotationMatrix(rotationMatrix) {
+        const m = rotationMatrix.m;
+        const m11 = m[0];
+        const m12 = m[4];
+        const m13 = m[8];
+        const m21 = m[1];
+        const m22 = m[5];
+        const m23 = m[9];
+        const m31 = m[2];
+        const m32 = m[6];
+        const m33 = m[10];
+        const trace = m11 + m22 + m33;
+        let s;
+        let x = 0;
+        let y = 0;
+        let z = 0;
+        let w = 0;
+        if (trace > 0) {
+            s = 0.5 / Math.sqrt(trace + 1.0);
+            w = 0.25 / s;
+            x = (m32 - m23) * s;
+            y = (m13 - m31) * s;
+            z = (m21 - m12) * s;
+        }
+        else if (m11 > m22 && m11 > m33) {
+            s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+            w = (m32 - m23) / s;
+            x = 0.25 * s;
+            y = (m12 + m21) / s;
+            z = (m13 + m31) / s;
+        }
+        else if (m22 > m33) {
+            s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+            w = (m13 - m31) / s;
+            x = (m12 + m21) / s;
+            y = 0.25 * s;
+            z = (m23 + m32) / s;
+        }
+        else {
+            s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+            w = (m21 - m12) / s;
+            x = (m13 + m31) / s;
+            y = (m23 + m32) / s;
+            z = 0.25 * s;
+        }
+        return new Quaternion(x, y, z, w);
+    }
+    static ToRotationMatrix(quat) {
+        return Matrix_1.Matrix.Compose(Vector3_1.Vector3.One(), quat, Vector3_1.Vector3.Zero());
+    }
+    /**
+     * Copy the quaternion to an array
+     * @returns an array populated with 4 elements from the quaternion coordinates
+     */
+    toArray() {
+        return [this.x, this.y, this.z, this.w];
+    }
+    get angle() {
+        const angle = 2 * Math.acos(this.w);
+        return Angle_1.Angle.FromRadians(angle);
+    }
+    get axis() {
+        const x = this.x / Math.sqrt(1 - this.w * this.w);
+        const y = this.y / Math.sqrt(1 - this.w * this.w);
+        const z = this.z / Math.sqrt(1 - this.w * this.w);
+        return new Vector3_1.Vector3(x, y, z);
+    }
+}
+exports.Quaternion = Quaternion;

package/lib/ValueObjects/Vector2.d.ts

@@ -1,22 +1,104 @@
 import { Angle } from ".";
 export declare class Vector2 {
+    /**
+     * Creates a zero vector
+     * @returns Vector [0,0]
+     */
     static Zero(): Vector2;
+    /**
+     * Creates a one vector
+     * @returns Vector [1,1]
+     */
     static One(): Vector2;
+    /**
+     * Checks to see if Vector A equals Vector B
+     * @param a Vector A
+     * @param b Vector B
+     * @returns True if Vector A === Vector B
+     */
     static Equal(a: Vector2, b: Vector2): boolean;
+    /**
+     * Adds Vector B to Vector A
+     * @param a Vector A
+     * @param b Vector B
+     * @returns A + B
+     */
     static Add(a: Vector2, b: Vector2): Vector2;
+    /**
+     * Subtracts Vector B from Vector A
+     * @param a Vector A
+     * @param b Vector B
+     * @returns A - B
+     */
     static Subtract(a: Vector2, b: Vector2): Vector2;
+    /**
+     * Checks to see if Vector A is close to Vector B
+     * @param a Vector A
+     * @param b Vector B
+     * @param threshold Tolerance to define "close". Defaults to 0.01
+     * @returns True if A and B are close enough
+     */
     static Close: (a: Vector2, b: Vector2, threshold?: number) => boolean;
+    /**
+     * Rotates a vector by an angle
+     * @param vec The original vector
+     * @param angle The angle
+     * @returns A new Vector that has been rotated from the original by an angle
+     */
     static Rotate: (vec: Vector2, angle: Angle) => Vector2;
+    /**
+     * Scales a vector uniformly
+     * @param vector The original vector
+     * @param scale Scale factor
+     * @returns A new, scaled vector
+     */
     static Scale: (vector: Vector2, scale: number) => Vector2;
+    /**
+     * Creates a new vector of a given lenght and a unit that is equal to the original vector
+     * @param vector The original vector. This determines the unit of the final vector
+     * @param length The desired length of the final vector
+     * @returns The final vector
+     */
     static NewVectorOfLength: (vector: Vector2, length: number) => Vector2;
+    /**
+     * Calculate the dot product between Vectors A and B
+     * @param a Vector A
+     * @param b Vector B
+     * @returns The Dot product between A and B
+     */
     static Dot: (a: Vector2, b: Vector2) => number;
+    /**
+     * Calculates the dot product between Vectors A and B
+     * @param a Vector A
+     * @param b Vector B
+     * @returns A . B
+     */
     static AngleBetween: (a: Vector2, b: Vector2) => Angle;
+    /**
+     * Calculates the Cross product between Vectors A and B
+     * @param a Vector A
+     * @param b Vector B
+     * @returns A X B
+     */
     static Cross: (a: Vector2, b: Vector2) => number;
     readonly x: number;
     readonly y: number;
+    /**
+     * Get the magnitude (length) of the vector
+     */
     get magnitued(): number;
+    /**
+     * Get the unit vector
+     */
     get unit(): Vector2;
+    /**
+     * Returns the angle of the direction of this angle in degrees.
+     * A right vector [1,0] will return 0, a left vector [-1,0] will return 180, an up vector [0,1] will return 90 and a down vector [0,-1] will return -90
+     */
     get theta(): number;
+    /**
+     * Retuns the vector as an array of numbers [x,y]
+     */
     get array(): [number, number];
     constructor(x: number, y: number);
 }

package/lib/ValueObjects/Vector2.js

@@ -7,12 +7,26 @@ class Vector2 {
         this.x = x;
         this.y = y;
     }
+    /**
+     * Creates a zero vector
+     * @returns Vector [0,0]
+     */
     static Zero() {
         return new Vector2(0, 0);
     }
+    /**
+     * Creates a one vector
+     * @returns Vector [1,1]
+     */
     static One() {
         return new Vector2(1, 1);
     }
+    /**
+     * Checks to see if Vector A equals Vector B
+     * @param a Vector A
+     * @param b Vector B
+     * @returns True if Vector A === Vector B
+     */
     static Equal(a, b) {
         if (a.x !== b.x)
             return false;
@@ -20,18 +34,36 @@ class Vector2 {
             return false;
         return true;
     }
+    /**
+     * Adds Vector B to Vector A
+     * @param a Vector A
+     * @param b Vector B
+     * @returns A + B
+     */
     static Add(a, b) {
         return new Vector2(a.x + b.x, a.y + b.y);
     }
+    /**
+     * Subtracts Vector B from Vector A
+     * @param a Vector A
+     * @param b Vector B
+     * @returns A - B
+     */
     static Subtract(a, b) {
         return new Vector2(a.x - b.x, a.y - b.y);
     }
+    /**
+     * Get the magnitude (length) of the vector
+     */
     get magnitued() {
         const xSqr = this.x * this.x;
         const ySqr = this.y * this.y;
         const magnitude = Math.sqrt(xSqr + ySqr);
         return magnitude;
     }
+    /**
+     * Get the unit vector
+     */
     get unit() {
         const mag = this.magnitued;
         if (mag === 0) {
@@ -41,14 +73,28 @@ class Vector2 {
         const unitY = this.y / mag;
         return new Vector2(unitX, unitY);
     }
+    /**
+     * Returns the angle of the direction of this angle in degrees.
+     * A right vector [1,0] will return 0, a left vector [-1,0] will return 180, an up vector [0,1] will return 90 and a down vector [0,-1] will return -90
+     */
     get theta() {
         return (Math.atan2(this.y, this.x) * 180) / Math.PI;
     }
+    /**
+     * Retuns the vector as an array of numbers [x,y]
+     */
     get array() {
         return [this.x, this.y];
     }
 }
 exports.Vector2 = Vector2;
+/**
+ * Checks to see if Vector A is close to Vector B
+ * @param a Vector A
+ * @param b Vector B
+ * @param threshold Tolerance to define "close". Defaults to 0.01
+ * @returns True if A and B are close enough
+ */
 Vector2.Close = (a, b, threshold = 0.01) => {
     const diff = Vector2.Subtract(a, b);
     const diffMag = diff.magnitued;
@@ -57,31 +103,67 @@ Vector2.Close = (a, b, threshold = 0.01) => {
     else
         return false;
 };
+/**
+ * Rotates a vector by an angle
+ * @param vec The original vector
+ * @param angle The angle
+ * @returns A new Vector that has been rotated from the original by an angle
+ */
 Vector2.Rotate = (vec, angle) => {
     const x = vec.x * Math.cos(angle.radians) - vec.y * Math.sin(angle.radians);
     const y = vec.x * Math.sin(angle.radians) + vec.y * Math.cos(angle.radians);
     return new Vector2(x, y);
 };
+/**
+ * Scales a vector uniformly
+ * @param vector The original vector
+ * @param scale Scale factor
+ * @returns A new, scaled vector
+ */
 Vector2.Scale = (vector, scale) => {
     const x = scale * vector.x;
     const y = scale * vector.y;
     return new Vector2(x, y);
 };
+/**
+ * Creates a new vector of a given lenght and a unit that is equal to the original vector
+ * @param vector The original vector. This determines the unit of the final vector
+ * @param length The desired length of the final vector
+ * @returns The final vector
+ */
 Vector2.NewVectorOfLength = (vector, length) => {
     const unit = vector.unit;
     const x = length * unit.x;
     const y = length * unit.y;
     return new Vector2(x, y);
 };
+/**
+ * Calculate the dot product between Vectors A and B
+ * @param a Vector A
+ * @param b Vector B
+ * @returns The Dot product between A and B
+ */
 Vector2.Dot = (a, b) => {
     return a.x * b.x + a.y * b.y;
 };
+/**
+ * Calculates the dot product between Vectors A and B
+ * @param a Vector A
+ * @param b Vector B
+ * @returns A . B
+ */
 Vector2.AngleBetween = (a, b) => {
     const dot = Vector2.Dot(a, b);
     const magnitues = a.magnitued * b.magnitued;
     const angRadians = Math.acos(dot / magnitues);
     return _1.Angle.FromRadians(angRadians);
 };
+/**
+ * Calculates the Cross product between Vectors A and B
+ * @param a Vector A
+ * @param b Vector B
+ * @returns A X B
+ */
 Vector2.Cross = (a, b) => {
     return a.x * b.y - a.y * b.x;
 };

package/lib/ValueObjects/Vector3.d.ts

@@ -1,26 +1,133 @@
+import { Matrix } from "./Matrix";
 export declare class Vector3 {
+    /**
+     * Creates a zero vector
+     * @returns Vector [0,0,0]
+     */
     static Zero(): Vector3;
+    /**
+     * Creates a vector of ones
+     * @returns Vector [1,1,1]
+     */
     static One(): Vector3;
+    /**
+     * Creates a Right vector (positive X)
+     * @param length optional length of the right unit. Default is 1
+     * @returns Vector [length, 0,0]
+     */
     static Right(length?: number): Vector3;
+    /**
+     * Creates a Left vector (negative X)
+     * @param length optional length of the left unit. Default is 1
+     * @returns Vector [-length, 0, 0]
+     */
     static Left(length?: number): Vector3;
+    /**
+     * Creates an Up vector (positive Y)
+     * @param length optional length of the vector. Default is 1
+     * @returns Vector [0, length, 0]
+     */
     static Up(length?: number): Vector3;
+    /**
+     * Creates a Down vector (negative Y)
+     * @param length optional length of the vector. Default is 1
+     * @returns Vector [0, -length, 0]
+     */
     static Down(length?: number): Vector3;
+    /**
+     * Creates a Forward vector (positive Z)
+     * @param length optional length of the vector. Default is 1
+     * @returns Vector [0, 0, length]
+     */
     static Forward(length?: number): Vector3;
+    /**
+     * Creates a Backward vector (negative Z)
+     * @param length optional length of the vector. Default is 1
+     * @returns Vector [0, 0, -length]
+     */
     static Backward(length?: number): Vector3;
+    /**
+     * Creates a Vector from an array of components
+     * @param values The x, y, z components as an array
+     * @returns The Vector
+     */
     static FromArray(values: [number, number, number]): Vector3;
+    /**
+     * Adds Vector B to Vector A
+     * @param a Vector A
+     * @param b Vector B
+     * @return Result of A + B
+     */
     static Add: (a: Vector3, b: Vector3) => Vector3;
+    /**
+     * Subtracts Vector B from Vector A
+     * @param a Vector A
+     * @param b Vector B
+     * @return Result of A - B
+     */
     static Subtract: (a: Vector3, b: Vector3) => Vector3;
+    /**
+     * Checks to see if the two vectors are equal
+     * @param a Vector A
+     * @param b Vector B
+     * @return True if the two vectors are equal, otherwise false
+     */
     static Equal: (a: Vector3, b: Vector3) => boolean;
+    /**
+     * Checks to see if the two vectors are close
+     * @param a Vector A
+     * @param b Vector B
+     * @param tolerance Tolerance for checking. Defaulted to 0.01
+     * @return True if the distance between the two vectors is less than the tolerance, otherwise false
+     */
     static Close: (a: Vector3, b: Vector3, tolerance?: number) => boolean;
+    /**
+     * Calculates the Cross Product between two vectors
+     * @param a Vector A
+     * @param b Vector B
+     * @return the cross product between the two vectors
+     */
     static Cross: (a: Vector3, b: Vector3) => Vector3;
+    /**
+     * Calculates the Dot Product between two vectors
+     * @param a Vector A
+     * @param b Vector B
+     * @return the dot product between the two vectors
+     */
     static Dot: (a: Vector3, b: Vector3) => number;
+    /**
+     * Create a new vector that will have the same unit as the original vector but set to the desired length
+     * @param vec The original vector
+     * @param length Desired lenght of the final vector
+     * @return The resulting vector
+     */
     static NewVectorOfLength: (vec: Vector3, length: number) => Vector3;
+    static Transform: (vector: Vector3, matrix: Matrix) => Vector3;
+    /**
+     * Linearly inerpolates between two vectors
+     * @param initial The starting point
+     * @param final The end point
+     * @param percent Percent of the lerp. 0 will return initial and 1 will return final
+     * @return the LERP result Vector3
+     */
     static Lerp: (initial: Vector3, final: Vector3, percent: number) => Vector3;
     readonly x: number;
     readonly y: number;
     readonly z: number;
+    /**
+     * Gets the magnitude of the Vector3
+     * @returns the magnitude of the Vector3
+     */
     get magnitued(): number;
+    /**
+     * Gets the unit vector for this Vector3
+     * @returns the unit vector
+     */
     get unit(): Vector3;
+    /**
+     * Gets the vector as an array
+     * @returns an array representing the vector
+     */
     get array(): [number, number, number];
     constructor(x: number, y: number, z: number);
 }