@openglobus/og 0.13.5 → 0.13.8

package/src/og/control/Sun.js

@@ -1,170 +1,170 @@
-/**
- * @module og/control/Sun
- */
-
-"use strict";
-
-import { Control } from "./Control.js";
-import { getSunPosition } from "../astro/earth.js";
-import { LightSource } from "../light/LightSource.js";
-import { Quat } from "../math/Quat.js";
-import { Vec3 } from "../math/Vec3.js";
-
-const ACTIVATION_HEIGHT = 12079000.0;
-/**
- * Real Sun geocentric position control that place the Sun on the right place by the Earth.
- * @class
- * @extends {Control}
- * @param {Object} [options] - Control options.
- */
-class Sun extends Control {
-    constructor(options) {
-        super(options);
-
-        this._name = "sun";
-
-        options = options || {};
-
-        /**
-         * Earth planet node.
-         * @public
-         * @type {Planet}
-         */
-        this.planet = null;
-
-        /**
-         * Sunlight position placed in the camera eye.
-         * @private
-         * @type {boolean}
-         */
-        // this._isCameraSunlight = false;
-
-        this.offsetVertical = options.offsetVertical || -5000000;
-
-        this.offsetHorizontal = options.offsetHorizontal || 5000000;
-
-        /**
-         * Light source.
-         * @public
-         * @type {LightSource}
-         */
-        this.sunlight = null;
-
-        /**
-         * Current frame handler clock date and time.
-         * @private
-         * @type {Number}
-         */
-        this._currDate = 0;
-
-        /**
-         * Previous frame handler clock date and time.
-         * @private
-         * @type {Number}
-         */
-        this._prevDate = 0;
-
-        this._clockPtr = null;
-
-        this._lightOn = false;
-
-        this._stopped = options.stopped || false;
-    }
-
-    oninit() {
-        this.planet.lightEnabled = true;
-
-        // sunlight initialization
-        this.sunlight = new LightSource("Sun", {
-            ambient: new Vec3(0.15, 0.15, 0.25),
-            diffuse: new Vec3(0.9, 0.9, 0.8),
-            specular: new Vec3(0.1, 0.1, 0.06),
-            shininess: 110
-        });
-        this.sunlight.addTo(this.planet);
-
-        this.renderer.events.on("draw", this._draw, this);
-
-        if (!this._clockPtr) {
-            this._clockPtr = this.renderer.handler.defaultClock;
-        }
-    }
-
-    stop() {
-        this._stopped = true;
-    }
-
-    onactivate() {
-        this._stopped = false;
-    }
-
-    bindClock(clock) {
-        this._clockPtr = clock;
-    }
-
-    _draw() {
-        this._currDate = this._clockPtr.currentDate;
-        if (!this._stopped) {
-            var cam = this.renderer.activeCamera;
-            if (cam.getHeight() < ACTIVATION_HEIGHT || !this._active) {
-                this._lightOn = true;
-                this._f = 1;
-                var n = cam.eye.normal(),
-                    u = cam.getForward();
-
-                u.scale(Math.sign(cam._u.dot(n))); // up
-
-                if (cam.slope > 0.99) {
-                    u = cam._u;
-                }
-
-                var tu = Vec3.proj_b_to_plane(u, n, u).normalize().scale(this.offsetVertical);
-                var tr = Vec3.proj_b_to_plane(cam._r, n, cam._r)
-                    .normalize()
-                    .scale(this.offsetHorizontal); // right
-                var d = tu.add(tr);
-                var pos = cam.eye.add(d);
-                if (this._k > 0) {
-                    this._k -= 0.01;
-                    let rot = Quat.getRotationBetweenVectors(
-                        this.sunlight._position.normal(),
-                        pos.normal()
-                    );
-                    let r = rot.slerp(Quat.IDENTITY, this._k).normalize();
-                    this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
-                } else {
-                    this.sunlight.setPosition3v(pos);
-                }
-            } else {
-                this._k = 1;
-                if (this._f > 0) {
-                    this._f -= 0.01;
-                    let rot = Quat.getRotationBetweenVectors(
-                        this.sunlight._position.normal(),
-                        getSunPosition(this._currDate).normal()
-                    );
-                    let r = rot.slerp(Quat.IDENTITY, this._f).normalize();
-                    this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
-                } else {
-                    if (
-                        (Math.abs(this._currDate - this._prevDate) > 0.00034 && this._active) ||
-                        this._lightOn
-                    ) {
-                        this._lightOn = false;
-                        this._prevDate = this._currDate;
-                        this.sunlight.setPosition3v(getSunPosition(this._currDate));
-                        this._f = 0;
-                    }
-                }
-            }
-        } else {
-            this.sunlight.setPosition3v(getSunPosition(this._currDate));
-        }
-    }
-}
-
-export function sun(options) {
-    return Sun(options);
-}
-
-export { Sun };
+/**
+ * @module og/control/Sun
+ */
+
+"use strict";
+
+import { Control } from "./Control.js";
+import { getSunPosition } from "../astro/earth.js";
+import { LightSource } from "../light/LightSource.js";
+import { Quat } from "../math/Quat.js";
+import { Vec3 } from "../math/Vec3.js";
+
+const ACTIVATION_HEIGHT = 12079000.0;
+/**
+ * Real Sun geocentric position control that place the Sun on the right place by the Earth.
+ * @class
+ * @extends {Control}
+ * @param {Object} [options] - Control options.
+ */
+class Sun extends Control {
+    constructor(options) {
+        super(options);
+
+        this._name = "sun";
+
+        options = options || {};
+
+        /**
+         * Earth planet node.
+         * @public
+         * @type {Planet}
+         */
+        this.planet = null;
+
+        /**
+         * Sunlight position placed in the camera eye.
+         * @private
+         * @type {boolean}
+         */
+        // this._isCameraSunlight = false;
+
+        this.offsetVertical = options.offsetVertical || -5000000;
+
+        this.offsetHorizontal = options.offsetHorizontal || 5000000;
+
+        /**
+         * Light source.
+         * @public
+         * @type {LightSource}
+         */
+        this.sunlight = null;
+
+        /**
+         * Current frame handler clock date and time.
+         * @private
+         * @type {Number}
+         */
+        this._currDate = 0;
+
+        /**
+         * Previous frame handler clock date and time.
+         * @private
+         * @type {Number}
+         */
+        this._prevDate = 0;
+
+        this._clockPtr = null;
+
+        this._lightOn = false;
+
+        this._stopped = options.stopped || false;
+    }
+
+    oninit() {
+        this.planet.lightEnabled = true;
+
+        // sunlight initialization
+        this.sunlight = new LightSource("Sun", {
+            ambient: new Vec3(0.15, 0.15, 0.25),
+            diffuse: new Vec3(0.9, 0.9, 0.8),
+            specular: new Vec3(0.1, 0.1, 0.06),
+            shininess: 110
+        });
+        this.sunlight.addTo(this.planet);
+
+        this.renderer.events.on("draw", this._draw, this);
+
+        if (!this._clockPtr) {
+            this._clockPtr = this.renderer.handler.defaultClock;
+        }
+    }
+
+    stop() {
+        this._stopped = true;
+    }
+
+    onactivate() {
+        this._stopped = false;
+    }
+
+    bindClock(clock) {
+        this._clockPtr = clock;
+    }
+
+    _draw() {
+        this._currDate = this._clockPtr.currentDate;
+        if (!this._stopped) {
+            var cam = this.renderer.activeCamera;
+            if (cam.getHeight() < ACTIVATION_HEIGHT || !this._active) {
+                this._lightOn = true;
+                this._f = 1;
+                var n = cam.eye.normal(),
+                    u = cam.getForward();
+
+                u.scale(Math.sign(cam._u.dot(n))); // up
+
+                if (cam.slope > 0.99) {
+                    u = cam._u;
+                }
+
+                var tu = Vec3.proj_b_to_plane(u, n, u).normalize().scale(this.offsetVertical);
+                var tr = Vec3.proj_b_to_plane(cam._r, n, cam._r)
+                    .normalize()
+                    .scale(this.offsetHorizontal); // right
+                var d = tu.add(tr);
+                var pos = cam.eye.add(d);
+                if (this._k > 0) {
+                    this._k -= 0.01;
+                    let rot = Quat.getRotationBetweenVectors(
+                        this.sunlight._position.normal(),
+                        pos.normal()
+                    );
+                    let r = rot.slerp(Quat.IDENTITY, this._k).normalize();
+                    this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
+                } else {
+                    this.sunlight.setPosition3v(pos);
+                }
+            } else {
+                this._k = 1;
+                if (this._f > 0) {
+                    this._f -= 0.01;
+                    let rot = Quat.getRotationBetweenVectors(
+                        this.sunlight._position.normal(),
+                        getSunPosition(this._currDate).normal()
+                    );
+                    let r = rot.slerp(Quat.IDENTITY, this._f).normalize();
+                    this.sunlight.setPosition3v(r.mulVec3(this.sunlight._position));
+                } else {
+                    if (
+                        (Math.abs(this._currDate - this._prevDate) > 0.00034 && this._active) ||
+                        this._lightOn
+                    ) {
+                        this._lightOn = false;
+                        this._prevDate = this._currDate;
+                        this.sunlight.setPosition3v(getSunPosition(this._currDate));
+                        this._f = 0;
+                    }
+                }
+            }
+        } else {
+            this.sunlight.setPosition3v(getSunPosition(this._currDate));
+        }
+    }
+}
+
+export function sun(options) {
+    return new Sun(options);
+}
+
+export { Sun };

package/src/og/control/TouchNavigation.js

@@ -83,13 +83,13 @@ class TouchNavigation extends Control {
             t0.y = e.sys.touches.item(0).clientY - e.sys.offsetTop;
             t0.prev_x = e.sys.touches.item(0).clientX - e.sys.offsetLeft;
             t0.prev_y = e.sys.touches.item(0).clientY - e.sys.offsetTop;
-            t0.grabbedPoint = this.planet.getCartesianFromPixelTerrain(t0, true);
+            t0.grabbedPoint = this.planet.getCartesianFromPixelTerrain(e, true);
 
             t1.x = e.sys.touches.item(1).clientX - e.sys.offsetLeft;
             t1.y = e.sys.touches.item(1).clientY - e.sys.offsetTop;
             t1.prev_x = e.sys.touches.item(1).clientX - e.sys.offsetLeft;
             t1.prev_y = e.sys.touches.item(1).clientY - e.sys.offsetTop;
-            t1.grabbedPoint = this.planet.getCartesianFromPixelTerrain(t1, true);
+            t1.grabbedPoint = this.planet.getCartesianFromPixelTerrain(e, true);
 
             // this.planet._viewChanged = true;
             this.pointOnEarth = this.planet.getCartesianFromPixelTerrain(
@@ -119,7 +119,7 @@ class TouchNavigation extends Control {
         t.prev_x = e.sys.touches.item(0).clientX - e.sys.offsetLeft;
         t.prev_y = e.sys.touches.item(0).clientY - e.sys.offsetTop;
 
-        t.grabbedPoint = this.planet.getCartesianFromPixelTerrain(t, true);
+        t.grabbedPoint = this.planet.getCartesianFromPixelTerrain(e, true);
         this._eye0.copy(this.renderer.activeCamera.eye);
 
         if (t.grabbedPoint) {
@@ -142,7 +142,8 @@ class TouchNavigation extends Control {
 
         this.planet.stopFlying();
         this.stopRotation();
-        var p = this.planet.getCartesianFromPixelTerrain(this.touches[0], true);
+
+        var p = this.planet.getCartesianFromPixelTerrain(e);
         if (p) {
             var g = this.planet.ellipsoid.cartesianToLonLat(p);
             this.planet.flyLonLat(
@@ -199,11 +200,6 @@ class TouchNavigation extends Control {
             // distance < 0 --> zoomIn; distance > 0 --> zoomOut
             var t0t1Distance = Math.abs(t0.prev_x - t1.prev_x) + Math.abs(t0.prev_y - t1.prev_y)  - (Math.abs(t0.x - t1.x)  + Math.abs(t0.y - t1.y))
             var _move = 0
-            var _targetPoint = this.renderer.getCenter()
-            var d =
-                cam.eye.distance(
-                    this.planet.getCartesianFromPixelTerrain(_targetPoint, true)
-                ) * 0.075;
             if (t0t1Distance < 0) {
                 _move = 1
             }
@@ -211,9 +207,13 @@ class TouchNavigation extends Control {
                 _move = -1
             }
             if (_move !== 0) {
-                cam.eye.addA(cam.getForward().scale(_move * d));
-                cam.checkTerrainCollision();
-                cam.update();
+                let pos = this.planet.getCartesianFromPixelTerrain(e);
+                if (pos) {
+                    let d = cam.eye.distance(pos) * 0.075;
+                    cam.eye.addA(cam.getForward().scale(_move * d));
+                    cam.checkTerrainCollision();
+                    cam.update();
+                }
             }
 
             if (
@@ -246,7 +246,7 @@ class TouchNavigation extends Control {
 
             this.planet.stopFlying();
 
-            var direction = cam.unproject(t.x, t.y);
+            var direction = e.direction
             var targetPoint = new Ray(cam.eye, direction).hitSphere(t.grabbedSpheroid);
 
             if (targetPoint) {

package/src/og/control/ZoomControl.js

@@ -17,8 +17,6 @@ class ZoomControl extends Control {
     constructor(options) {
         super(options);
 
-        options = options || {};
-
         this._keyLock = new Key();
 
         this.planet = null;
@@ -114,7 +112,7 @@ class ZoomControl extends Control {
         var cam = this.renderer.activeCamera;
 
         if (this._move !== 0) {
-            let pos = this.planet.getCartesianFromPixelTerrain(this._targetPoint);
+            let pos = this.planet.getCartesianFromPixelTerrain(e);
             if (pos) {
                 let d = cam.eye.distance(pos) * 0.035;
                 cam.eye.addA(cam.getForward().scale(this._move * d));

package/src/og/control/index.js

@@ -10,6 +10,7 @@ import { MouseNavigation } from "./MouseNavigation.js";
 import { ToggleWireframe } from "./ToggleWireframe.js";
 import { TouchNavigation } from "./TouchNavigation.js";
 import { SimpleNavigation } from "./SimpleNavigation.js";
+import { Ruler } from "./ruler/Ruler.js";
 import { ShowFps } from "./ShowFps.js";
 import { Sun } from "./Sun.js";
 import { ZoomControl } from "./ZoomControl.js";
@@ -33,5 +34,6 @@ export {
     Sun,
     ZoomControl,
     MouseWheelZoomControl,
-    Lighting
+    Lighting,
+    Ruler
 };

package/src/og/control/ruler/Ruler.js

@@ -0,0 +1,43 @@
+/**
+ * @module og/control/Ruler
+ */
+
+"use strict";
+
+import { Control } from "../Control.js";
+import { RulerScene } from "./RulerScene.js";
+
+/**
+ * Activate ruler
+ * @class
+ * @extends {Control}
+ * @param {Object} [options] - Control options.
+ */
+class Ruler extends Control {
+    constructor(options = {}) {
+        super(options);
+
+        this._rulerScene = new RulerScene({
+            name: `rulerScene:${this._id}`,
+            ignoreTerrain: options.ignoreTerrain
+        });
+    }
+
+    set ignoreTerrain(v) {
+        this._rulerScene.ignoreTerrain = v;
+    }
+
+    oninit() {
+        this._rulerScene.bindPlanet(this.planet);
+    }
+
+    onactivate() {
+        this.renderer.addNode(this._rulerScene);
+    }
+
+    ondeactivate() {
+        this.renderer.removeNode(this._rulerScene);
+    }
+}
+
+export { Ruler };