@openglobus/og 0.11.1 → 0.11.6

package/src/og/math/Line3.js

@@ -3,137 +3,138 @@
 import * as math from '../math.js';
 import { Vec3 } from './Vec3.js';
 
-const Line3 = function (p0, p1) {
-    this.p0 = p0 || new Vec3();
-    this.p1 = p1 || new Vec3();
-};
-
-Line3.prototype.getMagnitude = function () {
-    return this.p0.distance(this.p1);
-};
-
-Line3.prototype.getSphereIntersection = function (sphere) {
-    var p0 = this.p0,
-        p1 = this.p1;
-
-    var cx = sphere.x,
-        cy = sphere.y,
-        cz = sphere.z;
-
-    var px = p0.x,
-        py = p0.y,
-        pz = p0.z;
-
-    var vx = p1.x - px,
-        vy = p1.y - py,
-        vz = p1.z - pz;
-
-    var A = vx * vx + vy * vy + vz * vz,
-        B = 2.0 * (px * vx + py * vy + pz * vz - vx * cx - vy * cy - vz * cz),
-        C = px * px - 2 * px * cx + cx * cx + py * py - 2 * py * cy + cy * cy +
-            pz * pz - 2 * pz * cz + cz * cz - sphere.radius * sphere.radius;
-    var D = B * B - 4 * A * C;
-
-    if (D < 0) {
-        return null;
+export class Line3 {
+    constructor(p0, p1) {
+        this.p0 = p0 || new Vec3();
+        this.p1 = p1 || new Vec3();
     }
 
-    var t1 = (-B - Math.Sqrt(D)) / (2.0 * A);
+    getMagnitude() {
+        return this.p0.distance(this.p1);
+    }
 
-    var solution1 = new Vec3(
-        p0.x * (1 - t1) + t1 * p1.x,
-        p0.y * (1 - t1) + t1 * p1.y,
-        p0.z * (1 - t1) + t1 * p1.z);
+    getSphereIntersection(sphere) {
+        var p0 = this.p0,
+            p1 = this.p1;
 
-    if (D == 0) {
-        return solution1;
-    }
+        var cx = sphere.x,
+            cy = sphere.y,
+            cz = sphere.z;
 
-    var t2 = (-B + Math.Sqrt(D)) / (2.0 * A);
-    var solution2 = new Vec3(
-        p0.x * (1 - t2) + t2 * p1.x,
-        p0.y * (1 - t2) + t2 * p1.y,
-        p0.z * (1 - t2) + t2 * p1.z);
+        var px = p0.x,
+            py = p0.y,
+            pz = p0.z;
 
-    // prefer a solution that's on the line segment itself
-    if (Math.Abs(t1 - 0.5) < Math.abs(t2 - 0.5)) {
-        return [solution1, solution2];
-    }
+        var vx = p1.x - px,
+            vy = p1.y - py,
+            vz = p1.z - pz;
 
-    return [solution2, solution1];
-};
+        var A = vx * vx + vy * vy + vz * vz,
+            B = 2.0 * (px * vx + py * vy + pz * vz - vx * cx - vy * cy - vz * cz),
+            C = px * px - 2 * px * cx + cx * cx + py * py - 2 * py * cy + cy * cy +
+                pz * pz - 2 * pz * cz + cz * cz - sphere.radius * sphere.radius;
+        var D = B * B - 4 * A * C;
 
-Line3.prototype.intersects = function (line, res, res2) {
+        if (D < 0) {
+            return null;
+        }
 
-    let p13 = this.p0.sub(line.p0),
-        p43 = line.p1.sub(line.p0);
+        var t1 = (-B - Math.Sqrt(D)) / (2.0 * A);
 
-    if (Math.abs(p43.x) < math.EPSILON10 && Math.abs(p43.y) < math.EPSILON10 && Math.abs(p43.z) < math.EPSILON10) {
-        return false;
-    }
+        var solution1 = new Vec3(
+            p0.x * (1 - t1) + t1 * p1.x,
+            p0.y * (1 - t1) + t1 * p1.y,
+            p0.z * (1 - t1) + t1 * p1.z);
 
-    let p21 = this.p1.sub(this.p0);
+        if (D == 0) {
+            return solution1;
+        }
 
-    if (Math.abs(p21.x) < math.EPSILON10 && Math.abs(p21.y) < math.EPSILON10 && Math.abs(p21.z) < math.EPSILON10) {
-        return false;
+        var t2 = (-B + Math.Sqrt(D)) / (2.0 * A);
+        var solution2 = new Vec3(
+            p0.x * (1 - t2) + t2 * p1.x,
+            p0.y * (1 - t2) + t2 * p1.y,
+            p0.z * (1 - t2) + t2 * p1.z);
+
+        // prefer a solution that's on the line segment itself
+        if (Math.Abs(t1 - 0.5) < Math.abs(t2 - 0.5)) {
+            return [solution1, solution2];
+        }
+
+        return [solution2, solution1];
     }
 
-    let d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z,
-        d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z,
-        d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z,
-        d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z,
-        d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
+    intersects(line, res, res2) {
 
-    let denom = d2121 * d4343 - d4321 * d4321;
+        let p13 = this.p0.sub(line.p0),
+            p43 = line.p1.sub(line.p0);
 
-    if (Math.abs(denom) < math.EPSILON10) {
-        return false;
-    }
+        if (Math.abs(p43.x) < math.EPSILON10 && Math.abs(p43.y) < math.EPSILON10 && Math.abs(p43.z) < math.EPSILON10) {
+            return false;
+        }
 
-    let numer = d1343 * d4321 - d1321 * d4343;
+        let p21 = this.p1.sub(this.p0);
 
-    let mua = numer / denom;
+        if (Math.abs(p21.x) < math.EPSILON10 && Math.abs(p21.y) < math.EPSILON10 && Math.abs(p21.z) < math.EPSILON10) {
+            return false;
+        }
 
-    res.x = this.p0.x + mua * p21.x;
-    res.y = this.p0.y + mua * p21.y;
-    res.z = this.p0.z + mua * p21.z;
+        let d1343 = p13.x * p43.x + p13.y * p43.y + p13.z * p43.z,
+            d4321 = p43.x * p21.x + p43.y * p21.y + p43.z * p21.z,
+            d1321 = p13.x * p21.x + p13.y * p21.y + p13.z * p21.z,
+            d4343 = p43.x * p43.x + p43.y * p43.y + p43.z * p43.z,
+            d2121 = p21.x * p21.x + p21.y * p21.y + p21.z * p21.z;
 
-    if (res2) {
+        let denom = d2121 * d4343 - d4321 * d4321;
 
-        let mub = (d1343 + d4321 * mua) / d4343;
+        if (Math.abs(denom) < math.EPSILON10) {
+            return false;
+        }
 
-        res2.x = line.p0.x + mub * p43.x;
-        res2.y = line.p0.y + mub * p43.y;
-        res2.z = line.p0.z + mub * p43.z;
+        let numer = d1343 * d4321 - d1321 * d4343;
+
+        let mua = numer / denom;
+
+        res.x = this.p0.x + mua * p21.x;
+        res.y = this.p0.y + mua * p21.y;
+        res.z = this.p0.z + mua * p21.z;
+
+        if (res2) {
+
+            let mub = (d1343 + d4321 * mua) / d4343;
+
+            res2.x = line.p0.x + mub * p43.x;
+            res2.y = line.p0.y + mub * p43.y;
+            res2.z = line.p0.z + mub * p43.z;
+        }
+
+        return true;
     }
 
-    return true;
-};
+    getNearestDistancePoint(point, res) {
 
-Line3.prototype.getNearestDistancePoint = function (point, res) {
+        let p0 = this.p0,
+            p1 = this.p1;
 
-    let p0 = this.p0,
-        p1 = this.p1;
+        let mag = this.getMagnitude();
 
-    let mag = this.getMagnitude();
+        let u =
+            (
+                ((point.x - p0.x) * (p1.x - p0.x)) +
+                ((point.y - p0.y) * (p1.y - p0.y)) +
+                ((point.z - p0.z) * (p1.z - p0.z))
+            ) /
+            (mag * mag);
 
-    let u =
-        (
-            ((point.x - p0.x) * (p1.x - p0.x)) +
-            ((point.y - p0.y) * (p1.y - p0.y)) +
-            ((point.z - p0.z) * (p1.z - p0.z))
-        ) /
-        (mag * mag);
+        res.x = p0.x + u * (p1.x - p0.x);
+        res.y = p0.y + u * (p1.y - p0.y);
+        res.z = p0.z + u * (p1.z - p0.z);
 
-    res.x = p0.x + u * (p1.x - p0.x);
-    res.y = p0.y + u * (p1.y - p0.y);
-    res.z = p0.z + u * (p1.z - p0.z);
+        if (u < 0.0 || u > 1.0) {
+            return false;
+        }
 
-    if (u < 0.0 || u > 1.0) {
-        return false;
+        return true;
     }
 
-    return true;
-};
-
-export { Line3 };
+}

package/src/og/math/Mat3.js

@@ -2,142 +2,155 @@
  * @module og/math/Mat3
  */
 
-'use strict';
+"use strict";
 
-import { Mat4 } from './Mat4.js';
-import { Vec3 } from './Vec3.js';
+import { Mat4 } from "./Mat4.js";
+import { Vec3 } from "./Vec3.js";
 
 /**
  * Class represents a 3x3 matrix.
  * @class
  */
-const Mat3 = function () {
+export class Mat3 {
+    constructor() {
+        /**
+         * A 3x3 matrix, indexable as a column-major order array.
+         * @public
+         * @type {Array.<number>}
+         */
+        this._m = new Array(9);
+    }
+
     /**
-     * A 3x3 matrix, indexable as a column-major order array.
+     * Sets column-major order array matrix.
      * @public
-     * @type {Array.<number>}
+     * @param {Array.<number>} m - Matrix array.
+     * @returns {Mat3}
      */
-    this._m = new Array(9);
-};
-
-/**
- * Mat3 factory.
- * @static
- * @return {og.Mat3}
- */
+    set(m) {
+        this._m[0] = m[0];
+        this._m[1] = m[1];
+        this._m[2] = m[2];
+        this._m[3] = m[3];
+        this._m[4] = m[4];
+        this._m[5] = m[5];
+        this._m[6] = m[6];
+        this._m[7] = m[7];
+        this._m[8] = m[8];
+        return this;
+    }
 
-export function mat3() {
-    return new Mat3();
-};
-
-/**
- * Sets column-major order array matrix.
- * @public
- * @param {Array.<number>} m - Matrix array.
- * @returns {og.Mat3}
- */
-Mat3.prototype.set = function (m) {
-    this._m[0] = m[0];
-    this._m[1] = m[1];
-    this._m[2] = m[2];
-    this._m[3] = m[3];
-    this._m[4] = m[4];
-    this._m[5] = m[5];
-    this._m[6] = m[6];
-    this._m[7] = m[7];
-    this._m[8] = m[8];
-    return this;
-};
+    /**
+     * Duplicates a Mat3 instance.
+     * @public
+     * @returns {Mat3}
+     */
+    clone() {
+        var res = new Mat3();
+        res.set(this);
+        return res;
+    }
 
-/**
- * Duplicates a Mat3 instance.
- * @public
- * @returns {og.Mat3}
- */
-Mat3.prototype.clone = function () {
-    var res = new Mat3();
-    res.set(this);
-    return res;
-};
+    /**
+     * Copy matrix.
+     * @public
+     * @param {Mat3} a - Matrix to copy.
+     * @returns {Mat3}
+     */
+    copy(a) {
+        return this.set(a._m);
+    }
 
-/**
- * Copy matrix.
- * @public
- * @param {og.Mat3} a - Matrix to copy.
- * @returns {og.Mat3}
- */
-Mat3.prototype.copy = function (a) {
-    return this.set(a._m);
-};
+    /**
+     * Creates trasposed matrix from the current.
+     * @public
+     * @returns {Mat3}
+     */
+    transposeTo() {
+        var res = new Mat3();
+        var m = this._m;
+        res._m[0] = m[0];
+        res._m[1] = m[3];
+        res._m[2] = m[6];
+        res._m[3] = m[1];
+        res._m[4] = m[4];
+        res._m[5] = m[7];
+        res._m[6] = m[2];
+        res._m[7] = m[5];
+        res._m[8] = m[8];
+        return res;
+    }
 
-/**
- * Creates trasposed matrix from the current.
- * @public
- * @returns {og.Mat3}
- */
-Mat3.prototype.transposeTo = function () {
-    var res = new Mat3();
-    var m = this._m;
-    res._m[0] = m[0]; res._m[1] = m[3]; res._m[2] = m[6];
-    res._m[3] = m[1]; res._m[4] = m[4]; res._m[5] = m[7];
-    res._m[6] = m[2]; res._m[7] = m[5]; res._m[8] = m[8];
-    return res;
-};
+    /**
+     * Sets matrix to identity.
+     * @public
+     * @returns {Mat3}
+     */
+    setIdentity() {
+        this._m[0] = 1;
+        this._m[1] = 0;
+        this._m[2] = 0;
+        this._m[3] = 0;
+        this._m[4] = 1;
+        this._m[5] = 0;
+        this._m[6] = 0;
+        this._m[7] = 0;
+        this._m[8] = 1;
+        return this;
+    }
 
-/**
- * Sets matrix to identity.
- * @public
- * @returns {og.Mat3}
- */
-Mat3.prototype.setIdentity = function () {
-    this._m[0] = 1; this._m[1] = 0; this._m[2] = 0;
-    this._m[3] = 0; this._m[4] = 1; this._m[5] = 0;
-    this._m[6] = 0; this._m[7] = 0; this._m[8] = 1;
-    return this;
-};
+    /**
+     * Multiply to 3d vector.
+     * @public
+     * @params {Vec3} p - 3d vector.
+     * @returns {Vec3}
+     */
+    mulVec(p) {
+        var d = p.x,
+            e = p.y,
+            g = p.z;
+        var m = this._m;
+        return new Vec3(
+            m[0] * d + m[3] * e + m[6] * g,
+            m[1] * d + m[4] * e + m[7] * g,
+            m[2] * d + m[5] * e + m[8] * g
+        );
+    }
 
-/**
- * Multiply to 3d vector.
- * @public
- * @params {og.Vec3} p - 3d vector.
- * @returns {og.Vec3}
- */
-Mat3.prototype.mulVec = function (p) {
-    var d = p.x, e = p.y, g = p.z;
-    var m = this._m;
-    return new Vec3(
-        m[0] * d + m[3] * e + m[6] * g,
-        m[1] * d + m[4] * e + m[7] * g,
-        m[2] * d + m[5] * e + m[8] * g
-    );
-};
+    /**
+     * Converts to 4x4 matrix.
+     * @public
+     * @returns {Mat4}
+     */
+    toMatrix4() {
+        var res = new Mat4();
+        var b = res._m;
+        var a = this._m;
+        b[0] = a[0];
+        b[1] = a[1];
+        b[2] = a[2];
+        b[3] = 0;
+        b[4] = a[3];
+        b[5] = a[4];
+        b[6] = a[5];
+        b[7] = 0;
+        b[8] = a[6];
+        b[9] = a[7];
+        b[10] = a[8];
+        b[11] = 0;
+        b[12] = 0;
+        b[13] = 0;
+        b[14] = 0;
+        b[15] = 1;
+        return res;
+    }
+}
 
 /**
- * Converts to 4x4 matrix.
- * @public
- * @returns {og.Mat4}
+ * Mat3 factory.
+ * @static
+ * @return {Mat3}
  */
-Mat3.prototype.toMatrix4 = function () {
-    var res = new Mat4();
-    var b = res._m;
-    var a = this._m;
-    b[0] = a[0];
-    b[1] = a[1];
-    b[2] = a[2];
-    b[3] = 0;
-    b[4] = a[3];
-    b[5] = a[4];
-    b[6] = a[5];
-    b[7] = 0;
-    b[8] = a[6];
-    b[9] = a[7];
-    b[10] = a[8];
-    b[11] = 0;
-    b[12] = 0;
-    b[13] = 0;
-    b[14] = 0;
-    b[15] = 1;
-    return res;
-};
-
-export { Mat3 };
+export function mat3() {
+    return new Mat3();
+}