@openglobus/og 0.24.2 → 0.25.0

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

@@ -1,33 +0,0 @@
-import type { EventCallback, EventCallbackStamp } from "../Events";
-interface ICallbackHandler {
-    callback: EventCallbackStamp;
-    sender: any;
-    priority: number;
-}
-declare 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();
-    getcurrentlyPressedKeys(): Record<number, boolean>;
-    getPressedKeysCallbacks(): Record<number, ICallbackHandler[]>;
-    getUnpressedKeysCallbacks(): Record<number, ICallbackHandler[]>;
-    getCharkeysCallbacks(): Record<number, ICallbackHandler[]>;
-    removeEvent(event: string, keyCode: number, callback: EventCallback): void;
-    protected _removeCallback(handlers: ICallbackHandler[], callback: EventCallbackStamp): void;
-    protected _getStamp(name: string, keyCode: number, ogid: number): string;
-    protected _stamp(name: string, keyCode: number, obj: any): boolean;
-    setActivity(activity: boolean): void;
-    releaseKeys(): void;
-    addEvent(event: string, keyCode: number, callback: EventCallback, sender?: any, priority?: number): void;
-    isKeyPressed(keyCode: number): boolean;
-    handleKeyDown(): void;
-    handleKeyUp(): void;
-    handleEvents(): void;
-}
-export { KeyboardHandler };

package/lib/js/input/KeyboardHandler.js

@@ -1,159 +0,0 @@
-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() {
-        // If you want to get a key code just uncomment and check console
-        //console.log(this._event!.keyCode);
-        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

@@ -1,17 +0,0 @@
-export type MouseEventExt = MouseEvent & {
-    wheelDelta?: number;
-    deltaY?: number;
-    isTouchPad?: boolean;
-};
-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

@@ -1,92 +0,0 @@
-function _checkTouchPad(e) {
-    //@ts-ignore
-    if (e.deltaMode !== 0) {
-        return false;
-    }
-    //@ts-ignore
-    return Math.abs(e.deltaY) < 50;
-    //@ts-ignore
-    //return e.wheelDeltaY ? e.wheelDeltaY === -3 * e.deltaY : e.deltaMode === 0
-}
-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', (event) => {
-                    let delta = event.deltaY || event.detail || event.wheelDelta || 0;
-                    if (event.wheelDelta == undefined) {
-                        event.wheelDelta = delta * (-120);
-                    }
-                    event.isTouchPad = _checkTouchPad(event);
-                    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

@@ -1,11 +0,0 @@
-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

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

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

package/lib/js/input/input.js

@@ -1,47 +0,0 @@
-export const input = {
-    MB_LEFT: 0,
-    MB_RIGHT: 2,
-    MB_MIDDLE: 1,
-    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,
-    KEY_BACK_SLASH: 220,
-    KEY_MORE: 190,
-    KEY_SLASH: 191,
-    KEY_LESS: 188,
-    KEY_LEFT_SQUARE_BRACKET: 219,
-    KEY_RIGHT_SQUARE_BRACKET: 221,
-    KEY_SINGLE_QUOTE: 222
-};

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

@@ -1,146 +0,0 @@
-import { Extent } from "../Extent";
-import type { EventCallback, EventsHandler } from "../Events";
-import { Layer } from "./Layer";
-import type { LayerEventsList, ILayerParams } from "./Layer";
-import { LonLat } from "../LonLat";
-import { Material } from "./Material";
-import type { NumberArray2 } from "../math/Vec2";
-import type { NumberArray4 } from "../math/Vec4";
-import { Planet } from "../scene/Planet";
-import type { 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 };