@openglobus/og 0.17.2 → 0.18.1

package/src/og/entity/StripHandler.js

@@ -1,158 +0,0 @@
-"use strict";
-
-import { Program } from "../webgl/Program.js";
-
-class StripHandler {
-    constructor(entityCollection) {
-        /**
-         * Picking rendering option.
-         * @public
-         * @type {boolean}
-         */
-        this.pickingEnabled = true;
-
-        /**
-         * Parent collection
-         * @private
-         * @type {EntityCollection}
-         */
-        this._entityCollection = entityCollection;
-
-        /**
-         * Renderer
-         * @private
-         * @type {Renderer}
-         */
-        this._renderer = null;
-
-        /**
-         * Point cloud array
-         * @private
-         * @type {Array.<Strip>}
-         */
-        this._strips = [];
-
-        this.__staticId = StripHandler._staticCounter++;
-    }
-
-    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) {
-            !this._renderer.handler.programs.strip &&
-                this._renderer.handler.addProgram(
-                    new Program("strip", {
-                        uniforms: {
-                            projectionMatrix: { type: "mat4" },
-                            viewMatrix: { type: "mat4" },
-                            eyePositionHigh: "vec3",
-                            eyePositionLow: "vec3",
-                            uColor: { type: "vec4" },
-                            uOpacity: { type: "float" }
-                        },
-                        attributes: {
-                            aVertexPositionHigh: { type: "vec3" },
-                            aVertexPositionLow: { type: "vec3" }
-                        },
-                        vertexShader: `attribute vec3 aVertexPositionHigh;
-                        attribute vec3 aVertexPositionLow;
-                        uniform mat4 projectionMatrix;
-                        uniform mat4 viewMatrix;
-                        uniform vec3 eyePositionHigh;
-                        uniform vec3 eyePositionLow;
-                        void main(void) {
-
-                            vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
-                            vec3 lowDiff = aVertexPositionLow - eyePositionLow;
-
-                            mat4 viewMatrixRTE = viewMatrix;
-                            viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
-
-                            gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
-                        }`,
-                        fragmentShader: `precision highp float;
-                        uniform vec4 uColor;
-                        uniform float uOpacity;
-                        void main(void) {
-                            gl_FragColor = vec4(uColor.rgb, uColor.a * uOpacity);
-                        }`
-                    })
-                );
-        }
-    }
-
-    setRenderNode(renderNode) {
-        this._renderer = renderNode.renderer;
-        this._initProgram();
-        for (let i = 0; i < this._strips.length; i++) {
-            this._strips[i].setRenderNode(renderNode);
-        }
-    }
-
-    add(strip) {
-        if (strip._handlerIndex === -1) {
-            strip._handler = this;
-            strip._handlerIndex = this._strips.length;
-            this._strips.push(strip);
-            this._entityCollection &&
-                this._entityCollection.renderNode &&
-                strip.setRenderNode(this._entityCollection.renderNode);
-        }
-    }
-
-    remove(strip) {
-        var index = strip._handlerIndex;
-        if (index !== -1) {
-            strip._deleteBuffers();
-            strip._handlerIndex = -1;
-            strip._handler = null;
-            this._strips.splice(index, 1);
-            this.reindexStripArray(index);
-        }
-    }
-
-    reindexStripArray(startIndex) {
-        var pc = this._strips;
-        for (let i = startIndex; i < pc.length; i++) {
-            pc[i]._handlerIndex = i;
-        }
-    }
-
-    draw() {
-        var i = this._strips.length;
-        while (i--) {
-            this._strips[i].draw();
-        }
-    }
-
-    drawPicking() {
-        if (this.pickingEnabled) {
-            var i = this._strips.length;
-            while (i--) {
-                this._strips[i].drawPicking();
-            }
-        }
-    }
-
-    clear() {
-        var i = this._strips.length;
-        while (i--) {
-            this._strips[i]._deleteBuffers();
-            this._strips[i]._handler = null;
-            this._strips[i]._handlerIndex = -1;
-        }
-        this._strips.length = 0;
-        this._strips = [];
-    }
-}
-
-export { StripHandler };

package/src/og/entity/index.js

@@ -1,9 +0,0 @@
-import { Billboard } from "./Billboard.js";
-import { Entity } from "./Entity.js";
-import { EntityCollection } from "./EntityCollection.js";
-import { Geometry } from "./Geometry.js";
-import { Label } from "./Label.js";
-import { PointCloud } from "./PointCloud.js";
-import { Polyline } from "./Polyline.js";
-
-export { Entity, EntityCollection, Billboard, Geometry, Label, PointCloud, Polyline };

package/src/og/index.js

@@ -1,112 +0,0 @@
-'use strict';
-
-import * as jd from './astro/jd.js';
-import * as math from './math.js';
-import * as mercator from './mercator.js';
-import * as utils from './utils/shared.js';
-
-import * as bv from './bv/index.js';
-import * as control from './control/index.js';
-import * as entity from './entity/index.js';
-import * as layer from './layer/index.js';
-import * as scene from './scene/index.js';
-import * as terrain from './terrain/index.js';
-import * as webgl from './webgl/index.js';
-
-import { Globe } from './Globe.js';
-
-import { Geoid } from './terrain/Geoid.js';
-
-import { input } from './input/input.js';
-
-import { Ellipsoid, wgs84 } from './ellipsoid/index.js';
-
-import { Camera, PlanetCamera } from './camera/index.js';
-
-import { Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4 } from './math/index.js';
-
-import { Renderer } from './renderer/Renderer.js';
-
-import { LightSource } from './light/LightSource.js';
-
-import { Clock } from './Clock.js';
-import { Events } from './Events.js';
-import { Extent } from './Extent.js';
-import { LonLat } from './LonLat.js';
-import { RenderNode } from './scene/RenderNode.js';
-import { Planet } from './scene/Planet.js';
-
-import { Popup } from './Popup.js';
-
-import {
-    EarthQuadTreeStrategy,
-    MarsQuadTreeStrategy,
-    QuadTreeStrategy,
-    quadTreeStrategyType,
-    Wgs84QuadTreeStrategy
-} from './quadTree/index.js';
-
-
-import { Object3d } from './Object3d.js';
-const { Handler } = webgl, { Control } = control;
-const { Layer, Vector, XYZ, CanvasTiles} = layer;
-const {
-    Polyline,
-    EntityCollection,
-    Entity,
-} = entity;
-
-export {
-    bv,
-    jd,
-    math,
-    mercator,
-    utils,
-    input,
-    Layer,
-    XYZ,
-    Vector,
-    CanvasTiles,
-    layer,
-    terrain,
-    Control,
-    control,
-    webgl,
-    wgs84,
-    Camera,
-    Ellipsoid,
-    Planet,
-    PlanetCamera,
-    Globe,
-    LightSource,
-    Polyline,
-    EntityCollection,
-    Handler,
-    Renderer,
-    Clock,
-    Events,
-    Extent,
-    LonLat,
-    scene,
-    RenderNode,
-    Line2,
-    Line3,
-    Mat3,
-    Mat4,
-    Plane,
-    Quat,
-    Ray,
-    Vec2,
-    Vec3,
-    Vec4,
-    entity,
-    Entity,
-    Geoid,
-    Popup,
-    QuadTreeStrategy,
-    MarsQuadTreeStrategy,
-    EarthQuadTreeStrategy,
-    Wgs84QuadTreeStrategy,
-    quadTreeStrategyType,
-    Object3d
-};

package/src/og/input/KeyboardHandler.js

@@ -1,195 +0,0 @@
-'use strict';
-
-import { input } from './input.js';
-import { stamp } from "../utils/shared.js";
-
-const STAMP_SPACER = "_";
-
-class KeyboardHandler {
-
-    constructor() {
-        let _currentlyPressedKeys = {};
-        let _pressedKeysCallbacks = {};
-        let _unpressedKeysCallbacks = {};
-        let _charkeysCallbacks = {};
-
-        let _that = this;
-        let _anykeyCallback = null;
-        let _event = null;
-
-        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();
-            };
-        }
-
-        var _sortByPriority = function (a, b) {
-            return a.priority < b.priority;
-        };
-
-        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) {
-            _active = activity;
-        };
-
-        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;
-
-            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]) {
-                    let 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,94 +0,0 @@
-'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 };

package/src/og/input/TouchHandler.js

@@ -1,59 +0,0 @@
-'use strict';
-
-class TouchHandler {
-
-    constructor(htmlObject) {
-        this._htmlObject = htmlObject;
-    }
-
-    setEvent(event, sender, callback) {
-        switch (event) {
-            case "touchcancel":
-                this._htmlObject.addEventListener('touchcancel', function (event) {
-                    event.preventDefault();
-                    var rect = this.getBoundingClientRect();
-                    event.offsetLeft = rect.left;
-                    event.offsetTop = rect.top;
-                    callback.call(sender, event);
-                    event.preventDefault();
-                });
-                break;
-
-            case "touchstart":
-                this._htmlObject.addEventListener('touchstart', function (event) {
-                    event.preventDefault();
-                    var rect = this.getBoundingClientRect();
-                    event.offsetLeft = rect.left;
-                    event.offsetTop = rect.top;
-                    callback.call(sender, event);
-                    event.preventDefault();
-                });
-                break;
-
-            case "touchend":
-                this._htmlObject.addEventListener('touchend', function (event) {
-                    event.preventDefault();
-                    var rect = this.getBoundingClientRect();
-                    event.offsetLeft = rect.left;
-                    event.offsetTop = rect.top;
-                    callback.call(sender, event);
-                    event.preventDefault();
-                });
-                break;
-
-            case "touchmove":
-                this._htmlObject.addEventListener('touchmove', function (event) {
-                    event.preventDefault();
-                    var rect = this.getBoundingClientRect();
-                    event.offsetLeft = rect.left;
-                    event.offsetTop = rect.top;
-                    callback.call(sender, event);
-                    event.preventDefault();
-                });
-                break;
-        }
-    }
-}
-
-export { TouchHandler };
-

package/src/og/input/input.js

@@ -1,44 +0,0 @@
-'use strict';
-
-export const input = {
-    KEY_CTRL: 17,
-    KEY_ALT: 18,
-    KEY_SHIFT: 16,
-    KEY_SPACE: 32,
-    KEY_PGUP: 33,
-    KEY_PGDN: 34,
-    KEY_LEFT: 37,
-    KEY_UP: 38,
-    KEY_RIGHT: 39,
-    KEY_DOWN: 40,
-    KEY_PRINTSCREEN: 44,
-    KEY_EQUALS: 61,
-    KEY_A: 65,
-    KEY_C: 67,
-    KEY_D: 68,
-    KEY_E: 69,
-    KEY_F: 70,
-    KEY_H: 72,
-    KEY_I: 73,
-    KEY_K: 75,
-    KEY_L: 76,
-    KEY_N: 78,
-    KEY_O: 79,
-    KEY_P: 80,
-    KEY_Q: 81,
-    KEY_R: 82,
-    KEY_S: 83,
-    KEY_V: 86,
-    KEY_W: 87,
-    KEY_X: 88,
-    KEY_Z: 90,
-    KEY_PLUS: 107,
-    KEY_F1: 112,
-    KEY_MINUS: 173,
-    KEY_APOSTROPHE: 192,
-    MB_LEFT: 0,
-    MB_RIGHT: 2,
-    MB_MIDDLE: 1,
-    KEY_BACK_SLASH: 220,
-    KEY_SINGLE_QUOTE: 222
-};