@openglobus/og 0.18.0 → 0.18.2

package/{src/math/Vec2.ts → lib/js/math/Vec2.js}

@@ -1,7 +1,4 @@
-import {Vec3} from "./Vec3";
-
-export type NumberArray2 = [number, number];
-
+import { Vec3 } from "./Vec3";
 /**
  * Class represents a 3d vector.
  * @class
@@ -9,49 +6,30 @@ export type NumberArray2 = [number, number];
  * @param {number} [y] - Second value.
  */
 export class Vec2 {
-
-    /**
-     * @public
-     * @type {number}
-     */
-    public x: number;
-
-    /**
-     * @public
-     * @type {number}
-     */
-    public y: number;
-
-    constructor(x: number = 0.0, y: number = 0.0) {
+    constructor(x = 0.0, y = 0.0) {
         this.x = x;
         this.y = y;
     }
-
     /** @const */
-    static get UP(): Vec2 {
+    static get UP() {
         return new Vec2(0, 1);
     }
-
     /** @const */
-    static get DOWN(): Vec2 {
+    static get DOWN() {
         return new Vec2(0, -1);
     }
-
     /** @const */
-    static get RIGHT(): Vec2 {
+    static get RIGHT() {
         return new Vec2(1, 0);
     }
-
     /** @const */
-    static get LEFT(): Vec2 {
+    static get LEFT() {
         return new Vec2(-1, 0);
     }
-
     /** @const */
-    static get ZERO(): Vec2 {
+    static get ZERO() {
         return new Vec2();
     }
-
     /**
      * Returns summary vector.
      * @static
@@ -59,12 +37,11 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2} - Summary vector.
      */
-    static add(a: Vec2, b: Vec2): Vec2 {
+    static add(a, b) {
         const res = new Vec2(a.x, a.y);
         res.addA(b);
         return res;
     }
-
     /**
      * Returns two vectors subtraction.
      * @static
@@ -72,12 +49,11 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2} - Vectors subtraction.
      */
-    static sub(a: Vec2, b: Vec2): Vec2 {
+    static sub(a, b) {
         var res = new Vec2(a.x, a.y);
         res.subA(b);
         return res;
     }
-
     /**
      * Returns scaled vector.
      * @static
@@ -85,12 +61,11 @@ export class Vec2 {
      * @param {number} scale - Scale value.
      * @returns {Vec2}
      */
-    static scale(a: Vec2, scale: number): Vec2 {
+    static scale(a, scale) {
         let res = new Vec2(a.x, a.y);
         res.scale(scale);
         return res;
     }
-
     /**
      * Returns two vectors production.
      * @static
@@ -98,12 +73,11 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2}
      */
-    static mul(a: Vec2, b: Vec2): Vec2 {
+    static mul(a, b) {
         let res = new Vec2(a.x, a.y);
         res.mulA(b);
         return res;
     }
-
     /**
      * Returns vector components division product one to another.
      * @static
@@ -111,12 +85,11 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {Vec2}
      */
-    static div(a: Vec2, b: Vec2): Vec2 {
+    static div(a, b) {
         let res = new Vec2(a.x, a.y);
         res.divA(b);
         return res;
     }
-
     /**
      * Get projection of the first vector to the second.
      * @static
@@ -124,10 +97,9 @@ export class Vec2 {
      * @param {Vec2} a - Second vector.
      * @returns {Vec2}
      */
-    static proj_b_to_a(b: Vec2, a: Vec2): Vec2 {
+    static proj_b_to_a(b, a) {
         return a.scaleTo(a.dot(b) / a.dot(a));
     }
-
     /**
      * Gets angle between two vectors.
      * @static
@@ -135,10 +107,9 @@ export class Vec2 {
      * @param {Vec2} b - Second vector.
      * @returns {number}
      */
-    static angle(a: Vec2, b: Vec2): number {
+    static angle(a, b) {
         return Math.acos(a.dot(b) / Math.sqrt(a.length2() * b.length2()));
     }
-
     /**
      * Makes vectors normalized and orthogonal to each other.
      * @static
@@ -146,260 +117,231 @@ export class Vec2 {
      * @param {Vec2} tangent - Tangent vector.
      * @returns {Vec2}
      */
-    static orthoNormalize(normal: Vec2, tangent: Vec2): Vec2 {
+    static orthoNormalize(normal, tangent) {
         normal = normal.normal();
         normal.scale(tangent.dot(normal));
         return tangent.sub(normal).normalize();
     }
-
     /**
      * Converts to 3d vector, third value is 0.0.
      * @public
      * @returns {Vec3}
      */
-    public toVector3(): Vec3 {
+    toVector3() {
         return new Vec3(this.x, this.y, 0);
     }
-
     /**
      * Returns clone vector.
      * @public
      * @returns {Vec2}
      */
-    public clone(): Vec2 {
+    clone() {
         return new Vec2(this.x, this.y);
     }
-
     /**
      * Compares with vector. Returns true if it equals another.
      * @public
      * @param {Vec2} p - Vector to compare.
      * @returns {boolean}
      */
-    public equal(p: Vec2): boolean {
+    equal(p) {
         return this.x === p.x && this.y === p.y;
     }
-
     /**
      * Copy input vector's values.
      * @param {Vec2} point2 - Vector to copy.
      * @returns {Vec2}
      */
-    public copy(point2: Vec2): Vec2 {
+    copy(point2) {
         this.x = point2.x;
         this.y = point2.y;
         return this;
     }
-
     /**
      * Gets vector's length.
      * @public
      * @returns {number}
      */
-    public length(): number {
+    length() {
         return Math.sqrt(this.x * this.x + this.y * this.y);
     }
-
     /**
      * Returns squared vector's length.
      * @public
      * @returns {number}
      */
-    public length2(): number {
+    length2() {
         return this.x * this.x + this.y * this.y;
     }
-
     /**
      * Adds vector to the current.
      * @public
      * @param {Vec2}
      * @returns {Vec2}
      */
-    public addA(v: Vec2): Vec2 {
+    addA(v) {
         this.x += v.x;
         this.y += v.y;
         return this;
     }
-
     /**
      * Summarize two vectors.
      * @public
      * @param {Vec2}
      * @returns {Vec2}
      */
-    public add(v: Vec2): Vec2 {
+    add(v) {
         return new Vec2(this.x + v.x, this.y + v.y);
     }
-
     /**
      * Subtract vector from the current where results saved on the current instance.
      * @public
      * @param {Vec2} v - Subtract vector.
      * @returns {Vec2}
      */
-    public subA(v: Vec2): Vec2 {
+    subA(v) {
         this.x -= v.x;
         this.y -= v.y;
         return this;
     }
-
     /**
      * Subtract vector from the current.
      * @public
      * @param {Vec2} v - Subtract vector.
      * @returns {Vec2}
      */
-    public sub(v: Vec2): Vec2 {
+    sub(v) {
         return new Vec2(this.x - v.x, this.y - v.y);
     }
-
     /**
      * Scale current vector.
      * @public
      * @param {number} scale - Scale value.
      * @returns {Vec2}
      */
-    public scale(scale: number): Vec2 {
+    scale(scale) {
         this.x *= scale;
         this.y *= scale;
         return this;
     }
-
     /**
      * Scale current vector to another instance.
      * @public
      * @param {number} scale - Scale value.
      * @returns {Vec2}
      */
-    public scaleTo(scale: number): Vec2 {
+    scaleTo(scale) {
         return new Vec2(this.x * scale, this.y * scale);
     }
-
     /**
      * Multiply current vector object to another and store result in the current instance.
      * @public
      * @param {Vec2} vec - Multiply vector.
      * @returns {Vec2}
      */
-    public mulA(vec: Vec2): Vec2 {
+    mulA(vec) {
         this.x *= vec.x;
         this.y *= vec.y;
         return this;
     }
-
     /**
      * Multiply current vector object to another and returns new vector instance.
      * @public
      * @param {Vec2} vec - Multiply vector.
      * @returns {Vec2}
      */
-    public mul(vec: Vec2): Vec2 {
+    mul(vec) {
         return new Vec2(this.x * vec.x, this.y * vec.y);
     }
-
     /**
      * Divide current vector's components to another. Results stores in the current vector object.
      * @public
      * @param {Vec2}
      * @returns {Vec2}
      */
-    public divA(vec: Vec2): Vec2 {
+    divA(vec) {
         this.x /= vec.x;
         this.y /= vec.y;
         return this;
     }
-
     /**
      * Gets vectors dot production.
      * @public
      * @param {Vec2} v - Another vector.
      * @returns {number}
      */
-    public dot(v: Vec2): number {
+    dot(v) {
         return v.x * this.x + v.y * this.y;
     }
-
     /**
      * Gets vectors dot production.
      * @public
      * @param {Array.<number>} arr - Array vector. (exactly 2 entries)
      * @returns {number}
      */
-    public dotArr(arr: NumberArray2): number {
+    dotArr(arr) {
         return arr[0] * this.x + arr[1] * this.y;
     }
-
     /**
      * Gets vectors cross production.
      * @public
      * @param {Vec2} v - Another vector.
      * @returns {number}
      */
-    public cross(v: Vec2): number {
+    cross(v) {
         return this.x * v.y - this.y * v.x;
     }
-
     /**
      * Sets vector to zero.
      * @public
      * @returns {Vec2}
      */
-    public clear(): Vec2 {
+    clear() {
         this.x = this.y = 0;
         return this;
     }
-
     /**
      * Returns normalized vector.
      * @public
      * @returns {Vec2}
      */
-    public normal(): Vec2 {
+    normal() {
         let res = new Vec2();
         res.copy(this);
-
         let length = 1.0 / res.length();
-
         res.x *= length;
         res.y *= length;
-
         return res;
     }
-
     /**
      * Normalize current vector.
      * @public
      * @returns {Vec2}
      */
-    public normalize(): Vec2 {
+    normalize() {
         let length = 1.0 / this.length();
-
         this.x *= length;
         this.y *= length;
-
         return this;
     }
-
     /**
      * Converts vector to a number array.
      * @public
      * @returns {Array.<number>} - (exactly 2 entries)
      */
-    public toVec(): NumberArray2 {
+    toVec() {
         return [this.x, this.y];
     }
-
     /**
      * Gets distance to point.
      * @public
      * @param {Vec2} p - Distant point.
      * @returns {number}
      */
-    public distance(p: Vec2): number {
+    distance(p) {
         let vec = Vec2.sub(this, p);
         return vec.length();
     }
-
     /**
      * Sets vector's values.
      * @public
@@ -407,32 +349,29 @@ export class Vec2 {
      * @param {number} y - Value Y.
      * @returns {Vec2}
      */
-    public set(x: number, y: number): Vec2 {
+    set(x, y) {
         this.x = x;
         this.y = y;
         return this;
     }
-
     /**
      * Negate current vector.
      * @public
      * @returns {Vec2}
      */
-    public negate(): Vec2 {
+    negate() {
         this.x = -this.x;
         this.y = -this.y;
         return this;
     }
-
     /**
      * Negate current vector to another instance.
      * @public
      * @returns {Vec2}
      */
-    public negateTo(): Vec2 {
+    negateTo() {
         return new Vec2(-this.x, -this.y);
     }
-
     /**
      * Gets projected point coordinates of the current vector on the ray.
      * @public
@@ -440,22 +379,20 @@ export class Vec2 {
      * @param {Vec2} direction - Ray direction.
      * @returns {Vec2}
      */
-    public projToRay(pos: Vec2, direction: Vec2): Vec2 {
+    projToRay(pos, direction) {
         let v = Vec2.proj_b_to_a(Vec2.sub(this, pos), direction);
         v.add(pos);
         return v;
     }
-
     /**
      * Gets angle between two vectors.
      * @public
      * @param {Vec2} a - Another vector.
      * @returns {number}
      */
-    public angle(a: Vec2): number {
+    angle(a) {
         return Vec2.angle(this, a);
     }
-
     /**
      * Returns two vectors linear interpolation.
      * @public
@@ -463,22 +400,22 @@ export class Vec2 {
      * @param {number} l - Interpolate value.
      * @returns {Vec2}
      */
-    public lerp(v1: Vec2, v2: Vec2, l: number): Vec2 {
+    lerp(v1, v2, l) {
         let res = this.clone();
         if (l <= 0.0) {
             res.copy(v1);
-        } else if (l >= 1.0) {
+        }
+        else if (l >= 1.0) {
             res.copy(v2);
-        } else {
+        }
+        else {
             res = Vec2.add(v1, Vec2.sub(v2, v1).scale(l));
         }
         return res;
     }
-
-    static get LERP_DELTA(): number {
+    static get LERP_DELTA() {
         return 1e-6;
     }
-
     /**
      * Spherically interpolates between two vectors.
      * Interpolates between current and v2 vector by amount t. The difference between this and linear interpolation (aka, "lerp") is that
@@ -489,34 +426,31 @@ export class Vec2 {
      * @param {number} t - The parameter t is clamped to the range [0, 1].
      * @returns {Vec2}
      */
-    public slerp(v2: Vec2, t: number): Vec2 {
+    slerp(v2, t) {
         let res = new Vec2();
-
         if (t <= 0.0) {
             res.copy(this);
             return res;
-        } else if (t >= 1.0) {
+        }
+        else if (t >= 1.0) {
             res.copy(v2);
             return res;
         }
-
         let omega, sinom, scale0, scale1;
         let cosom = this.dot(v2);
-
         if (1.0 - cosom > Vec2.LERP_DELTA) {
             omega = Math.acos(cosom);
             sinom = Math.sin(omega);
             scale0 = Math.sin((1.0 - t) * omega) / sinom;
             scale1 = Math.sin(t * omega) / sinom;
-        } else {
+        }
+        else {
             scale0 = 1.0 - t;
             scale1 = t;
         }
-
         return Vec2.add(this.scale(scale0), v2.scale(scale1));
     }
 }
-
 /**
  * Vector 2d object creator.
  * @function
@@ -524,6 +458,6 @@ export class Vec2 {
  * @param {number} [y] - Second value.
  * @returns {Vec2}
  */
-export function vec2(x: number = 0, y: number = 0): Vec2 {
+export function vec2(x = 0, y = 0) {
     return new Vec2(x, y);
 }