@openglobus/og 0.11.5 → 0.12.0

package/src/og/math/Plane.js

@@ -1,7 +1,7 @@
-'use strict';
+"use strict";
 
-import * as math from '../math.js';
-import { Vec3 } from './Vec3.js';
+import * as math from "../math.js";
+import { Vec3 } from "./Vec3.js";
 
 /**
  * Plane class.
@@ -11,8 +11,8 @@ import { Vec3 } from './Vec3.js';
  */
 class Plane {
     constructor(p, n) {
-        this.p = (p ? p.clone() : new Vec3());
-        this.n = (n ? n.clone() : this.p.normal());
+        this.p = p ? p.clone() : new Vec3();
+        this.n = n ? n.clone() : this.p.normal();
     }
 
     set(p, n) {
@@ -47,27 +47,28 @@ class Plane {
     }
 
     getIntersection(Pn1, Pn2, L) {
-
         var u = Pn1.n.cross(Pn2.n);
 
-        var ax = (u.x >= 0 ? u.x : -u.x);
-        var ay = (u.y >= 0 ? u.y : -u.y);
-        var az = (u.z >= 0 ? u.z : -u.z);
+        var ax = u.x >= 0 ? u.x : -u.x;
+        var ay = u.y >= 0 ? u.y : -u.y;
+        var az = u.z >= 0 ? u.z : -u.z;
 
         // test if the two planes are parallel
-        if ((ax + ay + az) < math.EPSILON5) {  // Pn1 and Pn2 are near parallel
+        if (ax + ay + az < math.EPSILON5) {
+            // Pn1 and Pn2 are near parallel
             // test if disjoint or coincide
             var v = Pn2.p.sub(Pn1.p);
-            if (Pn1.n.dot(v) == 0) {    // Pn2.V0 lies in Pn1
-                return 1;               // Pn1 and Pn2 coincide
+            if (Pn1.n.dot(v) == 0) {
+                // Pn2.V0 lies in Pn1
+                return 1; // Pn1 and Pn2 coincide
             } else {
-                return 0;               // Pn1 and Pn2 are disjoint
+                return 0; // Pn1 and Pn2 are disjoint
             }
         }
 
         // Pn1 and Pn2 intersect in a line
         // first determine max abs coordinate of cross product
-        var maxc;                       // max coordinate
+        var maxc; // max coordinate
         if (ax > ay) {
             if (ax > az) {
                 maxc = 1;
@@ -86,9 +87,9 @@ class Plane {
         // zero the max coord, and solve for the other two
         var iP = new Vec3(); // intersect point
 
-        var d1, d2;                     // the constants in the 2 plane equations
-        d1 = -Pn1.n.dot(Pn1.p);         // note: could be pre-stored  with plane
-        d2 = -Pn2.n.dot(Pn2.p);         // ditto
+        var d1, d2; // the constants in the 2 plane equations
+        d1 = -Pn1.n.dot(Pn1.p); // note: could be pre-stored  with plane
+        d2 = -Pn2.n.dot(Pn2.p); // ditto
 
         // select max coordinate
         if (maxc === 1) {
@@ -113,4 +114,4 @@ class Plane {
     }
 }
 
-export { Plane };
+export { Plane };

package/src/og/math/Ray.js

@@ -2,10 +2,10 @@
  * @module og/math/Ray
  */
 
-'use strict';
+"use strict";
 
-import * as math from '../math.js';
-import { Vec3 } from './Vec3.js';
+import * as math from "../math.js";
+import { Vec3 } from "./Vec3.js";
 
 /**
  * Represents a ray that extends infinitely from the provided origin in the provided direction.
@@ -15,7 +15,6 @@ import { Vec3 } from './Vec3.js';
  */
 export class Ray {
     constructor(origin, direction) {
-
         /**
          * The origin of the ray.
          * @public
@@ -32,14 +31,22 @@ export class Ray {
     }
 
     /** @const */
-    static get OUTSIDE() { return 0; }
+    static get OUTSIDE() {
+        return 0;
+    }
 
     /** @const */
-    static get INSIDE() { return 1; }
+    static get INSIDE() {
+        return 1;
+    }
     /** @const */
-    static get INPLANE() { return 2; }
+    static get INPLANE() {
+        return 2;
+    }
     /** @const */
-    static get AWAY() { return 3; }
+    static get AWAY() {
+        return 3;
+    }
 
     /**
      * Sets a ray parameters.
@@ -71,7 +78,7 @@ export class Ray {
      * @param {Vec3} v1 - Second triangle corner coordinate.
      * @param {Vec3} v2 - Third triangle corner coordinate.
      * @param {Vec3} res - Hit point object pointer that stores hit result.
-     * @returns {number} - Hit code, could 0 - og.Ray.OUTSIDE, 1 - og.Ray.INSIDE, 
+     * @returns {number} - Hit code, could 0 - og.Ray.OUTSIDE, 1 - og.Ray.INSIDE,
      *      2 - og.Ray.INPLANE and 3 - og.Ray.AWAY(ray goes away from triangle).
      */
     hitTriangle(v0, v1, v2, res, normal) {
@@ -120,7 +127,7 @@ export class Ray {
         }
 
         var t = (uv * wu - uu * wv) / D;
-        if (t < 0.0 || (s + t) > 1.0) {
+        if (t < 0.0 || s + t > 1.0) {
             return Ray.OUTSIDE;
         }
 
@@ -218,7 +225,6 @@ export class Ray {
         // TODO
         //
     }
-
 }
 
 /**
@@ -231,4 +237,3 @@ export class Ray {
 export function ray(origin, direction) {
     return new Ray(origin, direction);
 }
-

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}
@@ -29,15 +27,25 @@ export class Vec2 {
         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.
@@ -462,15 +470,17 @@ export class Vec2 {
         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 {math.Vec2} v2 - 
+     * @param {math.Vec2} v2 -
      * @param {number} t - The parameter t is clamped to the range [0, 1].
      * @returns {math.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;

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}
@@ -38,25 +36,45 @@ export class Vec3 {
     }
 
     /** @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.
@@ -67,8 +85,9 @@ export class Vec3 {
      * @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;
@@ -110,8 +129,9 @@ export class Vec3 {
      * @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;
@@ -245,7 +265,7 @@ export class Vec3 {
      * @static
      * @param {Vec3} b - Vector to project.
      * @param {Vec3} n - Plane normal.
-    * @param {Vec3} [def] - Default value for non existed result.
+     * @param {Vec3} [def] - Default value for non existed result.
      * @returns {Vec3} -
      */
     static proj_b_to_plane(b, n, def) {
@@ -679,8 +699,24 @@ export class Vec3 {
      * @param {Vec3} point3 - Distant point.
      * @returns {number} -
      */
-    distance(point3) {
-        return Vec3.sub(this, point3).length();
+    distance(point3) {
+        let dx = this.x - point3.x,
+            dy = this.y - point3.y,
+            dz = this.z - point3.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    /**
+     * Gets square distance to point.
+     * @public
+     * @param {Vec3} point3 - Distant point.
+     * @returns {number} -
+     */
+    distance2(point3) {
+        let dx = this.x - point3.x,
+            dy = this.y - point3.y,
+            dz = this.z - point3.z;
+        return dx * dx + dy * dy + dz * dz;
     }
 
     /**
@@ -750,7 +786,11 @@ export class 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
+        );
     }
 
     /**
@@ -762,18 +802,24 @@ export class 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 {Vec3} v2 - 
+     * @param {Vec3} v2 -
      * @param {number} t - The parameter t is clamped to the range [0, 1].
      * @returns {Vec3} -
      */
@@ -791,7 +837,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;
@@ -825,14 +871,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();
@@ -862,4 +909,3 @@ export class Vec3 {
 export function vec3(x, y, z) {
     return new Vec3(x, y, z);
 }
-

package/src/og/math/coder.js

@@ -2,10 +2,10 @@
  * @module og/math/coder
  */
 
-'use strict';
+"use strict";
 
-import * as math from '../math.js';
-import { Vec4 } from './Vec4.js';
+import * as math from "../math.js";
+import { Vec4 } from "./Vec4.js";
 
 /**
  * Encode 32 bit float value to the RGBA vector.
@@ -14,7 +14,7 @@ import { Vec4 } from './Vec4.js';
  * @returns {math.Vec4} - RGBA vector value.
  */
 export function encodeFloatToRGBA(v) {
-    var enc = new Vec4(1.0 * v % 1, 255.0 * v % 1, 65025.0 * v % 1, 160581375.0 * v % 1);
+    var enc = new Vec4((1.0 * v) % 1, (255.0 * v) % 1, (65025.0 * v) % 1, (160581375.0 * v) % 1);
     var yzww = new Vec4(enc.y / 255, enc.z / 255, enc.w / 255, 0);
     return enc.subA(yzww);
 }
@@ -28,7 +28,7 @@ export function encodeFloatToRGBA(v) {
 export function decodeFloatFromRGBA(rgba) {
     var s = 1.0 - math.step(128.0, rgba.x) * 2.0;
     var e = 2.0 * math.mod(rgba.x, 128.0) + math.step(128.0, rgba.y) - 127.0;
-    var m = math.mod(rgba.y, 128.0) * 65536.0 + rgba.z * 256.0 + rgba.w + 8388608.00;
+    var m = math.mod(rgba.y, 128.0) * 65536.0 + rgba.z * 256.0 + rgba.w + 8388608.0;
     return s * math.exp2(e) * (m * 1.1920928955078125e-7);
 }
 
@@ -41,7 +41,7 @@ export function decodeFloatFromRGBA(rgba) {
 export function decodeFloatFromRGBAArr(arr, use32) {
     var s = 1.0 - math.step(128.0, arr[0]) * 2.0;
     var e = 2.0 * math.mod(arr[0], 128.0) + math.step(128.0, arr[1]) - 127.0;
-    var m = math.mod(arr[1], 128.0) * 65536.0 + arr[2] * 256.0 + (use32 ? arr[3] : 0.0) + 8388608.00;
+    var m = math.mod(arr[1], 128.0) * 65536.0 + arr[2] * 256.0 + (use32 ? arr[3] : 0.0) + 8388608.0;
     return s * math.exp2(e) * (m * 1.1920928955078125e-7);
 }
 
@@ -101,4 +101,4 @@ export function doubleToTwoFloatsV2(value, highLowVec) {
         highLowVec.y = Math.fround(value + doubleHigh);
     }
     return highLowVec;
-}
+}

package/src/og/proj/EPSG3857.js

@@ -2,12 +2,12 @@
  * @module og/proj/EPSG3857
  */
 
-'use strict';
+"use strict";
 
-import { Units, Proj } from './Proj.js';
+import { Units, Proj } from "./Proj.js";
 
 /**
  * EPSG:3857 projection object.
  * @type {Proj}
  */
-export const EPSG3857 = new Proj({ code: "epsg:3857", units: Units.METERS });
+export const EPSG3857 = new Proj({ code: "epsg:3857", units: Units.METERS });

package/src/og/proj/EPSG4326.js

@@ -2,12 +2,12 @@
  * @module og/proj/EPSG4326
  */
 
-'use strict';
+"use strict";
 
-import { Units, Proj } from './Proj.js';
+import { Units, Proj } from "./Proj.js";
 
 /**
  * EPSG:4326 projection object.
  * @type {Proj}
  */
-export const EPSG4326 = new Proj({ code: "epsg:4326", units: Units.DEGREES });
+export const EPSG4326 = new Proj({ code: "epsg:4326", units: Units.DEGREES });

package/src/og/proj/Proj.js

@@ -2,7 +2,7 @@
  * @module og/proj/Proj
  */
 
-'use strict';
+"use strict";
 
 /**
  * Projection units: 'degrees', 'ft', 'm' or 'km'.
@@ -28,9 +28,7 @@ METERS_PER_UNIT[Units.KILOMETERS] = 1000;
 
 let _counter = 0;
 class Proj {
-
     constructor(options) {
-
         /**
          * @public
          * @type {string}
@@ -62,4 +60,4 @@ class Proj {
     }
 }
 
-export { Proj };
+export { Proj };