@openglobus/og 0.11.1 → 0.11.6

package/src/og/math/Vec3.js

@@ -2,10 +2,10 @@
  * @module og/math/Vec3
  */
 
-'use strict';
+"use strict";
 
-import { Vec4 } from './Vec4.js';
-import { Quat } from './Quat.js';
+import { Vec4 } from "./Vec4.js";
+import { Quat } from "./Quat.js";
 
 /**
  * Class represents a 3d vector.
@@ -15,9 +15,7 @@ import { Quat } from './Quat.js';
  * @param {number} [z] - Third value.
  */
 export class Vec3 {
-
     constructor(x, y, z) {
-
         /**
          * @public
          * @type {number}
@@ -35,28 +33,48 @@ export class Vec3 {
          * @type {number}
          */
         this.z = z || 0.0;
-    };
+    }
 
     /** @const */
-    static get UP() { return new Vec3(0, 1, 0) };
+    static get UP() {
+        return new Vec3(0, 1, 0);
+    }
     /** @const */
-    static get DOWN() { return new Vec3(0, -1, 0) };
+    static get DOWN() {
+        return new Vec3(0, -1, 0);
+    }
     /** @const */
-    static get RIGHT() { return new Vec3(1, 0, 0) };
+    static get RIGHT() {
+        return new Vec3(1, 0, 0);
+    }
     /** @const */
-    static get LEFT() { return new Vec3(-1, 0, 0) };
+    static get LEFT() {
+        return new Vec3(-1, 0, 0);
+    }
     /** @const */
-    static get FORWARD() { return new Vec3(0, 0, -1) };
+    static get FORWARD() {
+        return new Vec3(0, 0, -1);
+    }
     /** @const */
-    static get BACKWARD() { return new Vec3(0, 0, 1) };
+    static get BACKWARD() {
+        return new Vec3(0, 0, 1);
+    }
     /** @const */
-    static get ZERO() { return new Vec3() };
+    static get ZERO() {
+        return new Vec3();
+    }
     /** @const */
-    static get UNIT_X() { return new Vec3(1, 0, 0) };
+    static get UNIT_X() {
+        return new Vec3(1, 0, 0);
+    }
     /** @const */
-    static get UNIT_Y() { return new Vec3(0, 1, 0) };
+    static get UNIT_Y() {
+        return new Vec3(0, 1, 0);
+    }
     /** @const */
-    static get UNIT_Z() { return new Vec3(0, 0, 1) };
+    static get UNIT_Z() {
+        return new Vec3(0, 0, 1);
+    }
 
     /**
      * Separate 63 bit Vec3 to two Vec3 32 bit float values.
@@ -64,11 +82,12 @@ export class Vec3 {
      * @param {number} value - Double type value.
      * @param {Vec3} high - Out vector high values.
      * @param {Vec3} low - Out vector low values.
-     * @returns {Array.<number,number>} Encoded array.
+     * @returns {Array.<number>} Encoded array. (exactly 2 entries)
      */
     static doubleToTwoFloats(v, high, low) {
-
-        let x = v.x, y = v.y, z = v.z;
+        let x = v.x,
+            y = v.y,
+            z = v.z;
 
         if (x >= 0.0) {
             let doubleHigh = Math.floor(x / 65536.0) * 65536.0;
@@ -99,7 +118,7 @@ export class Vec3 {
             high.z = Math.fround(-doubleHigh);
             low.z = Math.fround(z + doubleHigh);
         }
-    };
+    }
 
     /**
      * Separate 63 bit Vec3 to two Vec3 32 bit float values.
@@ -107,11 +126,12 @@ export class Vec3 {
      * @param {number} value - Double type value.
      * @param {Float32Array} high - Out vector high values.
      * @param {Float32Array} low - Out vector low values.
-     * @returns {Array.<number,number>} Encoded array.
+     * @returns {Array.<number>} Encoded array. (exactly 2 entries)
      */
     static doubleToTwoFloat32Array(v, high, low) {
-
-        let x = v.x, y = v.y, z = v.z;
+        let x = v.x,
+            y = v.y,
+            z = v.z;
 
         if (x >= 0.0) {
             let doubleHigh = Math.floor(x / 65536.0) * 65536.0;
@@ -142,111 +162,111 @@ export class Vec3 {
             high[2] = Math.fround(-doubleHigh);
             low[2] = Math.fround(z + doubleHigh);
         }
-    };
+    }
 
     /**
      * Creates 3d vector from array.
      * @function
-     * @param {Array.<number,number,number>} arr - Input array
-     * @returns {og.Vec3} -
+     * @param {Array.<number>} arr - Input array (exactly 3 entries)
+     * @returns {Vec3} -
      */
     static fromVec(arr) {
         return new Vec3(arr[0], arr[1], arr[2]);
-    };
+    }
 
     /**
      * Gets angle between two vectors.
      * @static
-     * @param {og.Vec3} a - First vector.
-     * @param {og.Vec3} b - Second vector.
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
      * @returns {number} -
      */
     static angle(a, b) {
         return Math.acos(a.dot(b) / Math.sqrt(a.length2() * b.length2()));
-    };
+    }
 
     /**
      * Returns two vectors linear interpolation.
      * @static
-     * @param {og.Vec3} v1 - Start vector.
-     * @param {og.Vec3} v2 - End vector.
+     * @param {Vec3} v1 - Start vector.
+     * @param {Vec3} v2 - End vector.
      * @param {number} l - Interpolate value.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     static lerp(v1, v2, l) {
         return Vec3(v1.x + (v2.x - v1.x) * l, v1.y + (v2.y - v1.y) * l, v1.z + (v2.z - v1.z) * l);
-    };
+    }
 
     /**
      * Returns summary vector.
      * @static
-     * @param {og.Vec3} a - First vector.
-     * @param {og.Vec3} b - Second vector.
-     * @returns {og.Vec3} - Summary vector.
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} - Summary vector.
      */
     static add(a, b) {
         var res = new Vec3(a.x, a.y, a.z);
         res.addA(b);
         return res;
-    };
+    }
 
     /**
      * Returns two vectors subtraction.
      * @static
-     * @param {og.Vec3} a - First vector.
-     * @param {og.Vec3} b - Second vector.
-     * @returns {og.Vec3} - Vectors subtraction.
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} - Vectors subtraction.
      */
     static sub(a, b) {
         var res = new Vec3(a.x, a.y, a.z);
         res.subA(b);
         return res;
-    };
+    }
 
     /**
      * Returns scaled vector.
      * @static
-     * @param {og.Vec3} a - Input vector.
+     * @param {Vec3} a - Input vector.
      * @param {number} scale - Scale value.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     static scale(a, scale) {
         var res = new Vec3(a.x, a.y, a.z);
         res.scale(scale);
         return res;
-    };
+    }
 
     /**
      * Returns two vectors production.
      * @static
-     * @param {og.Vec3} a - First vector.
-     * @param {og.Vec3} b - Second vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} -
      */
     static mul(a, b) {
         var res = new Vec3(a.x, a.y, a.z);
         res.mulA(b);
         return res;
-    };
+    }
 
     /**
      * Returns true if two vectors are non collinear.
      * @public
-     * @param {og.Vec3} a - First vector.
-     * @param {og.Vec3} b - Second vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} -
      */
     static noncollinear(a, b) {
         return a.y * b.z - a.z * b.y || a.z * b.x - a.x * b.z || a.x * b.y - a.y * b.z;
-    };
+    }
 
     /**
      * Get projection of the vector to plane where n - normal to the plane.
      * @static
-     * @param {og.Vec3} b - Vector to project.
-     * @param {og.Vec3} n - Plane normal.
-    * @param {og.Vec3} [def] - Default value for non existed result.
-     * @returns {og.Vec3} -
+     * @param {Vec3} b - Vector to project.
+     * @param {Vec3} n - Plane normal.
+     * @param {Vec3} [def] - Default value for non existed result.
+     * @returns {Vec3} -
      */
     static proj_b_to_plane(b, n, def) {
         var res = b.sub(n.scaleTo(n.dot(b) / n.dot(n)));
@@ -254,63 +274,63 @@ export class Vec3 {
             return new Vec3(def.x, def.y, def.z);
         }
         return res;
-    };
+    }
 
     /**
      * Get projection of the first vector to the second.
      * @static
-     * @param {og.Vec3} b - First vector.
-     * @param {og.Vec3} a - Second vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} b - First vector.
+     * @param {Vec3} a - Second vector.
+     * @returns {Vec3} -
      */
     static proj_b_to_a(b, a) {
         return a.scaleTo(a.dot(b) / a.dot(a));
-    };
+    }
 
     /**
      * Makes vectors normalized and orthogonal to each other.
      * Normalizes normal. Normalizes tangent and makes sure it is orthogonal to normal (that is, angle between them is 90 degrees).
      * @static
-     * @param {og.Vec3} normal - Normal vector.
-     * @param {og.Vec3} tangent - Tangent vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} normal - Normal vector.
+     * @param {Vec3} tangent - Tangent vector.
+     * @returns {Vec3} -
      */
     static orthoNormalize(normal, tangent) {
         normal = normal.normal();
         normal.scale(tangent.dot(normal));
         return tangent.subA(normal).normalize();
-    };
+    }
 
     /**
      * Returns vector components division product one to another.
      * @static
-     * @param {og.Vec3} a - First vector.
-     * @param {og.Vec3} b - Second vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} a - First vector.
+     * @param {Vec3} b - Second vector.
+     * @returns {Vec3} -
      */
     static div(a, b) {
         var res = new Vec3(a.x, a.y, a.z);
         res.divA(b);
         return res;
-    };
+    }
 
     /**
      * Converts to 4d vector, Fourth value is 1.0.
      * @public
-     * @returns {og.Vec4} -
+     * @returns {Vec4} -
      */
     toVec4() {
         return new Vec4(this.x, this.y, this.z, 1.0);
-    };
+    }
 
     /**
      * Returns clone vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     clone() {
         return new Vec3(this.x, this.y, this.z);
-    };
+    }
 
     /**
      * Converts vector to text string.
@@ -319,7 +339,7 @@ export class Vec3 {
      */
     toString() {
         return "(" + this.x + "," + this.y + "," + this.z + ")";
-    };
+    }
 
     /**
      * Returns true if vector's values are zero.
@@ -328,39 +348,39 @@ export class Vec3 {
      */
     isZero() {
         return !(this.x || this.y || this.z);
-    };
+    }
 
     /**
      * Get projection of the first vector to the second.
      * @static
-     * @param {og.Vec3} a - Project vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} a - Project vector.
+     * @returns {Vec3} -
      */
     projToVec(a) {
         return a.scaleTo(a.dot(this) / a.dot(a));
-    };
+    }
 
     /**
      * Compares with vector. Returns true if it equals another.
      * @public
-     * @param {og.Vec3} p - Vector to compare.
+     * @param {Vec3} p - Vector to compare.
      * @returns {boolean} -
      */
     equal(p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
-    };
+    }
 
     /**
      * Copy input vector's values.
-     * @param {og.Vec3} point3 - Vector to copy.
-     * @returns {og.Vec3} -
+     * @param {Vec3} point3 - Vector to copy.
+     * @returns {Vec3} -
      */
     copy(point3) {
         this.x = point3.x;
         this.y = point3.y;
         this.z = point3.z;
         return this;
-    };
+    }
 
     /**
      * Gets vector's length.
@@ -369,7 +389,7 @@ export class Vec3 {
      */
     length() {
         return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-    };
+    }
 
     /**
      * Returns squared vector's length.
@@ -378,157 +398,157 @@ export class Vec3 {
      */
     length2() {
         return this.x * this.x + this.y * this.y + this.z * this.z;
-    };
+    }
 
     /**
      * Converts vector's values to a quaternion object.
      * @public
-     * @returns {og.Quat} -
+     * @returns {Quat} -
      */
     getQuat() {
         return new Quat(this.x, this.y, this.z);
-    };
+    }
 
     /**
      * Adds vector to the current.
      * @public
-     * @param {og.Vec3} point3 - Point to add.
-     * @returns {og.Vec3} -
+     * @param {Vec3} point3 - Point to add.
+     * @returns {Vec3} -
      */
     addA(point3) {
         this.x += point3.x;
         this.y += point3.y;
         this.z += point3.z;
         return this;
-    };
+    }
 
     /**
      * Gets two vectors summarization.
      * @public
-     * @param {og.Vec3} point3 - Vector to add.
-     * @returns {og.Vec3} Returns a sum vector.
+     * @param {Vec3} point3 - Vector to add.
+     * @returns {Vec3} Returns a sum vector.
      */
     add(point3) {
         return new Vec3(this.x + point3.x, this.y + point3.y, this.z + point3.z);
-    };
+    }
 
     /**
      * Subtract vector from the current.
      * @public
-     * @param {og.Vec3} point3 - Subtract vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} point3 - Subtract vector.
+     * @returns {Vec3} -
      */
     subA(point3) {
         this.x -= point3.x;
         this.y -= point3.y;
         this.z -= point3.z;
         return this;
-    };
+    }
 
     /**
      * Gets vector subtraction.
      * @public
-     * @param {og.Vec3} point3 - Subtract vector.
-     * @return {og.Vec3} Returns new instance of a subtraction
+     * @param {Vec3} point3 - Subtract vector.
+     * @return {Vec3} Returns new instance of a subtraction
      */
     sub(point3) {
         return new Vec3(this.x - point3.x, this.y - point3.y, this.z - point3.z);
-    };
+    }
 
     /**
      * Scale current vector.
      * @public
      * @param {number} scale - Scale value.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     scale(scale) {
         this.x *= scale;
         this.y *= scale;
         this.z *= scale;
         return this;
-    };
+    }
 
     /**
      * Scale current vector to another instance.
      * @public
      * @param {number} scale - Scale value.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     scaleTo(scale) {
         return new Vec3(this.x * scale, this.y * scale, this.z * scale);
-    };
+    }
 
     /**
      * Multiply current vector object to another and store result in the current instance.
      * @public
-     * @param {og.Vec3} vec - Multiply vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} vec - Multiply vector.
+     * @returns {Vec3} -
      */
     mulA(vec) {
         this.x *= vec.x;
         this.y *= vec.y;
         this.z *= vec.z;
         return this;
-    };
+    }
 
     /**
      * Multiply current vector object to another and returns new vector instance.
      * @public
-     * @param {og.Vec3} vec - Multiply vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} vec - Multiply vector.
+     * @returns {Vec3} -
      */
     mul(vec) {
         return new Vec3(this.x * vec.x, this.y * vec.y, this.z * vec.z);
-    };
+    }
 
     /**
      * Divide current vector's components to another. Results stores in the current vector object.
      * @public
-     * @param {og.Vec3} vec - Div vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} vec - Div vector.
+     * @returns {Vec3} -
      */
     divA(vec) {
         this.x /= vec.x;
         this.y /= vec.y;
         this.z /= vec.z;
         return this;
-    };
+    }
 
     /**
      * Divide current vector's components to another and returns new vector instance.
      * @public
-     * @param {og.Vec3} vec - Div vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} vec - Div vector.
+     * @returns {Vec3} -
      */
     div(vec) {
         return new Vec3(this.x / vec.x, this.y / vec.y, this.z / vec.z);
-    };
+    }
 
     /**
      * Gets vectors dot production.
      * @public
-     * @param {og.Vec3} point3 - Another vector.
+     * @param {Vec3} point3 - Another vector.
      * @returns {number} -
      */
     dot(point3) {
         return point3.x * this.x + point3.y * this.y + point3.z * this.z;
-    };
+    }
 
     /**
      * Gets vectors dot production.
      * @public
-     * @param {Array.<number,number,number>} arr - Array vector.
+     * @param {Array.<number>} arr - Array vector. (exactly 3 entries)
      * @returns {number} -
      */
     dotArr(arr) {
         return arr[0] * this.x + arr[1] * this.y + arr[2] * this.z;
-    };
+    }
 
     /**
      * Gets vectors cross production.
      * @public
-     * @param {og.Vec3} point3 - Another vector.
-     * @returns {og.Vec3} -
+     * @param {Vec3} point3 - Another vector.
+     * @returns {Vec3} -
      */
     cross(point3) {
         return new Vec3(
@@ -536,22 +556,22 @@ export class Vec3 {
             this.z * point3.x - this.x * point3.z,
             this.x * point3.y - this.y * point3.x
         );
-    };
+    }
 
     /**
      * Sets vector to zero.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     clear() {
         this.x = this.y = this.z = 0;
         return this;
-    };
+    }
 
     /**
      * Returns normalized vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     getNormal() {
         var res = new Vec3();
@@ -564,13 +584,13 @@ export class Vec3 {
         res.z *= length;
 
         return res;
-    };
+    }
 
     /**
      * Returns normalized vector.
      * @deprecated
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     normal() {
         var res = new Vec3();
@@ -583,12 +603,12 @@ export class Vec3 {
         res.z *= length;
 
         return res;
-    };
+    }
 
     /**
      * Returns normalized negate vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     normalNegate() {
         var res = new Vec3();
@@ -601,12 +621,12 @@ export class Vec3 {
         res.z *= length;
 
         return res;
-    };
+    }
 
     /**
      * Returns normalized negate scale vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     normalNegateScale(scale) {
         var res = new Vec3();
@@ -619,12 +639,12 @@ export class Vec3 {
         res.z *= length;
 
         return res;
-    };
+    }
 
     /**
      * Returns normalized scale vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     normalScale(scale) {
         var res = new Vec3();
@@ -637,12 +657,12 @@ export class Vec3 {
         res.z *= length;
 
         return res;
-    };
+    }
 
     /**
      * Normalize current vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     normalize() {
         var length = 1.0 / this.length();
@@ -652,36 +672,36 @@ export class Vec3 {
         this.z *= length;
 
         return this;
-    };
+    }
 
     /**
      * Converts vector to a number array.
      * @public
-     * @returns {Array.<number,number,number>} -
+     * @returns {Array.<number>} - (exactly 3 entries)
      * @deprecated
      */
     toVec() {
         return [this.x, this.y, this.z];
-    };
+    }
 
     /**
      * Converts vector to a number array.
      * @public
-     * @returns {Array.<number,number,number>} -
+     * @returns {Array.<number>} - (exactly 3 entries)
      */
     toArray() {
         return [this.x, this.y, this.z];
-    };
+    }
 
     /**
      * Gets distance to point.
      * @public
-     * @param {og.Vec3} point3 - Distant point.
+     * @param {Vec3} point3 - Distant point.
      * @returns {number} -
      */
     distance(point3) {
         return Vec3.sub(this, point3).length();
-    };
+    }
 
     /**
      * Sets vector's values.
@@ -689,93 +709,103 @@ export class Vec3 {
      * @param {number} x - Value X.
      * @param {number} y - Value Y.
      * @param {number} z - Value Z.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     set(x, y, z) {
         this.x = x;
         this.y = y;
         this.z = z;
         return this;
-    };
+    }
 
     /**
      * Negate current vector.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     negate() {
         this.x = -this.x;
         this.y = -this.y;
         this.z = -this.z;
         return this;
-    };
+    }
 
     /**
      * Negate current vector to another instance.
      * @public
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     negateTo() {
         return new Vec3(-this.x, -this.y, -this.z);
-    };
+    }
 
     /**
      * Gets projected point coordinates of the current vector on the ray.
      * @public
-     * @param {og.Vec3} pos - Ray position.
-     * @param {og.Vec3} direction - Ray direction.
-     * @returns {og.Vec3} -
+     * @param {Vec3} pos - Ray position.
+     * @param {Vec3} direction - Ray direction.
+     * @returns {Vec3} -
      */
     projToRay(pos, direction) {
         var v = Vec3.proj_b_to_a(Vec3.sub(this, pos), direction);
         v.addA(pos);
         return v;
-    };
+    }
 
     /**
      * Gets angle between two vectors.
      * @public
-     * @param {og.Vec3} a - Another vector.
+     * @param {Vec3} a - Another vector.
      * @returns {number} -
      */
     angle(a) {
         return Vec3.angle(this, a);
-    };
+    }
 
     /**
      * Returns two vectors linear interpolation.
      * @public
-     * @param {og.Vec3} v2 - End vector.
+     * @param {Vec3} v2 - End vector.
      * @param {number} l - Interpolate value.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     lerp(v2, l) {
-        return new Vec3(this.x + (v2.x - this.x) * l, this.y + (v2.y - this.y) * l, this.z + (v2.z - this.z) * l);
-    };
+        return new Vec3(
+            this.x + (v2.x - this.x) * l,
+            this.y + (v2.y - this.y) * l,
+            this.z + (v2.z - this.z) * l
+        );
+    }
 
     /**
      * Returns vector interpolation by v(t) = v1 * t + v2 * (1 - t)
      * @public
-     * @param {og.Vec3} v2 - End vector.
+     * @param {Vec3} v2 - End vector.
      * @param {number} t - Interpolate value.
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     smerp(v2, t) {
         var one_d = 1 - t;
-        return new Vec3(this.x * t + v2.x * one_d, this.y * t + v2.y * one_d, this.z * t + v2.z * one_d);
-    };
+        return new Vec3(
+            this.x * t + v2.x * one_d,
+            this.y * t + v2.y * one_d,
+            this.z * t + v2.z * one_d
+        );
+    }
 
-    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.Vec3} v2 - 
+     * @param {Vec3} v2 -
      * @param {number} t - The parameter t is clamped to the range [0, 1].
-     * @returns {og.Vec3} -
+     * @returns {Vec3} -
      */
     slerp(v2, t) {
         var res = new Vec3();
@@ -791,7 +821,7 @@ export class Vec3 {
         var omega, sinom, scale0, scale1;
         var cosom = this.dot(v2);
 
-        if ((1.0 - cosom) > Vec3.LERP_DELTA) {
+        if (1.0 - cosom > Vec3.LERP_DELTA) {
             omega = Math.acos(cosom);
             sinom = Math.sin(omega);
             scale0 = Math.sin((1.0 - t) * omega) / sinom;
@@ -802,7 +832,7 @@ export class Vec3 {
         }
 
         return Vec3.add(this.scaleTo(scale0), v2.scale(scale1));
-    };
+    }
 
     /**
      * Gets the shortest arc quaternion to rotate this vector to the destination vector.
@@ -825,14 +855,15 @@ export class Vec3 {
             return Quat.IDENTITY.clone();
         }
 
-        if (d < (1e-6 - 1.0)) {
+        if (d < 1e-6 - 1.0) {
             if (!fallbackAxis.isEqual(Vec3.ZERO)) {
                 // rotate 180 degrees about the fallback axis
                 return Quat.axisAngleToQuat(Math.PI, fallbackAxis);
             } else {
                 // Generate an axis
                 let axis = Vec3.UNIT_X.cross(v0);
-                if (axis.isZero()) { // pick another if colinear
+                if (axis.isZero()) {
+                    // pick another if colinear
                     axis = Vec3.UNIT_Y.cross(v0);
                 }
                 axis.normalize();
@@ -848,7 +879,7 @@ export class Vec3 {
             q.normalise();
             return q;
         }
-    };
+    }
 }
 
 /**
@@ -857,9 +888,8 @@ export class Vec3 {
  * @param {number} [x] - First cvalue.
  * @param {number} [y] - Second value.
  * @param {number} [z] - Third value.
- * @returns {og.Vec3} -
+ * @returns {Vec3} -
  */
 export function vec3(x, y, z) {
     return new Vec3(x, y, z);
-};
-
+}