@openglobus/og 0.13.10 → 0.14.1

package/src/og/math/Line3.js

@@ -1,140 +1,141 @@
-'use strict';
-
-import * as math from '../math.js';
-import { Vec3 } from './Vec3.js';
-
-export class Line3 {
-    constructor(p0, p1) {
-        this.p0 = p0 || new Vec3();
-        this.p1 = p1 || new Vec3();
-    }
-
-    getMagnitude() {
-        return this.p0.distance(this.p1);
-    }
-
-    getSphereIntersection(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;
-        }
-
-        var t1 = (-B - Math.Sqrt(D)) / (2.0 * A);
-
-        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);
-
-        if (D == 0) {
-            return solution1;
-        }
-
-        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];
-    }
-
-    intersects(line, res, res2) {
-
-        let p13 = this.p0.sub(line.p0),
-            p43 = line.p1.sub(line.p0);
-
-        if (Math.abs(p43.x) < math.EPSILON10 && Math.abs(p43.y) < math.EPSILON10 && Math.abs(p43.z) < math.EPSILON10) {
-            return false;
-        }
-
-        let p21 = this.p1.sub(this.p0);
-
-        if (Math.abs(p21.x) < math.EPSILON10 && Math.abs(p21.y) < math.EPSILON10 && Math.abs(p21.z) < math.EPSILON10) {
-            return false;
-        }
-
-        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;
-
-        let denom = d2121 * d4343 - d4321 * d4321;
-
-        if (Math.abs(denom) < math.EPSILON10) {
-            return false;
-        }
-
-        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;
-    }
-
-    getNearestDistancePoint(point, res) {
-
-        let p0 = this.p0,
-            p1 = this.p1;
-
-        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);
-
-        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;
-        }
-
-        return true;
-    }
-
+'use strict';
+
+import * as math from '../math.js';
+import { EPS10 } from '../math.js';
+import { Vec3 } from './Vec3.js';
+
+export class Line3 {
+    constructor(p0, p1) {
+        this.p0 = p0 || new Vec3();
+        this.p1 = p1 || new Vec3();
+    }
+
+    getMagnitude() {
+        return this.p0.distance(this.p1);
+    }
+
+    getSphereIntersection(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;
+        }
+
+        var t1 = (-B - Math.Sqrt(D)) / (2.0 * A);
+
+        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);
+
+        if (D == 0) {
+            return solution1;
+        }
+
+        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];
+    }
+
+    intersects(line, res, res2) {
+
+        let p13 = this.p0.sub(line.p0),
+            p43 = line.p1.sub(line.p0);
+
+        if (Math.abs(p43.x) < EPS10 && Math.abs(p43.y) < EPS10 && Math.abs(p43.z) < EPS10) {
+            return false;
+        }
+
+        let p21 = this.p1.sub(this.p0);
+
+        if (Math.abs(p21.x) < EPS10 && Math.abs(p21.y) < EPS10 && Math.abs(p21.z) < EPS10) {
+            return false;
+        }
+
+        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;
+
+        let denom = d2121 * d4343 - d4321 * d4321;
+
+        if (Math.abs(denom) < EPS10) {
+            return false;
+        }
+
+        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;
+    }
+
+    getNearestDistancePoint(point, res) {
+
+        let p0 = this.p0,
+            p1 = this.p1;
+
+        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);
+
+        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;
+        }
+
+        return true;
+    }
+
 }

package/src/og/math/Plane.js

@@ -1,117 +1,118 @@
-"use strict";
-
-import * as math from "../math.js";
-import { Vec3 } from "./Vec3.js";
-
-/**
- * Plane class.
- * @constructor
- * @param {Vec3} [p] - Plane point.
- * @param {Vec3} [n] - Planet normal.
- */
-class Plane {
-    constructor(p, n) {
-        this.p = p ? p.clone() : new Vec3();
-        this.n = n ? n.clone() : this.p.normal();
-    }
-
-    set(p, n) {
-        this.p.copy(p);
-        this.n.copy(n);
-    }
-
-    getNormal() {
-        return this.n.clone();
-    }
-
-    distance(p) {
-        let pp = this.getProjection(p);
-        return p.distance(pp);
-    }
-
-    getProjection(v, def) {
-        return Vec3.proj_b_to_plane(v, this.n, def);
-    }
-
-    getProjectionPoint(p, vh) {
-        let v = p.sub(this.p),
-            n = this.n,
-            dist = v.dot(n);
-
-        if (vh) {
-            vh.copy(n.scale(dist));
-        } else {
-            vh = n.scale(dist);
-        }
-        return p.sub(vh);
-    }
-
-    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;
-
-        // test if the two planes are 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
-            } else {
-                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
-        if (ax > ay) {
-            if (ax > az) {
-                maxc = 1;
-            } else {
-                maxc = 3;
-            }
-        } else {
-            if (ay > az) {
-                maxc = 2;
-            } else {
-                maxc = 3;
-            }
-        }
-
-        // next, to get a point on the intersect line
-        // 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
-
-        // select max coordinate
-        if (maxc === 1) {
-            // intersect with x=0
-            iP.x = 0;
-            iP.y = (d2 * Pn1.n.z - d1 * Pn2.n.z) / u.x;
-            iP.z = (d1 * Pn2.n.y - d2 * Pn1.n.y) / u.x;
-        } else if (maxc === 2) {
-            // intersect with y=0
-            iP.x = (d1 * Pn2.n.z - d2 * Pn1.n.z) / u.y;
-            iP.y = 0;
-            iP.z = (d2 * Pn1.n.x - d1 * Pn2.n.x) / u.y;
-        } else if (maxc === 3) {
-            // intersect with z=0
-            iP.x = (d2 * Pn1.n.y - d1 * Pn2.n.y) / u.z;
-            iP.y = (d1 * Pn2.n.x - d2 * Pn1.n.x) / u.z;
-            iP.z = 0;
-        }
-        L.p0.copy(iP);
-        L.p1.copy(iP.add(u));
-        return 2;
-    }
-}
-
-export { Plane };
+"use strict";
+
+import * as math from "../math.js";
+import { EPS5 } from "../math.js";
+import { Vec3 } from "./Vec3.js";
+
+/**
+ * Plane class.
+ * @constructor
+ * @param {Vec3} [p] - Plane point.
+ * @param {Vec3} [n] - Planet normal.
+ */
+class Plane {
+    constructor(p, n) {
+        this.p = p ? p.clone() : new Vec3();
+        this.n = n ? n.clone() : this.p.normal();
+    }
+
+    set(p, n) {
+        this.p.copy(p);
+        this.n.copy(n);
+    }
+
+    getNormal() {
+        return this.n.clone();
+    }
+
+    distance(p) {
+        let pp = this.getProjection(p);
+        return p.distance(pp);
+    }
+
+    getProjection(v, def) {
+        return Vec3.proj_b_to_plane(v, this.n, def);
+    }
+
+    getProjectionPoint(p, vh) {
+        let v = p.sub(this.p),
+            n = this.n,
+            dist = v.dot(n);
+
+        if (vh) {
+            vh.copy(n.scale(dist));
+        } else {
+            vh = n.scale(dist);
+        }
+        return p.sub(vh);
+    }
+
+    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;
+
+        // test if the two planes are parallel
+        if (ax + ay + az < EPS5) {
+            // 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
+            } else {
+                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
+        if (ax > ay) {
+            if (ax > az) {
+                maxc = 1;
+            } else {
+                maxc = 3;
+            }
+        } else {
+            if (ay > az) {
+                maxc = 2;
+            } else {
+                maxc = 3;
+            }
+        }
+
+        // next, to get a point on the intersect line
+        // 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
+
+        // select max coordinate
+        if (maxc === 1) {
+            // intersect with x=0
+            iP.x = 0;
+            iP.y = (d2 * Pn1.n.z - d1 * Pn2.n.z) / u.x;
+            iP.z = (d1 * Pn2.n.y - d2 * Pn1.n.y) / u.x;
+        } else if (maxc === 2) {
+            // intersect with y=0
+            iP.x = (d1 * Pn2.n.z - d2 * Pn1.n.z) / u.y;
+            iP.y = 0;
+            iP.z = (d2 * Pn1.n.x - d1 * Pn2.n.x) / u.y;
+        } else if (maxc === 3) {
+            // intersect with z=0
+            iP.x = (d2 * Pn1.n.y - d1 * Pn2.n.y) / u.z;
+            iP.y = (d1 * Pn2.n.x - d2 * Pn1.n.x) / u.z;
+            iP.z = 0;
+        }
+        L.p0.copy(iP);
+        L.p1.copy(iP.add(u));
+        return 2;
+    }
+}
+
+export { Plane };