@openglobus/og 0.11.1 → 0.11.6

package/src/og/math/Vec2.js

@@ -2,9 +2,9 @@
  * @module og/math/Vec2
  */
 
-'use strict';
+"use strict";
 
-import { Vec3 } from './Vec3.js';
+import { Vec3 } from "./Vec3.js";
 
 /**
  * Class represents a 3d vector.
@@ -13,9 +13,7 @@ import { Vec3 } from './Vec3.js';
  * @param {number} [y] - Second value.
  */
 export class Vec2 {
-
     constructor(x, y) {
-
         /**
          * @public
          * @type {number}
@@ -27,156 +25,166 @@ export class Vec2 {
          * @type {number}
          */
         this.y = y || 0.0;
-    };
+    }
     /** @const */
-    static get UP() { return new Vec2(0, 1) };
+    static get UP() {
+        return new Vec2(0, 1);
+    }
     /** @const */
-    static get DOWN() { return new Vec2(0, -1) };
+    static get DOWN() {
+        return new Vec2(0, -1);
+    }
     /** @const */
-    static get RIGHT() { return new Vec2(1, 0) };
+    static get RIGHT() {
+        return new Vec2(1, 0);
+    }
     /** @const */
-    static get LEFT() { return new Vec2(-1, 0) };
+    static get LEFT() {
+        return new Vec2(-1, 0);
+    }
     /** @const */
-    static get ZERO() { return new Vec2() };
+    static get ZERO() {
+        return new Vec2();
+    }
 
     /**
      * Returns summary vector.
      * @static
-     * @param {og.math.Vec2} a - First vector.
-     * @param {og.math.Vec2} b - Second vector.
-     * @returns {og.math.Vec2} - Summary vector.
+     * @param {math.Vec2} a - First vector.
+     * @param {math.Vec2} b - Second vector.
+     * @returns {math.Vec2} - Summary vector.
      */
     static add(a, b) {
         var res = new Vec2(a.x, a.y);
         res.addA(b);
         return res;
-    };
+    }
 
     /**
      * Returns two vectors subtraction.
      * @static
-     * @param {og.math.Vec2} a - First vector.
-     * @param {og.math.Vec2} b - Second vector.
-     * @returns {og.math.Vec2} - Vectors subtraction.
+     * @param {math.Vec2} a - First vector.
+     * @param {math.Vec2} b - Second vector.
+     * @returns {math.Vec2} - Vectors subtraction.
      */
     static sub(a, b) {
         var res = new Vec2(a.x, a.y);
         res.subA(b);
         return res;
-    };
+    }
 
     /**
      * Returns scaled vector.
      * @static
-     * @param {og.math.Vec2} a - Input vector.
+     * @param {math.Vec2} a - Input vector.
      * @param {number} scale - Scale value.
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     static scale(a, scale) {
         var res = new Vec2(a.x, a.y);
         res.scale(scale);
         return res;
-    };
+    }
 
     /**
      * Returns two vectors production.
      * @static
-     * @param {og.math.Vec2} a - First vector.
-     * @param {og.math.Vec2} b - Second vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} a - First vector.
+     * @param {math.Vec2} b - Second vector.
+     * @returns {math.Vec2}
      */
     static mul(a, b) {
         var res = new Vec2(a.x, a.y);
         res.mulA(b);
         return res;
-    };
+    }
 
     /**
      * Returns vector components division product one to another.
      * @static
-     * @param {og.math.Vec2} a - First vector.
-     * @param {og.math.Vec2} b - Second vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} a - First vector.
+     * @param {math.Vec2} b - Second vector.
+     * @returns {math.Vec2}
      */
     static div(a, b) {
         var res = new Vec2(a.x, a.y);
         res.divA(b);
         return res;
-    };
+    }
 
     /**
      * Get projection of the first vector to the second.
      * @static
-     * @param {og.math.Vec2} b - First vector.
-     * @param {og.math.Vec2} a - Second vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} b - First vector.
+     * @param {math.Vec2} a - Second vector.
+     * @returns {math.Vec2}
      */
     static proj_b_to_a(b, a) {
         return a.scaleTo(a.dot(b) / a.dot(a));
-    };
+    }
 
     /**
      * Gets angle between two vectors.
      * @static
-     * @param {og.math.Vec2} a - First vector.
-     * @param {og.math.Vec2} b - Second vector.
+     * @param {math.Vec2} a - First vector.
+     * @param {math.Vec2} b - Second vector.
      * @returns {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
-     * @param {og.math.Vec2} normal - Normal vector.
-     * @param {og.math.Vec2} tangent - Tangent vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} normal - Normal vector.
+     * @param {math.Vec2} tangent - Tangent vector.
+     * @returns {math.Vec2}
      */
     static orthoNormalize(normal, tangent) {
         normal = normal.norm();
         normal.scale(tangent.dot(normal));
         return tangent.sub(normal).normalize();
-    };
+    }
 
     /**
      * Converts to 3d vector, third value is 0.0.
      * @public
-     * @returns {og.Vec3}
+     * @returns {Vec3}
      */
     toVector3() {
         return new Vec3(this.x, this.y, 0);
-    };
+    }
 
     /**
      * Returns clone vector.
      * @public
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     clone() {
         return new Vec2(this.x, this.y);
-    };
+    }
 
     /**
      * Compares with vector. Returns true if it equals another.
      * @public
-     * @param {og.math.Vec2} p - Vector to compare.
+     * @param {math.Vec2} p - Vector to compare.
      * @returns {boolean}
      */
     equal(p) {
         return this.x === p.x && this.y === p.y;
-    };
+    }
 
     /**
      * Copy input vector's values.
-     * @param {og.math.Vec2} point2 - Vector to copy.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} point2 - Vector to copy.
+     * @returns {math.Vec2}
      */
     copy(point2) {
         this.x = point2.x;
         this.y = point2.y;
         return this;
-    };
+    }
 
     /**
      * Gets vector's length.
@@ -185,7 +193,7 @@ export class Vec2 {
      */
     length() {
         return Math.sqrt(this.x * this.x + this.y * this.y);
-    };
+    }
 
     /**
      * Returns squared vector's length.
@@ -194,152 +202,152 @@ export class Vec2 {
      */
     length2() {
         return this.x * this.x + this.y * this.y;
-    };
+    }
 
     /**
      * Adds vector to the current.
      * @public
-     * @param {og.math.Vec2}
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2}
+     * @returns {math.Vec2}
      */
     addA(v) {
         this.x += v.x;
         this.y += v.y;
         return this;
-    };
+    }
 
     /**
      * Summarize two vectors.
      * @public
-     * @param {og.math.Vec2}
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2}
+     * @returns {math.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 {og.math.Vec2} v - Subtract vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} v - Subtract vector.
+     * @returns {math.Vec2}
      */
     subA(v) {
         this.x -= v.x;
         this.y -= v.y;
         return this;
-    };
+    }
 
     /**
      * Subtract vector from the current.
      * @public
-     * @param {og.math.Vec2} v - Subtract vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} v - Subtract vector.
+     * @returns {math.Vec2}
      */
     sub(v) {
         return new Vec2(this.x - v.x, this.y - v.y);
-    };
+    }
 
     /**
      * Scale current vector.
      * @public
      * @param {number} scale - Scale value.
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     scale(scale) {
         this.x *= scale;
         this.y *= scale;
         return this;
-    };
+    }
 
     /**
      * Scale current vector to another instance.
      * @public
      * @param {number} scale - Scale value.
-     * @returns {og.math.Vec2}
+     * @returns {math.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 {og.math.Vec2} vec - Multiply vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} vec - Multiply vector.
+     * @returns {math.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 {og.math.Vec2} vec - Multiply vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} vec - Multiply vector.
+     * @returns {math.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 {og.math.Vec2}
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2}
+     * @returns {math.Vec2}
      */
     divA(vec) {
         this.x /= vec.x;
         this.y /= vec.y;
         return this;
-    };
+    }
 
     /**
      * Gets vectors dot production.
      * @public
-     * @param {og.math.Vec2} v - Another vector.
+     * @param {math.Vec2} v - Another vector.
      * @returns {number}
      */
     dot(v) {
         return v.x * this.x + v.y * this.y;
-    };
+    }
 
     /**
      * Gets vectors dot production.
      * @public
-     * @param {Array.<number,number>} arr - Array vector.
+     * @param {Array.<number>} arr - Array vector. (exactly 2 entries)
      * @returns {number}
      */
     dotArr(arr) {
         return arr[0] * this.x + arr[1] * this.y;
-    };
+    }
 
     /**
      * Gets vectors cross production.
      * @public
-     * @param {og.math.Vec2} v - Another vector.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} v - Another vector.
+     * @returns {math.Vec2}
      */
     cross(v) {
         return this.x * v.y - this.y * v.x;
-    };
+    }
 
     /**
      * Sets vector to zero.
      * @public
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     clear() {
         this.x = this.y = 0;
         return this;
-    };
+    }
 
     /**
      * Returns normalized vector.
      * @public
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     normal() {
         var res = new Vec2();
@@ -351,12 +359,12 @@ export class Vec2 {
         res.y *= length;
 
         return res;
-    };
+    }
 
     /**
      * Normalize current vector.
      * @public
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     normalize() {
         var length = 1.0 / this.length();
@@ -365,90 +373,90 @@ export class Vec2 {
         this.y *= length;
 
         return this;
-    };
+    }
 
     /**
      * Converts vector to a number array.
      * @public
-     * @returns {Array.<number,number>}
+     * @returns {Array.<number>} - (exactly 2 entries)
      */
     toVec() {
         return [this.x, this.y];
-    };
+    }
 
     /**
      * Gets distance to point.
      * @public
-     * @param {og.math.Vec2} p - Distant point.
+     * @param {math.Vec2} p - Distant point.
      * @returns {number}
      */
     distance(p) {
         var vec = Vec2.sub(this, p);
         return vec.length();
-    };
+    }
 
     /**
      * Sets vector's values.
      * @public
      * @param {number} x - Value X.
      * @param {number} y - Value Y.
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     set(x, y) {
         this.x = x;
         this.y = y;
         return this;
-    };
+    }
 
     /**
      * Negate current vector.
      * @public
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     negate() {
         this.x = -this.x;
         this.y = -this.y;
         return this;
-    };
+    }
 
     /**
      * Negate current vector to another instance.
      * @public
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     negateTo() {
         return new Vec2(-this.x, -this.y);
-    };
+    }
 
     /**
      * Gets projected point coordinates of the current vector on the ray.
      * @public
-     * @param {og.math.Vec2} pos - Ray position.
-     * @param {og.math.Vec2} direction - Ray direction.
-     * @returns {og.math.Vec2}
+     * @param {math.Vec2} pos - Ray position.
+     * @param {math.Vec2} direction - Ray direction.
+     * @returns {math.Vec2}
      */
     projToRay(pos, direction) {
         var v = Vec2.proj_b_to_a(Vec2.sub(this, pos), direction);
         v.add(pos);
         return v;
-    };
+    }
 
     /**
      * Gets angle between two vectors.
      * @public
-     * @param {og.math.Vec2} a - Another vector.
+     * @param {math.Vec2} a - Another vector.
      * @returns {number}
      */
     angle(a) {
         return Vec2.angle(this, a);
-    };
+    }
 
     /**
      * Returns two vectors linear interpolation.
      * @public
-     * @param {og.math.Vec2} v2 - End vector.
+     * @param {math.Vec2} v2 - End vector.
      * @param {number} l - Interpolate value.
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     lerp(v1, v2, l) {
         var res = Vec2.clone(this);
@@ -460,19 +468,21 @@ export class Vec2 {
             res = Vec2.add(v1, Vec2.sub(v2, v1).scale(l));
         }
         return res;
-    };
+    }
 
-    static get LERP_DELTA() { return 1e-6 };
+    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 
-     * the vectors are treated as directions rather than points in space. The direction of the returned vector is interpolated 
+     * Interpolates between current and v2 vector by amount t. The difference between this and linear interpolation (aka, "lerp") is that
+     * the vectors are treated as directions rather than points in space. The direction of the returned vector is interpolated
      * by the angle and its magnitude is interpolated between the magnitudes of from and to.
      * @public
-     * @param {og.math.Vec2} v2 - 
+     * @param {math.Vec2} v2 -
      * @param {number} t - The parameter t is clamped to the range [0, 1].
-     * @returns {og.math.Vec2}
+     * @returns {math.Vec2}
      */
     slerp(v2, t) {
         var res = new Vec2();
@@ -488,7 +498,7 @@ export class Vec2 {
         var omega, sinom, scale0, scale1;
         var cosom = this.dot(v2);
 
-        if ((1.0 - cosom) > Vec2.LERP_DELTA) {
+        if (1.0 - cosom > Vec2.LERP_DELTA) {
             omega = Math.acos(cosom);
             sinom = Math.sin(omega);
             scale0 = Math.sin((1.0 - t) * omega) / sinom;
@@ -499,7 +509,7 @@ export class Vec2 {
         }
 
         return Vec2.add(this.scale(scale0), v2.scale(scale1));
-    };
+    }
 }
 
 /**
@@ -507,8 +517,8 @@ export class Vec2 {
  * @function
  * @param {number} [x] - First cvalue.
  * @param {number} [y] - Second value.
- * @returns {og.math.Vec2}
+ * @returns {math.Vec2}
  */
 export function vec2(x, y) {
     return new Vec2(x, y);
-};
+}