@openglobus/og 0.17.2 → 0.18.0

package/src/entity/index.ts

@@ -0,0 +1,12 @@
+import { Billboard } from "./Billboard";
+import { Entity } from "./Entity";
+import { EntityCollection } from "./EntityCollection";
+import { Geometry } from "./Geometry";
+import { GeoObject } from "./GeoObject";
+import { Label } from "./Label";
+import { PointCloud } from "./PointCloud";
+import { Polyline } from "./Polyline";
+import { Ray } from "./Ray";
+import { Strip } from "./Strip";
+
+export {  Billboard, Entity, EntityCollection, Geometry, GeoObject, Label, PointCloud, Polyline, Ray, Strip };

package/src/index.ts

@@ -0,0 +1,173 @@
+import * as jd from './astro/jd';
+import * as math from './math';
+import * as mercator from './mercator';
+import * as utils from './utils/shared';
+import * as bv from './bv/index';
+import * as control from './control/index';
+import * as scene from './scene/index';
+import * as terrain from './terrain/index';
+import * as layer from './layer/index';
+import * as webgl from './webgl/index';
+
+import {Globe} from './Globe';
+
+import {Geoid} from './terrain/Geoid';
+
+import {input} from './input/input';
+
+import {
+    Ellipsoid,
+    wgs84
+} from './ellipsoid/index';
+
+import {
+    Camera,
+    PlanetCamera
+} from './camera/index';
+
+import {
+    Line2,
+    Line3,
+    Mat3,
+    Mat4,
+    Plane,
+    Quat,
+    Ray,
+    Vec2,
+    Vec3,
+    Vec4
+} from './math/index';
+
+import {Renderer} from './renderer/Renderer';
+import {LightSource} from './light/LightSource';
+import {Clock} from './Clock';
+import {Events} from './Events';
+import {Extent} from './Extent';
+import {LonLat} from './LonLat';
+import {RenderNode} from './scene/RenderNode';
+import {Planet} from './scene/Planet';
+import {Popup} from './Popup';
+
+import {
+    EarthQuadTreeStrategy,
+    MarsQuadTreeStrategy,
+    QuadTreeStrategy,
+    quadTreeStrategyType,
+    Wgs84QuadTreeStrategy
+} from './quadTree/index';
+
+import {Object3d} from './Object3d';
+
+import {
+    Handler,
+    Program,
+    Framebuffer,
+    Multisample
+} from './webgl/index';
+
+import {
+    Control
+} from './control/Control';
+
+import {
+    Entity,
+    EntityCollection,
+    Billboard,
+    Geometry,
+    Label,
+    PointCloud,
+    Polyline,
+    GeoObject
+} from './entity/index';
+
+import {
+    Layer,
+    Vector,
+    XYZ,
+    CanvasTiles,
+    WMS,
+    GeoImage,
+    GeoVideo,
+    GeoTexture2d,
+    KML,
+    Material
+} from './layer/index';
+
+import {
+    EmptyTerrain,
+    GlobusTerrain,
+    MapboxTerrain,
+    BilTerrain
+} from './terrain/index';
+
+export {
+    bv,
+    jd,
+    math,
+    mercator,
+    utils,
+    input,
+    control,
+    scene,
+    quadTreeStrategyType,
+    wgs84,
+    terrain,
+    layer,
+    webgl,
+    Framebuffer,
+    Material,
+    KML,
+    Layer,
+    XYZ,
+    Vector,
+    CanvasTiles,
+    WMS,
+    GeoImage,
+    GeoVideo,
+    GeoTexture2d,
+    EmptyTerrain,
+    GlobusTerrain,
+    MapboxTerrain,
+    BilTerrain,
+    Control,
+    Camera,
+    Ellipsoid,
+    Planet,
+    PlanetCamera,
+    Globe,
+    LightSource,
+    Entity,
+    EntityCollection,
+    Billboard,
+    Geometry,
+    Label,
+    PointCloud,
+    Polyline,
+    Program,
+    GeoObject,
+    Handler,
+    Multisample,
+    Renderer,
+    Clock,
+    Events,
+    Extent,
+    LonLat,
+    RenderNode,
+    Line2,
+    Line3,
+    Mat3,
+    Mat4,
+    Plane,
+    Quat,
+    Ray,
+    Vec2,
+    Vec3,
+    Vec4,
+    Geoid,
+    Popup,
+    QuadTreeStrategy,
+    MarsQuadTreeStrategy,
+    EarthQuadTreeStrategy,
+    Wgs84QuadTreeStrategy,
+    Object3d
+};

package/src/input/KeyboardHandler.ts

@@ -0,0 +1,196 @@
+import {input} from './input';
+import {stamp} from "../utils/shared";
+import {EventCallback, EventCallbackStamp} from "../Events";
+
+const STAMP_SPACER = "_";
+
+interface ICallbackHandler {
+    callback: EventCallbackStamp,
+    sender: any,
+    priority: number
+}
+
+const _sortByPriority = function (a: ICallbackHandler, b: ICallbackHandler): number {
+    return Number(a.priority < b.priority);
+};
+
+class KeyboardHandler {
+    protected _currentlyPressedKeys: Record<number, boolean>;
+    protected _pressedKeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _unpressedKeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _charkeysCallbacks: Record<number, ICallbackHandler[]>;
+    protected _anykeyCallback: any;
+    protected _event: KeyboardEvent | null;
+    protected _active: boolean;
+    protected _stampCache: Record<string, number>;
+
+    constructor() {
+        this._currentlyPressedKeys = {};
+        this._pressedKeysCallbacks = {};
+        this._unpressedKeysCallbacks = {};
+        this._charkeysCallbacks = {};
+        this._anykeyCallback = null;
+        this._event = null;
+        this._active = true;
+        this._stampCache = {};
+
+        document.onkeydown = (event: KeyboardEvent) => {
+            this._event = event;
+            this._active && this.handleKeyDown();
+        };
+
+        document.onkeyup = (event: KeyboardEvent) => {
+            this._event = event;
+            this._active && this.handleKeyUp();
+        };
+    }
+
+    public getcurrentlyPressedKeys(): Record<number, boolean> {
+        return this._currentlyPressedKeys;
+    }
+
+    public getPressedKeysCallbacks() {
+        return this._pressedKeysCallbacks;
+    }
+
+    public getUnpressedKeysCallbacks() {
+        return this._unpressedKeysCallbacks;
+    }
+
+    public getCharkeysCallbacks() {
+        return this._charkeysCallbacks;
+    }
+
+    public removeEvent(event: string, keyCode: number, callback: EventCallback) {
+        let st = this._getStamp(event, keyCode, (callback as EventCallbackStamp)._openglobus_id!);
+        if ((callback as EventCallbackStamp)._openglobus_id && this._stampCache[st]) {
+            //this._stampCache[st] = null;
+            delete this._stampCache[st];
+
+            if (event === "keypress") {
+                this._removeCallback(this._pressedKeysCallbacks[keyCode], callback);
+            } else if (event === "keyfree") {
+                this._removeCallback(this._unpressedKeysCallbacks[keyCode], callback);
+            } else if (event === "charkeypress") {
+                this._removeCallback(this._charkeysCallbacks[keyCode], callback);
+            }
+        }
+    }
+
+    protected _removeCallback(handlers: ICallbackHandler[], callback: EventCallbackStamp) {
+        for (let i = 0; i < handlers.length; i++) {
+            if (handlers[i].callback._openglobus_id === callback._openglobus_id) {
+                handlers.splice(i, 1);
+            }
+        }
+    }
+
+    protected _getStamp(name: string, keyCode: number, ogid: number) {
+        return `${name}${STAMP_SPACER}${keyCode}${STAMP_SPACER}${ogid}`;
+    }
+
+    protected _stamp(name: string, keyCode: number, obj: any) {
+        const ogid = stamp(obj);
+        const st = this._getStamp(name, keyCode, ogid);
+        if (!this._stampCache[st]) {
+            this._stampCache[st] = ogid;
+            return true;
+        }
+        return false;
+    }
+
+    public setActivity(activity: boolean) {
+        this._active = activity;
+    }
+
+    public releaseKeys() {
+        this._currentlyPressedKeys = {};
+    }
+
+    public addEvent(event: string, keyCode: number, callback: EventCallback, sender?: any, priority?: number) {
+
+        // Event is already bound with the callback
+        if (!this._stamp(event, keyCode, callback)) return;
+
+        if (priority === undefined) {
+            priority = 1600;
+        }
+        switch (event) {
+            case "keyfree":
+                if (!this._unpressedKeysCallbacks[keyCode]) {
+                    this._unpressedKeysCallbacks[keyCode] = [];
+                }
+                this._unpressedKeysCallbacks[keyCode].push({callback: callback, sender: sender, priority: priority});
+                this._unpressedKeysCallbacks[keyCode].sort(_sortByPriority);
+                break;
+
+            case "keypress":
+                if (keyCode == null) {
+                    this._anykeyCallback = {callback: callback, sender: sender || this};
+                } else {
+                    if (!this._pressedKeysCallbacks[keyCode]) {
+                        this._pressedKeysCallbacks[keyCode] = [];
+                    }
+                    this._pressedKeysCallbacks[keyCode].push({callback: callback, sender: sender, priority: priority});
+                    this._pressedKeysCallbacks[keyCode].sort(_sortByPriority);
+                }
+                break;
+
+            case "charkeypress":
+                if (!this._charkeysCallbacks[keyCode]) {
+                    this._charkeysCallbacks[keyCode] = [];
+                }
+                this._charkeysCallbacks[keyCode].push({callback: callback, sender: sender, priority: priority});
+                this._charkeysCallbacks[keyCode].sort(_sortByPriority);
+                break;
+        }
+    }
+
+    public isKeyPressed(keyCode: number) {
+        return this._currentlyPressedKeys[keyCode];
+    }
+
+    public handleKeyDown() {
+        this._anykeyCallback && this._anykeyCallback.callback.call(this._anykeyCallback.sender, this._event);
+        this._currentlyPressedKeys[this._event!.keyCode] = true;
+        for (let ch in this._charkeysCallbacks) {
+            if (String.fromCharCode(this._event!.keyCode) === String.fromCharCode(Number(ch))) {
+                let ccl = this._charkeysCallbacks[ch];
+                for (let i = 0; i < ccl.length; i++) {
+                    (ccl[i].callback as Function).call(ccl[i].sender, this._event);
+                }
+            }
+        }
+
+        if (this._event!.keyCode == input.KEY_ALT || this._event!.keyCode == input.KEY_SHIFT) {
+            this._event!.preventDefault();
+        }
+    }
+
+    public handleKeyUp() {
+        if (this._currentlyPressedKeys[this._event!.keyCode] || this._event!.keyCode === input.KEY_PRINTSCREEN) {
+            for (let pk in this._unpressedKeysCallbacks) {
+                if (this._currentlyPressedKeys[pk] || this._event!.keyCode === input.KEY_PRINTSCREEN && Number(pk) === input.KEY_PRINTSCREEN) {
+                    let cpk = this._unpressedKeysCallbacks[pk];
+                    for (let i = 0; i < cpk.length; i++) {
+                        (cpk[i].callback as Function).call(cpk[i].sender, this._event);
+                    }
+                }
+            }
+        }
+        this._currentlyPressedKeys[this._event!.keyCode] = false;
+    }
+
+    public handleEvents() {
+        for (let pk in this._pressedKeysCallbacks) {
+            if (this._currentlyPressedKeys[pk]) {
+                let cpk = this._pressedKeysCallbacks[pk];
+                for (let i = 0; i < cpk.length; i++) {
+                    (cpk[i].callback as Function).call(cpk[i].sender, this._event);
+                }
+            }
+        }
+    }
+}
+
+export {KeyboardHandler};

package/src/{og/input/MouseHandler.js → input/MouseHandler.ts}

@@ -1,89 +1,100 @@
-'use strict';
+export type MouseEventExt = MouseEvent & { wheelDelta?: number; deltaY?: number };
+
+export interface MouseHandlerEvent {
+    button?: number;
+    clientX: number;
+    clientY: number;
+}
+
+type MouseHandlerEventCallback = (sys: MouseEvent, event?: MouseHandlerEvent) => void;
 
 class MouseHandler {
 
-    constructor(htmlObject) {
+    protected _htmlObject: HTMLElement;
+
+    constructor(htmlObject: HTMLElement) {
         this._htmlObject = htmlObject;
     }
 
-    setEvent(event, sender, callback) {
+    public setEvent(event: string, sender: any, callback: MouseHandlerEventCallback) {
         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('mousewheel', function (event: WheelEventExt) {
+                //     let delta = event.deltaY || event.detail || event.wheelDelta || 0;
+                //     if (event.wheelDelta == undefined) {
+                //         event.wheelDelta = delta * (-120);
+                //     }
+                //     callback.call(sender, event);
+                //     event.preventDefault();
+                // }, false);
+
+                this._htmlObject.addEventListener('wheel', function (event: MouseEventExt) {
+                    let delta = event.deltaY || event.detail || event.wheelDelta || 0;
 
-                this._htmlObject.addEventListener('wheel', function (evt) {
-                    var delta = evt.deltaY || evt.detail || evt.wheelDelta;
-                    if (evt.wheelDelta == undefined) {
-                        evt.wheelDelta = delta * (-120);
+                    if (event.wheelDelta == undefined) {
+                        event.wheelDelta = delta * (-120);
                     }
-                    callback.call(sender, evt);
-                    evt.preventDefault();
+                    callback.call(sender, event);
+                    event.preventDefault();
                 }, false);
                 break;
 
             case "mousedown":
-                this._htmlObject.addEventListener('mousedown', function (event) {
-                    var rect = this.getBoundingClientRect();
-                    callback.call(sender, {
+                this._htmlObject.addEventListener('mousedown', function (event: MouseEventExt) {
+                    let rect = this.getBoundingClientRect();
+                    callback.call(sender, event, {
                         button: event.button,
                         clientX: event.clientX - rect.left,
                         clientY: event.clientY - rect.top
-                    }, event);
+                    });
                 });
-                this._htmlObject.addEventListener('contextmenu', function (event) {
+                this._htmlObject.addEventListener('contextmenu', function (event: MouseEventExt) {
                     event.preventDefault();
                     return false;
                 });
                 break;
 
             case "mouseup":
-                this._htmlObject.addEventListener('mouseup', function (event) {
-                    var rect = this.getBoundingClientRect();
-                    callback.call(sender, {
+                this._htmlObject.addEventListener('mouseup', function (event: MouseEventExt) {
+                    let rect = this.getBoundingClientRect();
+                    callback.call(sender, event, {
                         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, {
+                this._htmlObject.addEventListener('mousemove', function (event: MouseEventExt) {
+                    let rect = this.getBoundingClientRect();
+                    callback.call(sender, event, {
                         clientX: event.clientX - rect.left,
                         clientY: event.clientY - rect.top
-                    }, event);
+                    });
                 });
                 break;
 
             case "mouseleave":
-                this._htmlObject.addEventListener('mouseleave', function (event) {
+                this._htmlObject.addEventListener('mouseleave', function (event: MouseEventExt) {
                     callback.call(sender, event);
                 });
                 break;
 
             case "mouseout":
-                this._htmlObject.addEventListener('mouseout', function (event) {
+                this._htmlObject.addEventListener('mouseout', function (event: MouseEventExt) {
                     callback.call(sender, event);
                 });
                 break;
 
             case "mouseover":
-                this._htmlObject.addEventListener('mouseover', function (event) {
+                this._htmlObject.addEventListener('mouseover', function (event: MouseEventExt) {
                     callback.call(sender, event);
                 });
                 break;
 
             case "mouseenter":
-                this._htmlObject.addEventListener('mouseenter', function (event) {
+                this._htmlObject.addEventListener('mouseenter', function (event: MouseEventExt) {
                     callback.call(sender, event);
                 });
                 break;
@@ -91,4 +102,4 @@ class MouseHandler {
     }
 }
 
-export { MouseHandler };
+export {MouseHandler};

package/src/input/TouchHandler.ts

@@ -0,0 +1,54 @@
+export type TouchEventExt = TouchEvent & { offsetLeft: number; offsetTop: number };
+type TouchHandlerEventCallback = (sys: TouchEventExt) => void;
+
+class TouchHandler {
+
+    protected _htmlObject: HTMLElement;
+
+    constructor(htmlObject: HTMLElement) {
+        this._htmlObject = htmlObject;
+    }
+
+    public setEvent(event: string, sender: any, callback: TouchHandlerEventCallback) {
+        switch (event) {
+            case "touchcancel":
+                this._htmlObject.addEventListener('touchcancel', function (event: TouchEvent) {
+                    event.preventDefault();
+                    const rect = this.getBoundingClientRect();
+                    const eventExt: TouchEventExt = Object.assign(event, { offsetLeft: rect.left, offsetTop: rect.top });
+                    callback.call(sender, eventExt);
+                });
+                break;
+
+            case "touchstart":
+                this._htmlObject.addEventListener('touchstart', function (event: TouchEvent) {
+                    event.preventDefault();
+                    const rect = this.getBoundingClientRect();
+                    const eventExt: TouchEventExt = Object.assign(event, { offsetLeft: rect.left, offsetTop: rect.top });
+                    callback.call(sender, eventExt);
+                });
+                break;
+
+            case "touchend":
+                this._htmlObject.addEventListener('touchend', function (event: TouchEvent) {
+                    event.preventDefault();
+                    const rect = this.getBoundingClientRect();
+                    const eventExt: TouchEventExt = Object.assign(event, { offsetLeft: rect.left, offsetTop: rect.top });
+                    callback.call(sender, eventExt);
+                });
+                break;
+
+            case "touchmove":
+                this._htmlObject.addEventListener('touchmove', function (event: TouchEvent) {
+                    event.preventDefault();
+                    const rect = this.getBoundingClientRect();
+                    const eventExt: TouchEventExt = Object.assign(event, { offsetLeft: rect.left, offsetTop: rect.top });
+                    callback.call(sender, eventExt);
+                });
+                break;
+        }
+    }
+}
+
+export {TouchHandler};
+

package/src/{og/input/input.js → input/input.ts}

@@ -1,6 +1,4 @@
-'use strict';
-
-export const input = {
+export const input: { [id: string]: number } = {
     KEY_CTRL: 17,
     KEY_ALT: 18,
     KEY_SHIFT: 16,