@openglobus/og 0.16.2 → 0.17.0

package/src/og/entity/PolylineHandler.js

@@ -1,109 +1,105 @@
-/**
- * @module og/entity/PolylineHandler
- */
-
-'use strict';
-
-import * as shaders from '../shaders/polyline.js';
-
-class PolylineHandler {
-    constructor(entityCollection) {
-
-        this._entityCollection = entityCollection;
-
-        this._renderer = null;
-
-        this._polylines = [];
-
-        this.__staticId = PolylineHandler._staticCounter++;
-
-        this.pickingEnabled = true;
-    }
-
-    static get _staticCounter() {
-        if (!this._counter && this._counter !== 0) {
-            this._counter = 0;
-        }
-        return this._counter;
-    }
-
-    static set _staticCounter(n) {
-        this._counter = n;
-    }
-
-    _initProgram() {
-        if (this._renderer.handler) {
-            if (!this._renderer.handler.programs.polyline_screen) {
-                this._renderer.handler.addProgram(shaders.polyline_screen());
-            }
-            if (!this._renderer.handler.programs.polyline_picking) {
-                this._renderer.handler.addProgram(shaders.polyline_picking());
-            }
-        }
-    }
-
-    setRenderNode(renderNode) {
-        this._renderer = renderNode.renderer;
-        this._initProgram();
-        for (var i = 0; i < this._polylines.length; i++) {
-            this._polylines[i].setRenderNode(renderNode);
-        }
-    }
-
-    add(polyline) {
-        if (polyline._handlerIndex === -1) {
-            polyline._handler = this;
-            polyline._handlerIndex = this._polylines.length;
-            this._polylines.push(polyline);
-            this._entityCollection && this._entityCollection.renderNode &&
-                polyline.setRenderNode(this._entityCollection.renderNode);
-        }
-    }
-
-    remove(polyline) {
-        var index = polyline._handlerIndex;
-        if (index !== -1) {
-            polyline._deleteBuffers();
-            polyline._handlerIndex = -1;
-            polyline._handler = null;
-            this._polylines.splice(index, 1);
-            this.reindexPolylineArray(index);
-        }
-    }
-
-    reindexPolylineArray(startIndex) {
-        var ls = this._polylines;
-        for (var i = startIndex; i < ls.length; i++) {
-            ls[i]._handlerIndex = i;
-        }
-    }
-
-    draw() {
-        let i = this._polylines.length;
-        while (i--) {
-            this._polylines[i].draw();
-        }
-    }
-
-    drawPicking() {
-        if (this.pickingEnabled) {
-            let i = this._polylines.length;
-            while (i--) {
-                this._polylines[i].drawPicking();
-            }
-        }
-    }
-
-    clear() {
-        var i = this._polylines.length;
-        while (i--) {
-            this._polylines[i]._deleteBuffers();
-            this._polylines[i]._handler = null;
-            this._polylines[i]._handlerIndex = -1;
-        }
-        this._polylines.length = 0;
-        this._polylines = [];
-    }
-}
-
+'use strict';
+
+import * as shaders from '../shaders/polyline.js';
+
+class PolylineHandler {
+    constructor(entityCollection) {
+
+        this._entityCollection = entityCollection;
+
+        this._renderer = null;
+
+        this._polylines = [];
+
+        this.__staticId = PolylineHandler._staticCounter++;
+
+        this.pickingEnabled = true;
+    }
+
+    static get _staticCounter() {
+        if (!this._counter && this._counter !== 0) {
+            this._counter = 0;
+        }
+        return this._counter;
+    }
+
+    static set _staticCounter(n) {
+        this._counter = n;
+    }
+
+    _initProgram() {
+        if (this._renderer.handler) {
+            if (!this._renderer.handler.programs.polyline_screen) {
+                this._renderer.handler.addProgram(shaders.polyline_screen());
+            }
+            if (!this._renderer.handler.programs.polyline_picking) {
+                this._renderer.handler.addProgram(shaders.polyline_picking());
+            }
+        }
+    }
+
+    setRenderNode(renderNode) {
+        this._renderer = renderNode.renderer;
+        this._initProgram();
+        for (var i = 0; i < this._polylines.length; i++) {
+            this._polylines[i].setRenderNode(renderNode);
+        }
+    }
+
+    add(polyline) {
+        if (polyline._handlerIndex === -1) {
+            polyline._handler = this;
+            polyline._handlerIndex = this._polylines.length;
+            this._polylines.push(polyline);
+            this._entityCollection && this._entityCollection.renderNode &&
+                polyline.setRenderNode(this._entityCollection.renderNode);
+        }
+    }
+
+    remove(polyline) {
+        var index = polyline._handlerIndex;
+        if (index !== -1) {
+            polyline._deleteBuffers();
+            polyline._handlerIndex = -1;
+            polyline._handler = null;
+            this._polylines.splice(index, 1);
+            this.reindexPolylineArray(index);
+        }
+    }
+
+    reindexPolylineArray(startIndex) {
+        var ls = this._polylines;
+        for (var i = startIndex; i < ls.length; i++) {
+            ls[i]._handlerIndex = i;
+        }
+    }
+
+    draw() {
+        let i = this._polylines.length;
+        while (i--) {
+            this._polylines[i].draw();
+        }
+    }
+
+    drawPicking() {
+        if (this.pickingEnabled) {
+            let i = this._polylines.length;
+            while (i--) {
+                this._polylines[i].drawPicking();
+            }
+        }
+    }
+
+    clear() {
+        var i = this._polylines.length;
+        while (i--) {
+            this._polylines[i]._deleteBuffers();
+            this._polylines[i]._handler = null;
+            this._polylines[i]._handlerIndex = -1;
+        }
+        this._polylines.length = 0;
+        this._polylines = [];
+    }
+}
+
 export { PolylineHandler };

package/src/og/entity/Ray.js

@@ -1,12 +1,8 @@
-/**
- * @module og/entity/BaseBillboard
- */
-
 "use strict";
 
-import { Vec3 } from "../math/Vec3.js";
+import {Vec3} from "../math/Vec3.js";
 import * as utils from "../utils/shared.js";
-import { Entity } from "./Entity.js";
+import {Entity} from "./Entity.js";
 
 /**
  * Ray class.
@@ -99,11 +95,15 @@ class Ray {
             this._startPositionLow
         );
         this._handler &&
-            this._handler.setStartPositionArr(
-                this._handlerIndex,
-                this._startPositionHigh,
-                this._startPositionLow
-            );
+        this._handler.setStartPositionArr(
+            this._handlerIndex,
+            this._startPositionHigh,
+            this._startPositionLow
+        );
+    }
+
+    getLength() {
+        return this._startPosition.distance(this._endPosition);
     }
 
     /**
@@ -121,11 +121,11 @@ class Ray {
             this._startPositionLow
         );
         this._handler &&
-            this._handler.setStartPositionArr(
-                this._handlerIndex,
-                this._startPositionHigh,
-                this._startPositionLow
-            );
+        this._handler.setStartPositionArr(
+            this._handlerIndex,
+            this._startPositionHigh,
+            this._startPositionLow
+        );
     }
 
     /**
@@ -141,11 +141,11 @@ class Ray {
         this._endPosition.z = z;
         Vec3.doubleToTwoFloats(this._endPosition, this._endPositionHigh, this._endPositionLow);
         this._handler &&
-            this._handler.setEndPositionArr(
-                this._handlerIndex,
-                this._endPositionHigh,
-                this._endPositionLow
-            );
+        this._handler.setEndPositionArr(
+            this._handlerIndex,
+            this._endPositionHigh,
+            this._endPositionLow
+        );
     }
 
     /**
@@ -159,11 +159,11 @@ class Ray {
         this._endPosition.z = position.z;
         Vec3.doubleToTwoFloats(this._endPosition, this._endPositionHigh, this._endPositionLow);
         this._handler &&
-            this._handler.setEndPositionArr(
-                this._handlerIndex,
-                this._endPositionHigh,
-                this._endPositionLow
-            );
+        this._handler.setEndPositionArr(
+            this._handlerIndex,
+            this._endPositionHigh,
+            this._endPositionLow
+        );
     }
 
     setThickness(thickness) {
@@ -187,7 +187,7 @@ class Ray {
         }
 
         this._handler &&
-            this._handler.setRgbaArr(this._handlerIndex, this._startColor, this._endColor);
+        this._handler.setRgbaArr(this._handlerIndex, this._startColor, this._endColor);
     }
 
     setColorsHTML(startColor, endColor) {
@@ -200,7 +200,7 @@ class Ray {
         }
 
         this._handler &&
-            this._handler.setRgbaArr(this._handlerIndex, this._startColor, this._endColor);
+        this._handler.setRgbaArr(this._handlerIndex, this._startColor, this._endColor);
     }
 
     /**
@@ -259,4 +259,4 @@ class Ray {
     }
 }
 
-export { Ray };
+export {Ray};

package/src/og/entity/Strip.js

@@ -316,7 +316,7 @@ class Strip {
     }
 
     _createBuffers() {
-        if (this._renderNode && this._renderNode.renderer) {
+        if (this._renderNode && this._renderNode.renderer && this._renderNode.renderer.isInitialized()) {
             var gl = this._renderNode.renderer.handler.gl;
 
             gl.deleteBuffer(this._indexBuffer);

package/src/og/index.js

@@ -51,8 +51,9 @@ import { Object3d } from './Object3d.js';
 const { Handler } = webgl, { Control } = control;
 const { Layer, Vector, XYZ, CanvasTiles} = layer;
 const {
+    Polyline,
     EntityCollection,
-    Entity
+    Entity,
 } = entity;
 
 export {
@@ -78,6 +79,7 @@ export {
     PlanetCamera,
     Globe,
     LightSource,
+    Polyline,
     EntityCollection,
     Handler,
     Renderer,

package/src/og/input/KeyboardHandler.js

@@ -1,132 +1,128 @@
-/**
- * @module og/input/KeyboardHandler
- */
-
-'use strict';
-
-import { input } from './input.js';
-
-class KeyboardHandler {
-
-    constructor() {
-        var _currentlyPressedKeys = {};
-        var _pressedKeysCallbacks = {};
-        var _unpressedKeysCallbacks = {};
-        var _charkeysCallbacks = {};
-        var _that = this;
-        var _anykeyCallback = null;
-        var _event = null;
-
-        var _active = true;
-
-        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(); };
-        }
-
-        var _sortByPriority = function (a, b) {
-            return a.priority < b.priority;
-        };
-
-        this.removeEvent = function (events, callback) {
-            //
-            // TODO:...
-            //
-        };
-
-        this.setActivity = function (activity) {
-            _active = activity;
-        };
-
-        this.releaseKeys = function () {
-            _currentlyPressedKeys = {};
-        }
-
-        this.addEvent = function (event, sender, callback, keyCode, priority) {
-            if (priority === undefined) {
-                priority = 1600;
-            }
-            switch (event) {
-                case "keyfree":
-                    if (!_unpressedKeysCallbacks[keyCode]) {
-                        _unpressedKeysCallbacks[keyCode] = [];
-                    }
-                    _unpressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
-                    _unpressedKeysCallbacks[keyCode].sort(_sortByPriority);
-                    break;
-
-                case "keypress":
-                    if (keyCode == null) {
-                        _anykeyCallback = { callback: callback, sender: sender || _that };
-                    } else {
-                        if (!_pressedKeysCallbacks[keyCode]) {
-                            _pressedKeysCallbacks[keyCode] = [];
-                        }
-                        _pressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
-                        _pressedKeysCallbacks[keyCode].sort(_sortByPriority);
-                    }
-                    break;
-
-                case "charkeypress":
-                    if (!_charkeysCallbacks[keyCode]) {
-                        _charkeysCallbacks[keyCode] = [];
-                    }
-                    _charkeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
-                    _charkeysCallbacks[keyCode].sort(_sortByPriority);
-                    break;
-            }
-        };
-
-        this.isKeyPressed = function (keyCode) {
-            return _currentlyPressedKeys[keyCode];
-        };
-
-        this.handleKeyDown = function () {
-            _anykeyCallback && _anykeyCallback.callback.call(_anykeyCallback.sender, _event);
-            _currentlyPressedKeys[_event.keyCode] = true;
-            for (var ch in _charkeysCallbacks) {
-                if (String.fromCharCode(_event.keyCode) == String.fromCharCode(ch)) {
-                    var ccl = _charkeysCallbacks[ch];
-                    for (var i = 0; i < ccl.length; i++) {
-                        ccl[i].callback.call(ccl[i].sender, _event);
-                    }
-                }
-            }
-
-            if (_event.keyCode == input.KEY_ALT || _event.keyCode == input.KEY_SHIFT) {
-                _event.preventDefault();
-            }
-        };
-
-        this.handleKeyUp = function () {
-            if (_currentlyPressedKeys[_event.keyCode] || _event.keyCode === input.KEY_PRINTSCREEN) {
-                for (var pk in _unpressedKeysCallbacks) {
-                    if (_currentlyPressedKeys[pk] || _event.keyCode === input.KEY_PRINTSCREEN && pk == input.KEY_PRINTSCREEN) {
-                        var cpk = _unpressedKeysCallbacks[pk];
-                        for (var i = 0; i < cpk.length; i++) {
-                            cpk[i].callback.call(cpk[i].sender, _event);
-                        }
-                    }
-                }
-            }
-            _currentlyPressedKeys[_event.keyCode] = false;
-        };
-
-        this.handleEvents = function () {
-            for (var pk in _pressedKeysCallbacks) {
-                if (_currentlyPressedKeys[pk]) {
-                    var cpk = _pressedKeysCallbacks[pk];
-                    for (var i = 0; i < cpk.length; i++) {
-                        cpk[i].callback.call(cpk[i].sender, _event);
-                    }
-                }
-            }
-        };
-    }
-}
-
-export { KeyboardHandler };
+'use strict';
+
+import { input } from './input.js';
+
+class KeyboardHandler {
+
+    constructor() {
+        var _currentlyPressedKeys = {};
+        var _pressedKeysCallbacks = {};
+        var _unpressedKeysCallbacks = {};
+        var _charkeysCallbacks = {};
+        var _that = this;
+        var _anykeyCallback = null;
+        var _event = null;
+
+        var _active = true;
+
+        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(); };
+        }
+
+        var _sortByPriority = function (a, b) {
+            return a.priority < b.priority;
+        };
+
+        this.removeEvent = function (events, callback) {
+            //
+            // TODO:...
+            //
+        };
+
+        this.setActivity = function (activity) {
+            _active = activity;
+        };
+
+        this.releaseKeys = function () {
+            _currentlyPressedKeys = {};
+        }
+
+        this.addEvent = function (event, sender, callback, keyCode, priority) {
+            if (priority === undefined) {
+                priority = 1600;
+            }
+            switch (event) {
+                case "keyfree":
+                    if (!_unpressedKeysCallbacks[keyCode]) {
+                        _unpressedKeysCallbacks[keyCode] = [];
+                    }
+                    _unpressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
+                    _unpressedKeysCallbacks[keyCode].sort(_sortByPriority);
+                    break;
+
+                case "keypress":
+                    if (keyCode == null) {
+                        _anykeyCallback = { callback: callback, sender: sender || _that };
+                    } else {
+                        if (!_pressedKeysCallbacks[keyCode]) {
+                            _pressedKeysCallbacks[keyCode] = [];
+                        }
+                        _pressedKeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
+                        _pressedKeysCallbacks[keyCode].sort(_sortByPriority);
+                    }
+                    break;
+
+                case "charkeypress":
+                    if (!_charkeysCallbacks[keyCode]) {
+                        _charkeysCallbacks[keyCode] = [];
+                    }
+                    _charkeysCallbacks[keyCode].push({ callback: callback, sender: sender, priority: priority });
+                    _charkeysCallbacks[keyCode].sort(_sortByPriority);
+                    break;
+            }
+        };
+
+        this.isKeyPressed = function (keyCode) {
+            return _currentlyPressedKeys[keyCode];
+        };
+
+        this.handleKeyDown = function () {
+            _anykeyCallback && _anykeyCallback.callback.call(_anykeyCallback.sender, _event);
+            _currentlyPressedKeys[_event.keyCode] = true;
+            for (var ch in _charkeysCallbacks) {
+                if (String.fromCharCode(_event.keyCode) == String.fromCharCode(ch)) {
+                    var ccl = _charkeysCallbacks[ch];
+                    for (var i = 0; i < ccl.length; i++) {
+                        ccl[i].callback.call(ccl[i].sender, _event);
+                    }
+                }
+            }
+
+            if (_event.keyCode == input.KEY_ALT || _event.keyCode == input.KEY_SHIFT) {
+                _event.preventDefault();
+            }
+        };
+
+        this.handleKeyUp = function () {
+            if (_currentlyPressedKeys[_event.keyCode] || _event.keyCode === input.KEY_PRINTSCREEN) {
+                for (var pk in _unpressedKeysCallbacks) {
+                    if (_currentlyPressedKeys[pk] || _event.keyCode === input.KEY_PRINTSCREEN && pk == input.KEY_PRINTSCREEN) {
+                        var cpk = _unpressedKeysCallbacks[pk];
+                        for (var i = 0; i < cpk.length; i++) {
+                            cpk[i].callback.call(cpk[i].sender, _event);
+                        }
+                    }
+                }
+            }
+            _currentlyPressedKeys[_event.keyCode] = false;
+        };
+
+        this.handleEvents = function () {
+            for (var pk in _pressedKeysCallbacks) {
+                if (_currentlyPressedKeys[pk]) {
+                    var cpk = _pressedKeysCallbacks[pk];
+                    for (var i = 0; i < cpk.length; i++) {
+                        cpk[i].callback.call(cpk[i].sender, _event);
+                    }
+                }
+            }
+        };
+    }
+}
+
+export { KeyboardHandler };