@openglobus/og 0.18.0 → 0.18.1

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

@@ -1,8 +1,7 @@
 import * as math from "../math";
-import {Vec3} from "./Vec3";
-import {Mat4} from "./Mat4";
-import {Mat3} from "./Mat3";
-
+import { Vec3 } from "./Vec3";
+import { Mat4 } from "./Mat4";
+import { Mat3 } from "./Mat3";
 /**
  * A set of 4-dimensional coordinates used to represent rotation in 3-dimensional space.
  * @constructor
@@ -12,87 +11,50 @@ import {Mat3} from "./Mat3";
  * @param {Number} [w=0.0] The W component.
  */
 export class Quat {
-    /**
-     * The X component.
-     * @public
-     * @type {Number}
-     * @default 0.0
-     */
-    public x: number;
-
-    /**
-     * The Y component.
-     * @public
-     * @type {Number}
-     * @default 0.0
-     */
-    public y: number;
-
-    /**
-     * The Z component.
-     * @public
-     * @type {Number}
-     * @default 0.0
-     */
-    public z: number;
-
-    /**
-     * The W component.
-     * @public
-     * @type {Number}
-     * @default 0.0
-     */
-    public w: number;
-
-    constructor(x: number = 0.0, y: number = 0.0, z: number = 0.0, w: number = 0.0) {
+    constructor(x = 0.0, y = 0.0, z = 0.0, w = 0.0) {
         this.x = x;
         this.y = y;
         this.z = z;
         this.w = w;
     }
-
     /**
      * Identity Quat.
      * @const
      * @type {Quat}
      */
-    static get IDENTITY(): Quat {
+    static get IDENTITY() {
         return new Quat(0.0, 0.0, 0.0, 1.0);
     }
-
     /**
      * Returns a Quat represents rotation around X axis.
      * @static
      * @param {number} a - The angle in radians to rotate around the axis.
      * @returns {Quat} -
      */
-    static xRotation(a: number): Quat {
+    static xRotation(a) {
         a *= 0.5;
         return new Quat(Math.sin(a), 0.0, 0.0, Math.cos(a));
     }
-
     /**
      * Returns a Quat represents rotation around Y axis.
      * @static
      * @param {number} a - The angle in radians to rotate around the axis.
      * @returns {Quat} -
      */
-    static yRotation(a: number): Quat {
+    static yRotation(a) {
         a *= 0.5;
         return new Quat(0.0, Math.sin(a), 0.0, Math.cos(a));
     }
-
     /**
      * Returns a Quat represents rotation around Z axis.
      * @static
      * @param {number} a - The angle in radians to rotate around the axis.
      * @returns {Quat} -
      */
-    static zRotation(a: number): Quat {
+    static zRotation(a) {
         a *= 0.5;
         return new Quat(0.0, 0.0, Math.sin(a), Math.cos(a));
     }
-
     /**
      * Computes a Quat representing a rotation around an axis.
      * @static
@@ -100,13 +62,12 @@ export class Quat {
      * @param {number} [angle=0.0] The angle in radians to rotate around the axis.
      * @returns {Quat} -
      */
-    static axisAngleToQuat(axis: Vec3, angle: number = 0): Quat {
+    static axisAngleToQuat(axis, angle = 0) {
         let v = axis.getNormal();
         let half_angle = angle * 0.5;
         let sin_a = Math.sin(half_angle);
         return new Quat(v.x * sin_a, v.y * sin_a, v.z * sin_a, Math.cos(half_angle));
     }
-
     /**
      * Computes a rotation from the given heading and up vector.
      * @static
@@ -114,31 +75,26 @@ export class Quat {
      * @param {Vec3} up - Up vector.
      * @returns {Quat} -
      */
-    static getLookRotation(forward: Vec3, up: Vec3): Quat {
+    static getLookRotation(forward, up) {
         let f = forward.getNormal().negate();
         let s = up.cross(f).normalize();
         let u = f.cross(s);
         let z = 1.0 + s.x + u.y + f.z;
-
         if (z > 0.000001) {
             let fd = 1.0 / (2.0 * Math.sqrt(z));
             return new Quat((f.y - u.z) * fd, (s.z - f.x) * fd, (u.x - s.y) * fd, 0.25 / fd);
         }
-
         if (s.x > u.y && s.x > f.z) {
             let fd = 1.0 / (2.0 * Math.sqrt(1.0 + s.x - u.y - f.z));
             return new Quat(0.25 / fd, (u.x + s.y) * fd, (s.z + f.x) * fd, (f.y - u.z) * fd);
         }
-
         if (u.y > f.z) {
             let fd = 1.0 / (2.0 * Math.sqrt(1.0 + u.y - s.x - f.z));
             return new Quat((u.x + s.y) * fd, 0.25 / fd, (f.y + u.z) * fd, (s.z - f.x) * fd);
         }
-
         let fd = 1.0 / (2.0 * Math.sqrt(1.0 + f.z - s.x - u.y));
         return new Quat((s.z + f.x) * fd, (f.y + u.z) * fd, 0.25 / fd, (u.x - s.y) * fd);
     }
-
     /**
      * Computes a Quat from source point heading to the destination point.
      * @static
@@ -146,7 +102,7 @@ export class Quat {
      * @param {Vec3} destPoint - Destination coordinate.
      * @returns {Quat} -
      */
-    static getLookAtSourceDest(sourcePoint: Vec3, destPoint: Vec3): Quat {
+    static getLookAtSourceDest(sourcePoint, destPoint) {
         let forwardVector = destPoint.subA(sourcePoint).normalize();
         let dot = Vec3.FORWARD.dot(forwardVector);
         if (Math.abs(dot - -1.0) < 0.000001) {
@@ -159,7 +115,6 @@ export class Quat {
         let rotAxis = Vec3.FORWARD.cross(forwardVector).normalize();
         return Quat.axisAngleToQuat(rotAxis, rotAngle);
     }
-
     /**
      * Compute rotation between two vectors.
      * @static
@@ -167,12 +122,11 @@ export class Quat {
      * @param {Vec3} v - Second vector.
      * @returns {Quat} -
      */
-    static getRotationBetweenVectors(u: Vec3, v: Vec3): Quat {
+    static getRotationBetweenVectors(u, v) {
         let w = u.cross(v);
         let q = new Quat(w.x, w.y, w.z, 1.0 + u.dot(v));
         return q.normalize();
     }
-
     /**
      * Compute rotation between two vectors.
      * @static
@@ -181,12 +135,11 @@ export class Quat {
      * @param {Quat} res
      * @returns {Quat} -
      */
-    static getRotationBetweenVectorsRes(u: Vec3, v: Vec3, res: Quat): Quat {
+    static getRotationBetweenVectorsRes(u, v, res) {
         let w = u.cross(v);
         res.set(w.x, w.y, w.z, 1.0 + u.dot(v));
         return res.normalize();
     }
-
     /**
      * Compute rotation between two vectors with around vector up
      * for exactly opposite vectors. If vectors exactly in the same
@@ -197,7 +150,7 @@ export class Quat {
      * @param {Vec3} up - Up vector.
      * @returns {Quat} -
      */
-    static getRotationBetweenVectorsUp(source: Vec3, dest: Vec3, up: Vec3): Quat {
+    static getRotationBetweenVectorsUp(source, dest, up) {
         let dot = source.dot(dest);
         if (Math.abs(dot + 1.0) < 0.000001) {
             // vector source and dest point exactly in the opposite direction,
@@ -213,26 +166,23 @@ export class Quat {
         let rotAxis = source.cross(dest).normalize();
         return Quat.axisAngleToQuat(rotAxis, rotAngle);
     }
-
     /**
      * Returns true if the components are zero.
      * @public
      * @returns {boolean} -
      */
-    public isZero(): boolean {
+    isZero() {
         return this.x === 0.0 && this.y === 0.0 && this.z === 0.0 && this.w === 0.0;
     }
-
     /**
      * Clear Quat. Sets zeroes.
      * @public
      * @returns {Quat} -
      */
-    public clear(): Quat {
+    clear() {
         this.x = this.y = this.z = this.w = 0;
         return this;
     }
-
     /**
      * Sets Quat values.
      * @public
@@ -242,103 +192,94 @@ export class Quat {
      * @param {Number} [w=0.0] The W component.
      * @returns {Quat} -
      */
-    public set(x: number, y: number, z: number, w: number): Quat {
+    set(x, y, z, w) {
         this.x = x;
         this.y = y;
         this.z = z;
         this.w = w;
         return this;
     }
-
     /**
      * Copy Quat values.
      * @public
      * @param {Quat} q - Copy Quat.
      * @returns {Quat} -
      */
-    public copy(q: Quat): Quat {
+    copy(q) {
         this.x = q.x;
         this.y = q.y;
         this.z = q.z;
         this.w = q.w;
         return this;
     }
-
     /**
      * Set current Quat instance to identity Quat.
      * @public
      * @returns {Quat} -
      */
-    public setIdentity(): Quat {
+    setIdentity() {
         this.x = 0.0;
         this.y = 0.0;
         this.z = 0.0;
         this.w = 1.0;
         return this;
     }
-
     /**
      * Duplicates a Quat instance.
      * @public
      * @returns {Quat} -
      */
-    public clone(): Quat {
+    clone() {
         return new Quat(this.x, this.y, this.z, this.w);
     }
-
     /**
      * Computes the componentwise sum of two Quats.
      * @public
      * @param {Quat} q - Quat to add.
      * @returns {Quat} -
      */
-    public add(q: Quat): Quat {
+    add(q) {
         return new Quat(this.x + q.x, this.y + q.y, this.z + q.z, this.w + q.w);
     }
-
     /**
      * Computes the componentwise difference of two Quats.
      * @public
      * @param {Quat} q - Quat to subtract.
      * @returns {Quat} -
      */
-    public sub(q: Quat): Quat {
+    sub(q) {
         return new Quat(this.x - q.x, this.y - q.y, this.z - q.z, this.w - q.w);
     }
-
     /**
      * Multiplies the provided Quat componentwise by the provided scalar.
      * @public
      * @param {Number} scale - The scalar to multiply with.
      * @returns {Quat} -
      */
-    public scaleTo(scale: number): Quat {
+    scaleTo(scale) {
         return new Quat(this.x * scale, this.y * scale, this.z * scale, this.w * scale);
     }
-
     /**
      * Multiplies the provided Quat componentwise.
      * @public
      * @param {Number} scale - The scalar to multiply with.
      * @returns {Quat} -
      */
-    public scale(scale: number): Quat {
+    scale(scale) {
         this.x *= scale;
         this.y *= scale;
         this.z *= scale;
         this.w *= scale;
         return this;
     }
-
     /**
      * Converts Quat values to array.
      * @public
      * @returns {Array.<number>} - (exactly 4 entries)
      */
-    public toVec(): [number, number, number, number] {
+    toVec() {
         return [this.x, this.y, this.z, this.w];
     }
-
     /**
      * Sets current quaternion by spherical coordinates.
      * @public
@@ -347,22 +288,19 @@ export class Quat {
      * @param {number} angle - Angle in radians.
      * @returns {Quat} -
      */
-    public setFromSphericalCoords(lat: number, lon: number, angle: number): Quat {
+    setFromSphericalCoords(lat, lon, angle) {
         let sin_a = Math.sin(angle / 2);
         let cos_a = Math.cos(angle / 2);
         let sin_lat = Math.sin(lat);
         let cos_lat = Math.cos(lat);
         let sin_long = Math.sin(lon);
         let cos_long = Math.cos(lon);
-
         this.x = sin_a * cos_lat * sin_long;
         this.y = sin_a * sin_lat;
         this.z = sin_a * sin_lat * cos_long;
         this.w = cos_a;
-
         return this;
     }
-
     /**
      * Sets rotation with the given heading and up vectors.
      * @static
@@ -370,79 +308,72 @@ export class Quat {
      * @param {Vec3} up - Up vector.
      * @returns {Quat} -
      */
-    public setLookRotation(forward: Vec3, up: Vec3): Quat {
+    setLookRotation(forward, up) {
         let f = forward.getNormal().negate();
         let s = up.cross(f).normalize();
         let u = f.cross(s);
         let z = 1.0 + s.x + u.y + f.z;
-
         if (z > 0.000001) {
             let fd = 1.0 / (2.0 * Math.sqrt(z));
             this.x = (f.y - u.z) * fd;
             this.y = (s.z - f.x) * fd;
             this.z = (u.x - s.y) * fd;
             this.w = 0.25 / fd;
-        } else if (s.x > u.y && s.x > f.z) {
+        }
+        else if (s.x > u.y && s.x > f.z) {
             let fd = 1.0 / (2.0 * Math.sqrt(1.0 + s.x - u.y - f.z));
             this.x = 0.25 / fd;
             this.y = (u.x + s.y) * fd;
             this.z = (s.z + f.x) * fd;
             this.w = (f.y - u.z) * fd;
-        } else if (u.y > f.z) {
+        }
+        else if (u.y > f.z) {
             let fd = 1.0 / (2.0 * Math.sqrt(1.0 + u.y - s.x - f.z));
             this.x = (u.x + s.y) * fd;
             this.y = 0.25 / fd;
             this.z = (f.y + u.z) * fd;
             this.w = (s.z - f.x) * fd;
-        } else {
+        }
+        else {
             let fd = 1.0 / (2.0 * Math.sqrt(1.0 + f.z - s.x - u.y));
             this.x = (s.z + f.x) * fd;
             this.y = (f.y + u.z) * fd;
             this.z = 0.25 / fd;
             this.w = (u.x - s.y) * fd;
         }
-
         return this;
     }
-
     /**
      * Gets spherical coordinates.
      * @public
      * @returns {Object} Returns object with latitude, longitude and alpha.
      */
-    public toSphericalCoords(): any {
-
+    toSphericalCoords() {
         let cos_a = this.w;
         let sin_a = Math.sqrt(1.0 - cos_a * cos_a);
-
         // var angle = Math.acos(cos_a) * 2;
         if (Math.abs(sin_a) < 0.0005) {
             sin_a = 1;
         }
-
         let tx = this.x / sin_a;
         let ty = this.y / sin_a;
         let tz = this.z / sin_a;
-
         let lon, lat = -Math.asin(ty);
-
         if (tx * tx + tz * tz < 0.0005) {
             lon = 0;
-        } else {
+        }
+        else {
             lon = Math.atan2(tx, tz);
         }
-
         if (lon < 0) {
             lon += 360.0;
         }
-
         return {
             lat: lat,
             lon: lon,
             alpha: Math.acos(cos_a)
         };
     }
-
     /**
      * Sets current Quat representing a rotation around an axis.
      * @public
@@ -450,24 +381,20 @@ export class Quat {
      * @param {number} angle The angle in radians to rotate around the axis.
      * @returns {Quat} -
      */
-    public setFromAxisAngle(axis: Vec3, angle: number): Quat {
+    setFromAxisAngle(axis, angle) {
         let v = axis.getNormal();
         let half_angle = angle * 0.5;
         let sin_a = Math.sin(half_angle);
         this.set(v.x * sin_a, v.y * sin_a, v.z * sin_a, Math.cos(half_angle));
         return this;
     }
-
     /**
      * Returns axis and angle of the current Quat.
      * @public
      * @returns {Object} -
      */
-    public getAxisAngle(): any {
-        let x = this.x,
-            y = this.y,
-            z = this.z,
-            w = this.w;
+    getAxisAngle() {
+        let x = this.x, y = this.y, z = this.z, w = this.w;
         let vl = Math.sqrt(x * x + y * y + z * z);
         let axis, angle;
         if (vl > 0.0000001) {
@@ -475,20 +402,20 @@ export class Quat {
             axis = new Vec3(x * ivl, y * ivl, z * ivl);
             if (w < 0) {
                 angle = 2.0 * Math.atan2(-vl, -w); // -PI,0
-            } else {
+            }
+            else {
                 angle = 2.0 * Math.atan2(vl, w); // 0,PI
             }
-        } else {
+        }
+        else {
             axis = new Vec3(0, 0, 0);
             angle = 0;
         }
-
         return {
             axis: axis,
             angle: angle
         };
     }
-
     /**
      * Sets current Quat by Euler's angles.
      * @public
@@ -497,80 +424,53 @@ export class Quat {
      * @param {number} roll - Roll angle in degrees.
      * @returns {Quat} -
      */
-    public setFromEulerAngles(pitch: number, yaw: number, roll: number): Quat {
-        let ex = pitch * math.RADIANS_HALF,
-            ey = yaw * math.RADIANS_HALF,
-            ez = roll * math.RADIANS_HALF;
-
-        let cr = Math.cos(ex),
-            cp = Math.cos(ey),
-            cy = Math.cos(ez);
-
-        let sr = Math.sin(ex),
-            sp = Math.sin(ey),
-            sy = Math.sin(ez);
-
-        let cpcy = cp * cy,
-            spsy = sp * sy;
-
+    setFromEulerAngles(pitch, yaw, roll) {
+        let ex = pitch * math.RADIANS_HALF, ey = yaw * math.RADIANS_HALF, ez = roll * math.RADIANS_HALF;
+        let cr = Math.cos(ex), cp = Math.cos(ey), cy = Math.cos(ez);
+        let sr = Math.sin(ex), sp = Math.sin(ey), sy = Math.sin(ez);
+        let cpcy = cp * cy, spsy = sp * sy;
         this.w = cr * cpcy + sr * spsy;
         this.x = sr * cpcy - cr * spsy;
         this.y = cr * sp * cy + sr * cp * sy;
         this.z = cr * cp * sy - sr * sp * cy;
-
         return this.normalize();
     }
-
     /**
      * Returns Euler's angles of the current Quat.
      * @public
      * @returns {Object} -
      */
-    public getEulerAngles(): any {
-        let x = this.x,
-            y = this.y,
-            z = this.z,
-            w = this.w;
-
+    getEulerAngles() {
+        let x = this.x, y = this.y, z = this.z, w = this.w;
         let sqy = y * y;
-
         let roll = Math.atan2(2.0 * (w * x + y * z), 1.0 - 2.0 * (x * x + sqy));
-
         let a = w * y - z * x;
-
         if (a < -1.0) {
             a = -1.0;
-        } else if (a > 1.0) {
+        }
+        else if (a > 1.0) {
             a = 1.0;
         }
         let pitch = Math.asin(2.0 * a);
-
         let yaw = Math.atan2(2.0 * (w * z + x * y), 1.0 - 2.0 * (sqy + z * z));
-
         return {
             roll,
             pitch,
             yaw
         };
     }
-
     /**
      * Computes a Quat from the provided 4x4 matrix instance.
      * @public
      * @param {Mat4} mx - The rotation matrix.
      * @returns {Quat} -
      */
-    public setFromMatrix4(mx: Mat4): Quat {
-        let tr,
-            s,
-            q = [];
+    setFromMatrix4(mx) {
+        let tr, s, q = [];
         let i, j, k;
         let m = mx._m;
-
         let nxt = [1, 2, 0];
-
         tr = m[0] + m[5] + m[10];
-
         if (tr > 0.0) {
             s = Math.sqrt(tr + 1.0);
             this.w = s / 2.0;
@@ -578,23 +478,22 @@ export class Quat {
             this.x = (m[6] - m[9]) * s;
             this.y = (m[8] - m[2]) * s;
             this.z = (m[1] - m[4]) * s;
-        } else {
+        }
+        else {
             i = 0;
-            if (m[5] > m[0]) i = 1;
-            if (m[10] > m[i * 5]) i = 2;
+            if (m[5] > m[0])
+                i = 1;
+            if (m[10] > m[i * 5])
+                i = 2;
             j = nxt[i];
             k = nxt[j];
-
             s = Math.sqrt(m[i * 5] - (m[j * 5] + m[k * 5]) + 1.0);
-
             q[i] = s * 0.5;
-
-            if (s !== 0.0) s = 0.5 / s;
-
+            if (s !== 0.0)
+                s = 0.5 / s;
             q[3] = (m[j * 4 + k] - m[k * 4 + j]) * s;
             q[j] = (m[i * 4 + j] + m[j * 4 + i]) * s;
             q[k] = (m[i * 4 + k] + m[k * 4 + i]) * s;
-
             this.x = q[0];
             this.y = q[1];
             this.z = q[2];
@@ -602,14 +501,13 @@ export class Quat {
         }
         return this;
     }
-
     /**
      * Converts current Quat to the rotation 4x4 matrix.
      * @public
      * @params {Mat4} [out] - Output matrix
      * @returns {Mat4} -
      */
-    public getMat4(out: Mat4 = new Mat4()): Mat4 {
+    getMat4(out = new Mat4()) {
         let xs = this.x + this.x;
         let ys = this.y + this.y;
         let zs = this.z + this.z;
@@ -622,7 +520,6 @@ export class Quat {
         let yy = this.y * ys;
         let yz = this.y * zs;
         let zz = this.z * zs;
-
         return out.set([
             1 - (yy + zz), xy - wz, xz + wy, 0,
             xy + wz, 1 - (xx + zz), yz - wx, 0,
@@ -630,36 +527,23 @@ export class Quat {
             0, 0, 0, 1
         ]);
     }
-
     /**
      * Converts current Quat to the rotation 3x3 matrix.
      * @public
      * @returns {Mat3} -
      * @todo NOT TESTED
      */
-    public getMat3(): Mat3 {
+    getMat3() {
         let m = new Mat3();
         let mx = m._m;
-        let c = this.x,
-            d = this.y,
-            e = this.z,
-            g = this.w,
-            f = c + c,
-            h = d + d,
-            i = e + e,
-            j = c * f,
-            k = c * h;
-
+        let c = this.x, d = this.y, e = this.z, g = this.w, f = c + c, h = d + d, i = e + e, j = c * f, k = c * h;
         c = c * i;
-
         let l = d * h;
-
         d = d * i;
         e = e * i;
         f = g * f;
         h = g * h;
         g = g * i;
-
         mx[0] = 1 - (l + e);
         mx[1] = k - g;
         mx[2] = c + h;
@@ -669,160 +553,100 @@ export class Quat {
         mx[6] = c - h;
         mx[7] = d + f;
         mx[8] = 1 - (j + l);
-
         return m;
     }
-
     /**
      * Returns quaternion and vector production.
      * @public
      * @param {Vec3} v - 3d Vector.
      * @returns {Vec3} -
      */
-    public mulVec3(v: Vec3): Vec3 {
+    mulVec3(v) {
         // t = 2 * cross(q.xyz, v)
         // v' = v + q.w * t + cross(q.xyz, t)
-
-        let d = v.x,
-            e = v.y,
-            g = v.z;
-
-        let b = this.x,
-            f = this.y,
-            h = this.z,
-            a = this.w;
-
-        let i = a * d + f * g - h * e,
-            j = a * e + h * d - b * g,
-            k = a * g + b * e - f * d;
-
+        let d = v.x, e = v.y, g = v.z;
+        let b = this.x, f = this.y, h = this.z, a = this.w;
+        let i = a * d + f * g - h * e, j = a * e + h * d - b * g, k = a * g + b * e - f * d;
         d = -b * d - f * e - h * g;
-
-        return new Vec3(
-            i * a + d * -b + j * -h - k * -f,
-            j * a + d * -f + k * -b - i * -h,
-            k * a + d * -h + i * -f - j * -b
-        );
+        return new Vec3(i * a + d * -b + j * -h - k * -f, j * a + d * -f + k * -b - i * -h, k * a + d * -h + i * -f - j * -b);
     }
-
     /**
      * Computes the product of two Quats.
      * @public
      * @param {Quat} q - Quat to multiply.
      * @returns {Quat} -
      */
-    public mul(q: Quat): Quat {
-        let d = this.x,
-            e = this.y,
-            g = this.z,
-            a = this.w;
-
-        let f = q.x,
-            h = q.y,
-            i = q.z,
-            b = q.w;
-
-        return new Quat(
-            d * b + a * f + e * i - g * h,
-            e * b + a * h + g * f - d * i,
-            g * b + a * i + d * h - e * f,
-            a * b - d * f - e * h - g * i
-        );
-    }
-
+    mul(q) {
+        let d = this.x, e = this.y, g = this.z, a = this.w;
+        let f = q.x, h = q.y, i = q.z, b = q.w;
+        return new Quat(d * b + a * f + e * i - g * h, e * b + a * h + g * f - d * i, g * b + a * i + d * h - e * f, a * b - d * f - e * h - g * i);
+    }
     /**
      * Computes the product of two Quats.
      * @public
      * @param {Quat} q - Quat to multiply.
      * @returns {Quat} -
      */
-    public mulA(q: Quat): Quat {
-        let d = this.x,
-            e = this.y,
-            g = this.z,
-            a = this.w;
-
-        let f = q.x,
-            h = q.y,
-            i = q.z,
-            b = q.w;
-
+    mulA(q) {
+        let d = this.x, e = this.y, g = this.z, a = this.w;
+        let f = q.x, h = q.y, i = q.z, b = q.w;
         this.x = d * b + a * f + e * i - g * h;
         this.y = e * b + a * h + g * f - d * i;
         this.z = g * b + a * i + d * h - e * f;
         this.w = a * b - d * f - e * h - g * i;
-
         return this;
     }
-
     /**
      * Gets the conjugate of the Quat.
      * @public
      * @returns {Quat} -
      */
-    public conjugate(): Quat {
+    conjugate() {
         return new Quat(-this.x, -this.y, -this.z, this.w);
     }
-
     /**
      * Computes the inverse of the Quat.
      * @public
      * @returns {Quat} -
      */
-    public inverse(): Quat {
+    inverse() {
         let n = 1.0 / this.magnitude2();
         return new Quat(-this.x * n, -this.y * n, -this.z * n, this.w * n);
     }
-
     /**
      * Computes a magnitude of the Quat.
      * @public
      * @returns {number} -
      */
-    public magnitude(): number {
-        let b = this.x,
-            c = this.y,
-            d = this.z,
-            a = this.w;
+    magnitude() {
+        let b = this.x, c = this.y, d = this.z, a = this.w;
         return Math.sqrt(b * b + c * c + d * d + a * a);
     }
-
     /**
      * Computes a squared magnitude of the Quat.
      * @public
      * @returns {number} -
      */
-    public magnitude2(): number {
-        let b = this.x,
-            c = this.y,
-            d = this.z,
-            a = this.w;
+    magnitude2() {
+        let b = this.x, c = this.y, d = this.z, a = this.w;
         return b * b + c * c + d * d + a * a;
     }
-
     /**
      * Computes the dot (scalar) product of two Quats.
      * @public
      * @param {Quat} q - Second quaternion.
      * @returns {number} -
      */
-    public dot(q: Quat): number {
+    dot(q) {
         return this.x * q.x + this.y * q.y + this.z * q.z;
     }
-
     /**
      * Current Quat normalization.
      * @public
      * @returns {Quat} -
      */
-    public normalize(): Quat {
-
-        let c = this.x,
-            d = this.y,
-            e = this.z,
-            g = this.w,
-            f = Math.sqrt(c * c + d * d + e * e + g * g);
-
+    normalize() {
+        let c = this.x, d = this.y, e = this.z, g = this.w, f = Math.sqrt(c * c + d * d + e * e + g * g);
         if (f === 0.0) {
             this.x = 0;
             this.y = 0;
@@ -830,30 +654,26 @@ export class Quat {
             this.w = 0;
             return this;
         }
-
         f = 1 / f;
         this.x = c * f;
         this.y = d * f;
         this.z = e * f;
         this.w = g * f;
-
         return this;
     }
-
     /**
      * Compares two Quats.
      * @public
      * @param {Quat} q - Second quaternion.
      * @returns {Boolean} -
      */
-    public isEqual(q: Quat): boolean {
+    isEqual(q) {
         let matching = this.dot(q);
         if (Math.abs(matching - 1.0) < 0.001) {
             return true;
         }
         return false;
     }
-
     /**
      * Performs a spherical linear interpolation between two Quats.
      * @public
@@ -861,21 +681,10 @@ export class Quat {
      * @param {number} t - interpolation amount between the two Quats.
      * @returns {Quat} -
      */
-    public slerp(b: Quat, t: number): Quat {
-
-        let ax = this.x,
-            ay = this.y,
-            az = this.z,
-            aw = this.w,
-            bx = b.x,
-            by = b.y,
-            bz = b.z,
-            bw = b.w;
-
+    slerp(b, t) {
+        let ax = this.x, ay = this.y, az = this.z, aw = this.w, bx = b.x, by = b.y, bz = b.z, bw = b.w;
         let omega, cosom, sinom, scale0, scale1;
-
         cosom = ax * bx + ay * by + az * bz + aw * bw;
-
         if (cosom < 0.0) {
             cosom = -cosom;
             bx = -bx;
@@ -883,38 +692,26 @@ export class Quat {
             bz = -bz;
             bw = -bw;
         }
-
         if (1.0 - cosom > 0.000001) {
             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 new Quat(
-            scale0 * ax + scale1 * bx,
-            scale0 * ay + scale1 * by,
-            scale0 * az + scale1 * bz,
-            scale0 * aw + scale1 * bw
-        );
+        return new Quat(scale0 * ax + scale1 * bx, scale0 * ay + scale1 * by, scale0 * az + scale1 * bz, scale0 * aw + scale1 * bw);
     }
-
     /**
      * Returns a roll angle in radians.
      * @public
      * @param {Boolean} [reprojectAxis] -
      * @returns {Number} -
      */
-    public getRoll(reprojectAxis: boolean = false): number {
-
-        let x = this.x,
-            y = this.y,
-            z = this.z,
-            w = this.w;
-
+    getRoll(reprojectAxis = false) {
+        let x = this.x, y = this.y, z = this.z, w = this.w;
         if (reprojectAxis) {
             let fTy = 2.0 * y;
             let fTz = 2.0 * z;
@@ -923,24 +720,19 @@ export class Quat {
             let fTyy = fTy * y;
             let fTzz = fTz * z;
             return Math.atan2(fTxy + fTwz, 1.0 - (fTyy + fTzz));
-        } else {
+        }
+        else {
             return Math.atan2(2 * (x * y + w * z), w * w + x * x - y * y - z * z);
         }
     }
-
     /**
      * Returns a pitch angle in radians.
      * @public
      * @param {Boolean} [reprojectAxis] -
      * @returns {number} -
      */
-    public getPitch(reprojectAxis: boolean = false): number {
-
-        let x = this.x,
-            y = this.y,
-            z = this.z,
-            w = this.w;
-
+    getPitch(reprojectAxis = false) {
+        let x = this.x, y = this.y, z = this.z, w = this.w;
         if (reprojectAxis) {
             let fTx = 2.0 * x;
             let fTz = 2.0 * z;
@@ -949,24 +741,19 @@ export class Quat {
             let fTyz = fTz * y;
             let fTzz = fTz * z;
             return Math.atan2(fTyz + fTwx, 1.0 - (fTxx + fTzz));
-        } else {
+        }
+        else {
             return Math.atan2(2 * (y * z + w * x), w * w - x * x - y * y + z * z);
         }
     }
-
     /**
      * Returns a yaw angle in radians.
      * @public
      * @param {Boolean} [reprojectAxis] -
      * @returns {number} -
      */
-    public getYaw(reprojectAxis: boolean = false): number {
-
-        let x = this.x,
-            y = this.y,
-            z = this.z,
-            w = this.w;
-
+    getYaw(reprojectAxis = false) {
+        let x = this.x, y = this.y, z = this.z, w = this.w;
         if (reprojectAxis) {
             let fTx = 2.0 * x;
             let fTy = 2.0 * y;
@@ -976,12 +763,12 @@ export class Quat {
             let fTxz = fTz * x;
             let fTyy = fTy * y;
             return Math.atan2(fTxz + fTwy, 1.0 - (fTxx + fTyy));
-        } else {
+        }
+        else {
             return Math.asin(-2 * (x * z - w * y));
         }
     }
 }
-
 /**
  * Creates Quat instance.
  * @function
@@ -991,6 +778,6 @@ export class Quat {
  * @param {Number} [w=0.0] The W component.
  * @returns {Quat} -
  */
-export function quat(x: number = 0, y: number = 0, z: number = 0, w: number = 0): Quat {
+export function quat(x = 0, y = 0, z = 0, w = 0) {
     return new Quat(x, y, z, w);
 }