@openglobus/og 0.17.2 → 0.18.1

package/lib/js/input/KeyboardHandler.js

@@ -0,0 +1,157 @@
+import { input } from './input';
+import { stamp } from "../utils/shared";
+const STAMP_SPACER = "_";
+const _sortByPriority = function (a, b) {
+    return Number(a.priority < b.priority);
+};
+class KeyboardHandler {
+    constructor() {
+        this._currentlyPressedKeys = {};
+        this._pressedKeysCallbacks = {};
+        this._unpressedKeysCallbacks = {};
+        this._charkeysCallbacks = {};
+        this._anykeyCallback = null;
+        this._event = null;
+        this._active = true;
+        this._stampCache = {};
+        document.onkeydown = (event) => {
+            this._event = event;
+            this._active && this.handleKeyDown();
+        };
+        document.onkeyup = (event) => {
+            this._event = event;
+            this._active && this.handleKeyUp();
+        };
+    }
+    getcurrentlyPressedKeys() {
+        return this._currentlyPressedKeys;
+    }
+    getPressedKeysCallbacks() {
+        return this._pressedKeysCallbacks;
+    }
+    getUnpressedKeysCallbacks() {
+        return this._unpressedKeysCallbacks;
+    }
+    getCharkeysCallbacks() {
+        return this._charkeysCallbacks;
+    }
+    removeEvent(event, keyCode, callback) {
+        let st = this._getStamp(event, keyCode, callback._openglobus_id);
+        if (callback._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);
+            }
+        }
+    }
+    _removeCallback(handlers, callback) {
+        for (let i = 0; i < handlers.length; i++) {
+            if (handlers[i].callback._openglobus_id === callback._openglobus_id) {
+                handlers.splice(i, 1);
+            }
+        }
+    }
+    _getStamp(name, keyCode, ogid) {
+        return `${name}${STAMP_SPACER}${keyCode}${STAMP_SPACER}${ogid}`;
+    }
+    _stamp(name, keyCode, obj) {
+        const ogid = stamp(obj);
+        const st = this._getStamp(name, keyCode, ogid);
+        if (!this._stampCache[st]) {
+            this._stampCache[st] = ogid;
+            return true;
+        }
+        return false;
+    }
+    setActivity(activity) {
+        this._active = activity;
+    }
+    releaseKeys() {
+        this._currentlyPressedKeys = {};
+    }
+    addEvent(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 (!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;
+        }
+    }
+    isKeyPressed(keyCode) {
+        return this._currentlyPressedKeys[keyCode];
+    }
+    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.call(ccl[i].sender, this._event);
+                }
+            }
+        }
+        if (this._event.keyCode == input.KEY_ALT || this._event.keyCode == input.KEY_SHIFT) {
+            this._event.preventDefault();
+        }
+    }
+    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.call(cpk[i].sender, this._event);
+                    }
+                }
+            }
+        }
+        this._currentlyPressedKeys[this._event.keyCode] = false;
+    }
+    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.call(cpk[i].sender, this._event);
+                }
+            }
+        }
+    }
+}
+export { KeyboardHandler };

package/lib/js/input/MouseHandler.d.ts

@@ -0,0 +1,16 @@
+export type MouseEventExt = MouseEvent & {
+    wheelDelta?: number;
+    deltaY?: number;
+};
+export interface MouseHandlerEvent {
+    button?: number;
+    clientX: number;
+    clientY: number;
+}
+type MouseHandlerEventCallback = (sys: MouseEvent, event?: MouseHandlerEvent) => void;
+declare class MouseHandler {
+    protected _htmlObject: HTMLElement;
+    constructor(htmlObject: HTMLElement);
+    setEvent(event: string, sender: any, callback: MouseHandlerEventCallback): void;
+}
+export { MouseHandler };

package/lib/js/input/MouseHandler.js

@@ -0,0 +1,81 @@
+class MouseHandler {
+    constructor(htmlObject) {
+        this._htmlObject = htmlObject;
+    }
+    setEvent(event, sender, callback) {
+        switch (event) {
+            case "mousewheel":
+                // 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) {
+                    let delta = event.deltaY || event.detail || event.wheelDelta || 0;
+                    if (event.wheelDelta == undefined) {
+                        event.wheelDelta = delta * (-120);
+                    }
+                    callback.call(sender, event);
+                    event.preventDefault();
+                }, false);
+                break;
+            case "mousedown":
+                this._htmlObject.addEventListener('mousedown', function (event) {
+                    let rect = this.getBoundingClientRect();
+                    callback.call(sender, event, {
+                        button: event.button,
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    });
+                });
+                this._htmlObject.addEventListener('contextmenu', function (event) {
+                    event.preventDefault();
+                    return false;
+                });
+                break;
+            case "mouseup":
+                this._htmlObject.addEventListener('mouseup', function (event) {
+                    let rect = this.getBoundingClientRect();
+                    callback.call(sender, event, {
+                        button: event.button,
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    });
+                });
+                break;
+            case "mousemove":
+                this._htmlObject.addEventListener('mousemove', function (event) {
+                    let rect = this.getBoundingClientRect();
+                    callback.call(sender, event, {
+                        clientX: event.clientX - rect.left,
+                        clientY: event.clientY - rect.top
+                    });
+                });
+                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/lib/js/input/TouchHandler.d.ts

@@ -0,0 +1,11 @@
+export type TouchEventExt = TouchEvent & {
+    offsetLeft: number;
+    offsetTop: number;
+};
+type TouchHandlerEventCallback = (sys: TouchEventExt) => void;
+declare class TouchHandler {
+    protected _htmlObject: HTMLElement;
+    constructor(htmlObject: HTMLElement);
+    setEvent(event: string, sender: any, callback: TouchHandlerEventCallback): void;
+}
+export { TouchHandler };

package/lib/js/input/TouchHandler.js

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

package/lib/js/input/input.d.ts

@@ -0,0 +1,3 @@
+export declare const input: {
+    [id: string]: number;
+};

package/lib/js/input/input.js

@@ -0,0 +1,42 @@
+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
+};

package/lib/js/layer/BaseGeoImage.d.ts

@@ -0,0 +1,145 @@
+import { Extent } from "../Extent";
+import { EventCallback, EventsHandler } from "../Events";
+import { Layer, LayerEventsList, ILayerParams } from "./Layer";
+import { LonLat } from "../LonLat";
+import { Material } from "./Material";
+import { NumberArray2 } from "../math/Vec2";
+import { NumberArray4 } from "../math/Vec4";
+import { Planet } from "../scene/Planet";
+import { WebGLBufferExt, WebGLTextureExt } from "../webgl/Handler";
+export interface IBaseGeoImageParams extends ILayerParams {
+    fullExtent?: boolean;
+    corners?: NumberArray2[];
+}
+type BaseGeoImageEventsList = [
+    "loadend"
+];
+export type BaseGeoImageEventsType = EventsHandler<BaseGeoImageEventsList> & EventsHandler<LayerEventsList>;
+/**
+ * BaseGeoImage layer represents square imagery layer that
+ * could be a static image, or animated video or webgl buffer
+ * object displayed on the globe.
+ * @class
+ * @extends {Layer}
+ */
+declare class BaseGeoImage extends Layer {
+    events: BaseGeoImageEventsType;
+    protected _projType: number;
+    protected _frameWidth: number;
+    protected _frameHeight: number;
+    protected _sourceReady: boolean;
+    protected _sourceTexture: WebGLTextureExt | null;
+    protected _materialTexture: WebGLTextureExt | null;
+    protected _gridBufferLow: WebGLBufferExt | null;
+    protected _gridBufferHigh: WebGLBufferExt | null;
+    protected _extentWgs84ParamsHigh: Float32Array;
+    protected _extentWgs84ParamsLow: Float32Array;
+    protected _extentMercParamsHigh: Float32Array;
+    protected _extentMercParamsLow: Float32Array;
+    protected _refreshFrame: boolean;
+    protected _frameCreated: boolean;
+    protected _sourceCreated: boolean;
+    _animate: boolean;
+    protected _ready: boolean;
+    _creationProceeding: boolean;
+    _isRendering: boolean;
+    protected _extentWgs84: Extent;
+    protected _cornersWgs84: LonLat[];
+    protected _cornersMerc: LonLat[];
+    protected _isFullExtent: number;
+    /**
+     * rendering function pointer
+     * @type {Function}
+     */
+    rendering: Function;
+    protected _onLoadend_: EventCallback | null;
+    constructor(name: string | null, options?: IBaseGeoImageParams);
+    get isIdle(): boolean;
+    addTo(planet: Planet): void;
+    protected _onLoadend(): void;
+    remove(): this;
+    get instanceName(): string;
+    /**
+     * Gets corners coordinates.
+     * @public
+     * @return {Array.<LonLat>} - (exactly 4 entries)
+     */
+    getCornersLonLat(): LonLat[];
+    /**
+     * Gets corners coordinates.
+     * @public
+     * @return {Array.<Array<number>>} - (exactly 3 entries)
+     */
+    getCorners(): NumberArray2[];
+    /**
+     * Sets geoImage geographical corners coordinates.
+     * @public
+     * @param {Array.<Array.<number>>} corners - GeoImage corners coordinates. Where first coordinate (exactly 3 entries)
+     * coincedents to the left top image corner, secont to the right top image corner, third to the right bottom
+     * and fourth - left bottom image corner.
+     */
+    setCorners(corners: NumberArray2[]): void;
+    /**
+     * Sets geoImage geographical corners coordinates.
+     * @public
+     * @param {Array.<LonLat>} corners - GeoImage corners coordinates. Where first coordinate
+     * coincedents to the left top image corner, secont to the right top image corner, third to the right bottom
+     * and fourth - left bottom image corner. (exactly 4 entries)
+     */
+    setCornersLonLat(corners: LonLat[]): void;
+    /**
+     * Creates geoImage frame.
+     * @protected
+     */
+    protected _createFrame(): void;
+    /**
+     * @public
+     * @override
+     * @param {Material} material - GeoImage material.
+     */
+    abortMaterialLoading(material: Material): void;
+    /**
+     * Clear layer material.
+     * @public
+     * @override
+     */
+    clear(): void;
+    /**
+     * Sets layer visibility.
+     * @public
+     * @override
+     * @param {boolean} visibility - GeoImage visibility.
+     */
+    setVisibility(visibility: boolean): void;
+    /**
+     * @public
+     * @param {Material} material - GeoImage material.
+     */
+    clearMaterial(material: Material): void;
+    /**
+     * @public
+     * @override
+     * @returns {Array<number>} -
+     */
+    applyMaterial(material: Material): NumberArray4;
+    /**
+     * Gets frame width size in pixels.
+     * @public
+     * @returns {Number} Frame width.
+     */
+    get getFrameWidth(): number;
+    /**
+     * Gets frame height size in pixels.
+     * @public
+     * @returns {Number} Frame height.
+     */
+    get getFrameHeight(): number;
+    /**
+     * Method depends on GeoImage instance
+     * @protected
+     */
+    protected _createSourceTexture(): void;
+    _renderingProjType1(): void;
+    protected _renderingProjType0(): void;
+}
+export { BaseGeoImage };