@vived/core 1.0.0

package/src/ValueObjects/Quaternion.ts

@@ -0,0 +1,353 @@
+import { Angle } from "./Angle";
+import { Matrix } from "./Matrix";
+import { Vector3 } from "./Vector3";
+
+export interface QuaternionDTO {
+  x: number;
+  y: number;
+  z: number;
+  w: number;
+}
+
+export class Quaternion {
+  /**
+   * Checks to see if two Quaternions are equal
+   * @param a Quaternion A
+   * @param b Quaternion B
+   * @returns True if they are equal, otherwise false
+   */
+  public static Equal(a: Quaternion, b: Quaternion): boolean {
+    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
+   */
+  public static Close(
+    a: Quaternion,
+    b: Quaternion,
+    threshold = 0.001
+  ): boolean {
+    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
+   */
+  public static Multiply(a: Quaternion, b: Quaternion): Quaternion {
+    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
+   */
+  public static FromArray(
+    values: [number, number, number, number]
+  ): Quaternion {
+    return new Quaternion(values[0], values[1], values[2], values[3]);
+  }
+
+  /**
+   * Creates a Quaterion from a Data Transfer Object
+   * @param dto The Data Transfer Object
+   * @returns The Quaternion
+   */
+  public static FromDTO(dto: QuaternionDTO): Quaternion {
+    return new Quaternion(dto.x, dto.y, dto.z, dto.w);
+  }
+
+  /**
+   * Creates an Identity Quaternion
+   * @returns An Identity Quaternion
+   */
+  public static Identity(): Quaternion {
+    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
+   */
+  public static FromAngleAxis(axis: Vector3, angle: Angle): Quaternion {
+    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);
+  }
+
+  public static FromDirectionVector(direction: Vector3): Quaternion {
+    if (direction.magnitude === 0) {
+      return Quaternion.Identity();
+    }
+
+    const dirUnit = direction.unit;
+
+    if (dirUnit.x === 0 && dirUnit.z === 0) {
+      if (dirUnit.y > 0) {
+        return Quaternion.FromYawPitchRoll(
+          Angle.FromDegrees(0),
+          Angle.FromDegrees(-90),
+          Angle.FromDegrees(0)
+        );
+      } else {
+        return Quaternion.FromYawPitchRoll(
+          Angle.FromDegrees(0),
+          Angle.FromDegrees(90),
+          Angle.FromDegrees(0)
+        );
+      }
+    }
+
+    const yawRadians = -Math.atan2(dirUnit.z, dirUnit.x) + Math.PI / 2;
+    const len = Math.sqrt(dirUnit.x * dirUnit.x + dirUnit.z * dirUnit.z);
+    const pitchRadians = -Math.atan2(dirUnit.y, len);
+
+    const yaw = Angle.FromRadians(yawRadians);
+    const pitch = Angle.FromRadians(pitchRadians);
+    const roll = Angle.FromRadians(0);
+
+    return Quaternion.FromYawPitchRoll(yaw, pitch, roll);
+  }
+
+  /**
+   * 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
+   */
+  public static FromYawPitchRoll(
+    yaw: Angle,
+    pitch: Angle,
+    roll: Angle
+  ): Quaternion {
+    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
+   */
+  public static FromEuler(x: Angle, y: Angle, z: Angle) {
+    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
+   */
+  public static Inverse(a: Quaternion): Quaternion {
+    return new Quaternion(-a.x, -a.y, -a.z, a.w);
+  }
+
+  public static AngleBetween(a: Quaternion, b: Quaternion): Angle {
+    const aInv = this.Inverse(a);
+    const diffQ = this.Multiply(aInv, b);
+
+    const angDeg = diffQ.angle.degrees;
+    if(angDeg > 180) {
+      return Angle.FromDegrees(360 - angDeg)
+    } else {
+      return diffQ.angle;
+    }
+  }
+
+  /**
+   * 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
+   */
+  public static Slerp(
+    initial: Quaternion,
+    final: Quaternion,
+    percent: number
+  ): Quaternion {
+    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
+   */
+  public static FromRotationMatrix(rotationMatrix: Matrix): Quaternion {
+    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);
+  }
+
+  public static ToRotationMatrix(quat: Quaternion): Matrix {
+    return Matrix.Compose(Vector3.One(), quat, Vector3.Zero());
+  }
+
+  /**
+   * Copy the quaternion to an array
+   * @returns an array populated with 4 elements from the quaternion coordinates
+   */
+  toArray(): [number, number, number, number] {
+    return [this.x, this.y, this.z, this.w];
+  }
+
+  get angle(): Angle {
+    const angle = 2 * Math.acos(this.w);
+    return Angle.FromRadians(angle);
+  }
+
+  get axis(): Vector3 {
+    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(x, y, z);
+  }
+
+  /**
+   * Get the quaternion as a Data Transfer Object
+   */
+  get dto(): QuaternionDTO {
+    return { x: this.x, y: this.y, z: this.z, w: this.w };
+  }
+
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly w: number;
+
+  constructor(x: number, y: number, z: number, w: number) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+  }
+}

package/src/ValueObjects/Rectangle.test.ts

@@ -0,0 +1,32 @@
+import {Rectangle} from "./Rectangle";
+
+describe("Rectangle value object", ()=>{
+	it("Creates and stores the values", ()=>{
+		const rect = new Rectangle(1,2,3,4);
+		expect(rect.top).toEqual(1);
+		expect(rect.right).toEqual(2);
+		expect(rect.bottom).toEqual(3);
+		expect(rect.left).toEqual(4);
+	})
+
+	it("Forms a dto", ()=>{
+		const rect = new Rectangle(1,2,3,4);
+		expect(rect.dto.top).toEqual(1);
+		expect(rect.dto.right).toEqual(2);
+		expect(rect.dto.bottom).toEqual(3);
+		expect(rect.dto.left).toEqual(4);
+	})
+
+	it("Forms a rectangle from the DTO", ()=>{
+		const rect = Rectangle.FromDTO({
+			top: 1,
+			left: 2,
+			bottom: 3,
+			right: 4
+		});
+		expect(rect.top).toEqual(1);
+		expect(rect.left).toEqual(2);
+		expect(rect.bottom).toEqual(3);
+		expect(rect.right).toEqual(4);
+	})
+})

package/src/ValueObjects/Rectangle.ts

@@ -0,0 +1,33 @@
+export interface RectangleDTO {
+  top: number;
+  left: number;
+  right: number;
+  bottom: number;
+}
+
+export class Rectangle {
+  public static FromDTO(dto: RectangleDTO):Rectangle {
+    return new Rectangle(dto.top, dto.right, dto.bottom, dto.left);
+  }
+
+  readonly top: number;
+  readonly left: number;
+  readonly bottom: number;
+  readonly right: number;
+
+  get dto(): RectangleDTO {
+    return {
+			top: this.top,
+			bottom: this.bottom,
+			left: this.left,
+			right: this.right
+		};
+  }
+
+  constructor(top: number, right: number, bottom: number, left: number ) {
+    this.top = top;
+    this.bottom = bottom;
+    this.left = left;
+    this.right = right;
+  }
+}

package/src/ValueObjects/Vector2.test.ts

@@ -0,0 +1,167 @@
+import { Angle } from ".";
+import { Vector2 } from "./Vector2";
+
+describe("Vector 2 value object", () => {
+  it("Creates a new vector", () => {
+    const v = new Vector2(2, 5);
+    expect(v.x).toEqual(2);
+    expect(v.y).toEqual(5);
+  });
+
+  it("Returns the magnitude", () => {
+    expect(new Vector2(0, 5).magnitued).toEqual(5);
+    expect(new Vector2(0, -5).magnitued).toEqual(5);
+    expect(new Vector2(5, 0).magnitued).toEqual(5);
+    expect(new Vector2(-5, 0).magnitued).toEqual(5);
+    expect(new Vector2(-1, -1).magnitued).toBeCloseTo(1.414);
+    expect(new Vector2(1, 1).magnitued).toBeCloseTo(1.414);
+  });
+
+  it("Returns the unit", () => {
+    expect(new Vector2(0, 5).unit).toEqual(new Vector2(0, 1));
+    expect(new Vector2(0, -5).unit).toEqual(new Vector2(0, -1));
+    expect(new Vector2(5, 0).unit).toEqual(new Vector2(1, 0));
+    expect(new Vector2(-5, 0).unit).toEqual(new Vector2(-1, 0));
+
+    const unit1 = new Vector2(5, 5).unit;
+    expect(unit1.x).toBeCloseTo(0.707);
+    expect(unit1.y).toBeCloseTo(0.707);
+  });
+
+  it("Retuns theta", () => {
+    expect(new Vector2(0, 5).theta).toBeCloseTo(90);
+    expect(new Vector2(0, -5).theta).toBeCloseTo(-90);
+    expect(new Vector2(5, 0).theta).toBeCloseTo(0);
+    expect(new Vector2(-5, 0).theta).toBeCloseTo(180);
+  });
+
+  test("Returns the vector as an array", () => {
+    const v1 = new Vector2(1, 2);
+
+    expect(v1.array[0]).toEqual(1);
+    expect(v1.array[1]).toEqual(2);
+  });
+});
+
+describe("Vector 2 static actions", () => {
+  it("Create a zero vector", () => {
+    expect(Vector2.Zero()).toEqual(new Vector2(0, 0));
+  });
+
+  it("Create a one vector", () => {
+    expect(Vector2.One()).toEqual(new Vector2(1, 1));
+  });
+
+  it("Check for vectors to be Equal", () => {
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(2, 3);
+    const v3 = new Vector2(1, 2);
+
+    expect(Vector2.Equal(v1, v2)).toEqual(false);
+    expect(Vector2.Equal(v1, v3)).toEqual(true);
+  });
+
+  it("Adds vectors", () => {
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(2, 3);
+    const v3 = Vector2.Add(v1, v2);
+
+    expect(v3).toEqual(new Vector2(3, 5));
+  });
+
+  it("Subtracts vectors", () => {
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(2, 3);
+    const v3 = Vector2.Subtract(v1, v2);
+
+    expect(v3).toEqual(new Vector2(-1, -1));
+  });
+
+  it("Checks to see if vectors are close using a default threshold", () => {
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(1.001, 2.001);
+    const v3 = new Vector2(1.1, 2.1);
+
+    expect(Vector2.Close(v1, v2)).toEqual(true);
+    expect(Vector2.Close(v1, v3)).toEqual(false);
+  });
+
+  it("Checks to see if vectors are close using a passed threshold", () => {
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(1.1, 2.1);
+    const v3 = new Vector2(2, 3);
+
+    expect(Vector2.Close(v1, v2, 1)).toEqual(true);
+    expect(Vector2.Close(v1, v3, 1)).toEqual(false);
+  });
+
+  it("Rotates to a new vector", () => {
+    const v1 = new Vector2(1, 2);
+
+    const r1 = Vector2.Rotate(v1, Angle.FromDegrees(90));
+    expect(r1.x).toBeCloseTo(-2);
+    expect(r1.y).toBeCloseTo(1);
+
+    const r2 = Vector2.Rotate(v1, Angle.FromDegrees(-90));
+    expect(r2.x).toBeCloseTo(2);
+    expect(r2.y).toBeCloseTo(-1);
+  });
+
+  it("Scales a vector", () => {
+    const v1 = new Vector2(1, 2);
+    const scaled = Vector2.Scale(v1, 3);
+    expect(scaled).toEqual(new Vector2(3, 6));
+  });
+
+  it("Make a new vector of length", () => {
+    const v1 = new Vector2(1, 1);
+    const lengthened = Vector2.NewVectorOfLength(v1, 3);
+    expect(lengthened.x).toBeCloseTo(2.12);
+    expect(lengthened.y).toBeCloseTo(2.12);
+  });
+
+  it("Calculates the dot between two vectors", () => {
+    // https://onlinemschool.com/math/assistance/vector/multiply/
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(5, 6);
+
+    const dot = Vector2.Dot(v1, v2);
+    expect(dot).toEqual(17);
+  });
+
+  it("Calculates the angle between two vectors", () => {
+    // https://www.omnicalculator.com/math/angle-between-two-vectors
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(3, 4);
+
+    const angle = Vector2.AngleBetween(v1, v2);
+    expect(angle.degrees).toBeCloseTo(10.305);
+  });
+
+  it("Calculates a Cross product", () => {
+    const v1 = new Vector2(1, 2);
+    const v2 = new Vector2(3, 4);
+
+    const cross = Vector2.Cross(v1, v2);
+    expect(cross).toEqual(-2);
+  });
+
+  it("Gets the Data Transfer Object", () => {
+    const vec = new Vector2(1, 2);
+
+    expect(vec.dto).toEqual({
+      x: 1,
+      y: 2
+    });
+  });
+
+  it("Makes a vector from a DTO", () => {
+    const vec = Vector2.FromDTO({
+      x: 1,
+      y: 2
+    });
+
+    expect(vec.x).toEqual(1);
+    expect(vec.y).toEqual(2);
+  });
+});