@openglobus/og 0.17.1 → 0.17.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openglobus/og",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "[OpenGlobus](https://www.openglobus.org/) is a javascript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers and 3d objects. It uses the WebGL technology, open source and completely free.",
   "directories": {
     "example": "./sandbox"

package/src/og/camera/PlanetCamera.js

@@ -34,10 +34,9 @@ class PlanetCamera extends Camera {
      */
     constructor(planet, options) {
         super(planet.renderer, {
-                frustums: [
-                    [[1, 100], [100, 1000 + 7.0], [1000 - 7.0, 1e6 + 17], [1e6 - 17, 1e9]]
-                ], //[[1, 1e3 + 100], [1e3, 1e6 + 10000], [1e6, 1e9]]*/
-                ...options
+                ...options,
+                frustums: options.frustums || [[1, 100 + 0.075], [100, 1000 + 0.075], [1000, 1e6 + 10000], [1e6, 1e9]],
+            //[[1, 1e3 + 100], [1e3, 1e6 + 10000], [1e6, 1e9]]*/
             }
         );
         /**

package/src/og/control/KeyboardNavigation.js

@@ -15,11 +15,11 @@ import { Control } from "./Control.js";
 class KeyboardNavigation extends Control {
     constructor(options) {
         options = options || {};
-        super(options);
+        super({ name: "KeyboardNavigation", ...options });
         this.step = options.step || 250;
     }
 
-    oninit() {
+    onactivate() {
         this.renderer.events.on("keypress", input.KEY_PGUP, this.onCameraMoveForward, this);
         this.renderer.events.on("keypress", input.KEY_PGDN, this.onCameraMoveBackward, this);
         this.renderer.events.on("keypress", input.KEY_PLUS, this.onCameraMoveForward, this);
@@ -38,6 +38,29 @@ class KeyboardNavigation extends Control {
         this.renderer.events.on("keypress", input.KEY_N, this.onCameraRollNorth, this);
     }
 
+    ondeactivate() {
+        this.renderer.events.off("keypress", input.KEY_PGUP, this.onCameraMoveForward);
+        this.renderer.events.off("keypress", input.KEY_PGDN, this.onCameraMoveBackward);
+        this.renderer.events.off("keypress", input.KEY_PLUS, this.onCameraMoveForward);
+        this.renderer.events.off("keypress", input.KEY_EQUALS, this.onCameraMoveForward);
+        this.renderer.events.off("keypress", input.KEY_MINUS, this.onCameraMoveBackward);
+        this.renderer.events.off("keypress", input.KEY_W, this.onCameraMoveForward);
+        this.renderer.events.off("keypress", input.KEY_S, this.onCameraMoveBackward);
+        this.renderer.events.off("keypress", input.KEY_A, this.onCameraStrifeLeft);
+        this.renderer.events.off("keypress", input.KEY_D, this.onCameraStrifeRight);
+        this.renderer.events.off("keypress", input.KEY_UP, this.onCameraLookUp);
+        this.renderer.events.off("keypress", input.KEY_DOWN, this.onCameraLookDown);
+        this.renderer.events.off("keypress", input.KEY_LEFT, this.onCameraLookLeft);
+        this.renderer.events.off("keypress", input.KEY_RIGHT, this.onCameraLookRight);
+        this.renderer.events.off("keypress", input.KEY_Q, this.onCameraRollLeft);
+        this.renderer.events.off("keypress", input.KEY_E, this.onCameraRollRight);
+        this.renderer.events.off("keypress", input.KEY_N, this.onCameraRollNorth);
+    }
+
+    oninit() {
+        this.activate();
+    }
+
     onCameraMoveForward(event) {
         var cam = this.renderer.activeCamera;
         cam.slide(0, 0, -cam._lonLat.height / this.step);
@@ -114,22 +137,22 @@ class KeyboardNavigation extends Control {
 
     // from CompassButton._onClick()
     onCameraRollNorth(event) {
-      let c = this.planet.getCartesianFromPixelTerrain(this.renderer.handler.getCenter());
-      if (c) {
-        this.planet.flyCartesian(
-          c.normal().scaleTo(c.length() + c.distance(this.planet.camera.eye)),
-          null,
-          null,
-          0,
-          null,
-          null,
-          () => {
-            this.planet.camera.look(c);
-          }
-          );
-      } else {
-        this.planet.flyCartesian(this.planet.camera.eye);
-      }
+        let c = this.planet.getCartesianFromPixelTerrain(this.renderer.handler.getCenter());
+        if (c) {
+            this.planet.flyCartesian(
+                c.normal().scaleTo(c.length() + c.distance(this.planet.camera.eye)),
+                null,
+                null,
+                0,
+                null,
+                null,
+                () => {
+                    this.planet.camera.look(c);
+                }
+            );
+        } else {
+            this.planet.flyCartesian(this.planet.camera.eye);
+        }
     }
 
     onCameraRollLeft(event) {

package/src/og/entity/Geometry.js

@@ -111,8 +111,8 @@ class Geometry {
         var t = Geometry.getType(geometryObj.type);
 
         if (t === GeometryType.POINT) {
-            let lon = res.coordinates[0],
-                lat = res.coordinates[1];
+            let lon = geometryObj.coordinates[0],
+                lat = geometryObj.coordinates[1];
             res.southWest.lon = lon;
             res.southWest.lat = lat;
             res.northEast.lon = lon;

package/src/og/input/KeyboardHandler.js

@@ -1,37 +1,100 @@
 'use strict';
 
 import { input } from './input.js';
+import { stamp } from "../utils/shared.js";
+
+const STAMP_SPACER = "_";
 
 class KeyboardHandler {
 
     constructor() {
-        var _currentlyPressedKeys = {};
-        var _pressedKeysCallbacks = {};
-        var _unpressedKeysCallbacks = {};
-        var _charkeysCallbacks = {};
-        var _that = this;
-        var _anykeyCallback = null;
-        var _event = null;
+        let _currentlyPressedKeys = {};
+        let _pressedKeysCallbacks = {};
+        let _unpressedKeysCallbacks = {};
+        let _charkeysCallbacks = {};
+
+        let _that = this;
+        let _anykeyCallback = null;
+        let _event = null;
 
-        var _active = true;
+        let _active = true;
+
+        let _stampCache = {};
 
         if (KeyboardHandler.prototype._instance) {
             return KeyboardHandler.prototype._instance;
         } else {
             KeyboardHandler.prototype._instance = this;
 
-            document.onkeydown = function (event) { _event = event; _active && _that.handleKeyDown(); };
-            document.onkeyup = function (event) { _event = event; _active && _that.handleKeyUp(); };
+            document.onkeydown = function (event) {
+                _event = event;
+                _active && _that.handleKeyDown();
+            };
+            document.onkeyup = function (event) {
+                _event = event;
+                _active && _that.handleKeyUp();
+            };
         }
 
         var _sortByPriority = function (a, b) {
             return a.priority < b.priority;
         };
 
-        this.removeEvent = function (events, callback) {
-            //
-            // TODO:...
-            //
+        this.getcurrentlyPressedKeys = function () {
+            return _currentlyPressedKeys;
+        }
+
+        this.getPressedKeysCallbacks = function () {
+            return _pressedKeysCallbacks;
+        }
+
+        this.getUnpressedKeysCallbacks = function () {
+            return _unpressedKeysCallbacks;
+        }
+
+        this.getCharkeysCallbacks = function () {
+            return _charkeysCallbacks;
+        }
+
+        this.removeEvent = function (event, keyCode, callback) {
+            let st = this._getStamp(event, keyCode, callback._openglobus_id);
+            if (callback._openglobus_id && _stampCache[st]) {
+                _stampCache[st] = null;
+                delete _stampCache[st];
+
+                if (event === "keypress") {
+                    this._removeCallback(_pressedKeysCallbacks[keyCode], callback);
+                } else if (event === "keyfree") {
+                    this._removeCallback(_unpressedKeysCallbacks[keyCode], callback);
+                } else if (event === "charkeypress") {
+                    this._removeCallback(_charkeysCallbacks[keyCode], callback);
+                }
+            }
+        };
+
+        this._removeCallback = function (handlers, callback) {
+            for (let i = 0; i < handlers.length; i++) {
+                if (handlers[i].callback._openglobus_id === callback._openglobus_id) {
+                    handlers.splice(i, 1);
+                }
+            }
+        };
+
+        this._getStamp = function (name, keyCode, ogid) {
+            return `${name}${STAMP_SPACER}${keyCode}${STAMP_SPACER}${ogid}`;
+        };
+
+        this._stamp = function (name, keyCode, obj) {
+            let ogid = stamp(obj);
+
+            let st = this._getStamp(name, keyCode, ogid);
+
+            if (!_stampCache[st]) {
+                _stampCache[st] = ogid;
+                return true;
+            }
+
+            return false;
         };
 
         this.setActivity = function (activity) {
@@ -40,9 +103,13 @@ class KeyboardHandler {
 
         this.releaseKeys = function () {
             _currentlyPressedKeys = {};
-        }
+        };
+
+        this.addEvent = function (event, keyCode, callback, sender, priority) {
+
+            // Event is already bound with the callback
+            if (!this._stamp(event, keyCode, callback)) return;
 
-        this.addEvent = function (event, sender, callback, keyCode, priority) {
             if (priority === undefined) {
                 priority = 1600;
             }
@@ -115,7 +182,7 @@ class KeyboardHandler {
         this.handleEvents = function () {
             for (let pk in _pressedKeysCallbacks) {
                 if (_currentlyPressedKeys[pk]) {
-                    var cpk = _pressedKeysCallbacks[pk];
+                    let cpk = _pressedKeysCallbacks[pk];
                     for (let i = 0; i < cpk.length; i++) {
                         cpk[i].callback.call(cpk[i].sender, _event);
                     }

package/src/og/renderer/RendererEvents.js

@@ -256,33 +256,19 @@ class RendererEvents extends Events {
         }
     }
 
-    /**
-     * Set render event callback.
-     * @public
-     * @param {string} name - Event name
-     * @param {eventCallback} callback - Callback function
-     * @param {number} [key] - Key code from og.input
-     * @param {*} sender - Callback context
-     * @param {number} [priority] - Event callback priority
-     */
     on(name, p0, p1, p2, p3) {
         if (name === "keypress" || name === "charkeypress" || name === "keyfree") {
-            this._keyboardHandler.addEvent(name, p2, p1, p0, p3);
+            this._keyboardHandler.addEvent(name, p0, p1, p2, p3);
         } else {
             super.on(name, p0, p1, p2);
         }
     }
 
-    /**
-     * TODO: DOESNT WORK!!!
-     * @param {any} name
-     * @param {any} callback
-     */
-    off(name, callback) {
+    off(name, p1, p2) {
         if (name === "keypress" || name === "charkeypress" || name === "keyfree") {
-            this._keyboardHandler.removeEvent(name, callback);
+            this._keyboardHandler.removeEvent(name, p1, p2);
         } else {
-            super.off(name, callback);
+            super.off(name, p1);
         }
     }
 

package/src/og/scene/Planet.js

@@ -117,8 +117,6 @@ export class Planet extends RenderNode {
     constructor(options = {}) {
         super(options.name);
 
-        this._cameraFrustums = options.frustums || [[1, 100], [100, 1000 + 7.0], [1000 - 7.0, 1e6 + 17], [1e6 - 17, 1e9]];
-
         /**
          * @public
          * @type {Ellipsoid}
@@ -205,7 +203,7 @@ export class Planet extends RenderNode {
          * @type {PlanetCamera}
          */
         this.camera = new PlanetCamera(this, {
-            frustums: this._cameraFrustums,
+            frustums: options.frustums,
             eye: new Vec3(25000000, 0, 0),
             look: Vec3.ZERO,
             up: Vec3.NORTH,

package/src/og/utils/TextureAtlas.js

@@ -189,7 +189,7 @@ class TextureAtlas {
      * @public
      */
     createTexture(img, internalFormat) {
-        if (this._handler) {
+        if (this._handler && this._handler.gl) {
             this._handler.gl.deleteTexture(this.texture);
             if (img) {
                 this.canvas.resize(img.width, img.height);

package/src/og/webgl/Handler.js

@@ -1026,6 +1026,8 @@ class Handler {
     destroy() {
         let gl = this.gl;
 
+        this.resizeObserver.disconnect();
+        this.intersectionObserver.disconnect();
         this.stop();
 
         //

package/types/input/KeyboardHandler.d.ts

@@ -1,8 +1,15 @@
 export class KeyboardHandler {
-    removeEvent: (events: any, callback: any) => void;
+    getcurrentlyPressedKeys: () => {};
+    getPressedKeysCallbacks: () => {};
+    getUnpressedKeysCallbacks: () => {};
+    getCharkeysCallbacks: () => {};
+    removeEvent: (event: any, keyCode: any, callback: any) => void;
+    _removeCallback: (handlers: any, callback: any) => void;
+    _getStamp: (name: any, keyCode: any, ogid: any) => string;
+    _stamp: (name: any, keyCode: any, obj: any) => boolean;
     setActivity: (activity: any) => void;
     releaseKeys: () => void;
-    addEvent: (event: any, sender: any, callback: any, keyCode: any, priority: any) => void;
+    addEvent: (event: any, keyCode: any, callback: any, sender: any, priority: any) => void;
     isKeyPressed: (keyCode: any) => any;
     handleKeyDown: () => void;
     handleKeyUp: () => void;

package/types/renderer/RendererEvents.d.ts

@@ -170,22 +170,8 @@ export class RendererEvents extends Events {
      * @public
      */
     public handleEvents(): void;
-    /**
-     * Set render event callback.
-     * @public
-     * @param {string} name - Event name
-     * @param {eventCallback} callback - Callback function
-     * @param {number} [key] - Key code from og.input
-     * @param {*} sender - Callback context
-     * @param {number} [priority] - Event callback priority
-     */
-    public on(name: string, p0: any, p1: any, p2: any, p3: any): void;
-    /**
-     * TODO: DOESNT WORK!!!
-     * @param {any} name
-     * @param {any} callback
-     */
-    off(name: any, callback: any): void;
+    on(name: any, p0: any, p1: any, p2: any, p3: any): void;
+    off(name: any, p1: any, p2: any): void;
     /**
      * Check key is pressed.
      * @public

package/types/scene/Planet.d.ts

@@ -17,7 +17,6 @@
  */
 export class Planet extends RenderNode {
     constructor(options?: {});
-    _cameraFrustums: any;
     /**
      * @public
      * @type {Ellipsoid}