@openglobus/og 0.16.3 → 0.17.1

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/RayHandler.js

@@ -74,7 +74,7 @@ class RayHandler {
     }
 
     static concArr(dest, curr) {
-        for (var i = 0; i < curr.length; i++) {
+        for (let i = 0; i < curr.length; i++) {
             dest.push(curr[i]);
         }
     }
@@ -457,7 +457,7 @@ class RayHandler {
 
     reindexRaysArray(startIndex) {
         var r = this._rays;
-        for (var i = startIndex; i < r.length; i++) {
+        for (let i = startIndex; i < r.length; i++) {
             r[i]._handlerIndex = i;
         }
     }

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/entity/StripHandler.js

@@ -93,7 +93,7 @@ class StripHandler {
     setRenderNode(renderNode) {
         this._renderer = renderNode.renderer;
         this._initProgram();
-        for (var i = 0; i < this._strips.length; i++) {
+        for (let i = 0; i < this._strips.length; i++) {
             this._strips[i].setRenderNode(renderNode);
         }
     }
@@ -122,7 +122,7 @@ class StripHandler {
 
     reindexStripArray(startIndex) {
         var pc = this._strips;
-        for (var i = startIndex; i < pc.length; i++) {
+        for (let i = startIndex; i < pc.length; i++) {
             pc[i]._handlerIndex = i;
         }
     }

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 (let ch in _charkeysCallbacks) {
+                if (String.fromCharCode(_event.keyCode) == String.fromCharCode(ch)) {
+                    var ccl = _charkeysCallbacks[ch];
+                    for (let 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 (let pk in _unpressedKeysCallbacks) {
+                    if (_currentlyPressedKeys[pk] || _event.keyCode === input.KEY_PRINTSCREEN && pk == input.KEY_PRINTSCREEN) {
+                        var cpk = _unpressedKeysCallbacks[pk];
+                        for (let i = 0; i < cpk.length; i++) {
+                            cpk[i].callback.call(cpk[i].sender, _event);
+                        }
+                    }
+                }
+            }
+            _currentlyPressedKeys[_event.keyCode] = false;
+        };
+
+        this.handleEvents = function () {
+            for (let pk in _pressedKeysCallbacks) {
+                if (_currentlyPressedKeys[pk]) {
+                    var cpk = _pressedKeysCallbacks[pk];
+                    for (let i = 0; i < cpk.length; i++) {
+                        cpk[i].callback.call(cpk[i].sender, _event);
+                    }
+                }
+            }
+        };
+    }
+}
+
+export { KeyboardHandler };

package/src/og/input/MouseHandler.js

@@ -1,98 +1,94 @@
-/**
- * @module og/input/MouseHandler
- */
-
-'use strict';
-
-class MouseHandler {
-
-    constructor(htmlObject) {
-        this._htmlObject = htmlObject;
-    }
-
-    setEvent(event, sender, callback) {
-        switch (event) {
-            case "mousewheel":
-                this._htmlObject.addEventListener('mousewheel', function (evt) {
-                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
-                    if (evt.wheelDelta == undefined) {
-                        evt.wheelDelta = delta * (-120);
-                    }
-                    callback.call(sender, evt);
-                    evt.preventDefault();
-                }, false);
-
-                this._htmlObject.addEventListener('wheel', function (evt) {
-                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
-                    if (evt.wheelDelta == undefined) {
-                        evt.wheelDelta = delta * (-120);
-                    }
-                    callback.call(sender, evt);
-                    evt.preventDefault();
-                }, false);
-                break;
-
-            case "mousedown":
-                this._htmlObject.addEventListener('mousedown', function (event) {
-                    var rect = this.getBoundingClientRect();
-                    callback.call(sender, {
-                        button: event.button,
-                        clientX: event.clientX - rect.left,
-                        clientY: event.clientY - rect.top
-                    }, event);
-                });
-                this._htmlObject.addEventListener('contextmenu', function (event) {
-                    event.preventDefault();
-                    return false;
-                });
-                break;
-
-            case "mouseup":
-                this._htmlObject.addEventListener('mouseup', function (event) {
-                    var rect = this.getBoundingClientRect();
-                    callback.call(sender, {
-                        button: event.button,
-                        clientX: event.clientX - rect.left,
-                        clientY: event.clientY - rect.top
-                    }, event);
-                });
-                break;
-
-            case "mousemove":
-                this._htmlObject.addEventListener('mousemove', function (event) {
-                    var rect = this.getBoundingClientRect();
-                    callback.call(sender, {
-                        clientX: event.clientX - rect.left,
-                        clientY: event.clientY - rect.top
-                    }, event);
-                });
-                break;
-
-            case "mouseleave":
-                this._htmlObject.addEventListener('mouseleave', function (event) {
-                    callback.call(sender, event);
-                });
-                break;
-
-            case "mouseout":
-                this._htmlObject.addEventListener('mouseout', function (event) {
-                    callback.call(sender, event);
-                });
-                break;
-
-            case "mouseover":
-                this._htmlObject.addEventListener('mouseover', function (event) {
-                    callback.call(sender, event);
-                });
-                break;
-
-            case "mouseenter":
-                this._htmlObject.addEventListener('mouseenter', function (event) {
-                    callback.call(sender, event);
-                });
-                break;
-        }
-    }
-}
-
-export { MouseHandler };
+'use strict';
+
+class MouseHandler {
+
+    constructor(htmlObject) {
+        this._htmlObject = htmlObject;
+    }
+
+    setEvent(event, sender, callback) {
+        switch (event) {
+            case "mousewheel":
+                this._htmlObject.addEventListener('mousewheel', function (evt) {
+                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
+                    if (evt.wheelDelta == undefined) {
+                        evt.wheelDelta = delta * (-120);
+                    }
+                    callback.call(sender, evt);
+                    evt.preventDefault();
+                }, false);
+
+                this._htmlObject.addEventListener('wheel', function (evt) {
+                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
+                    if (evt.wheelDelta == undefined) {
+                        evt.wheelDelta = delta * (-120);
+                    }
+                    callback.call(sender, evt);
+                    evt.preventDefault();
+                }, false);
+                break;
+
+            case "mousedown":
+                this._htmlObject.addEventListener('mousedown', function (event) {
+                    var rect = this.getBoundingClientRect();
+                    callback.call(sender, {
+                        button: event.button,
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    }, event);
+                });
+                this._htmlObject.addEventListener('contextmenu', function (event) {
+                    event.preventDefault();
+                    return false;
+                });
+                break;
+
+            case "mouseup":
+                this._htmlObject.addEventListener('mouseup', function (event) {
+                    var rect = this.getBoundingClientRect();
+                    callback.call(sender, {
+                        button: event.button,
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    }, event);
+                });
+                break;
+
+            case "mousemove":
+                this._htmlObject.addEventListener('mousemove', function (event) {
+                    var rect = this.getBoundingClientRect();
+                    callback.call(sender, {
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    }, event);
+                });
+                break;
+
+            case "mouseleave":
+                this._htmlObject.addEventListener('mouseleave', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
+
+            case "mouseout":
+                this._htmlObject.addEventListener('mouseout', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
+
+            case "mouseover":
+                this._htmlObject.addEventListener('mouseover', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
+
+            case "mouseenter":
+                this._htmlObject.addEventListener('mouseenter', function (event) {
+                    callback.call(sender, event);
+                });
+                break;
+        }
+    }
+}
+
+export { MouseHandler };