@openglobus/og 0.18.0 → 0.18.2

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

@@ -1,22 +1,8 @@
-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 {
-
-    protected _htmlObject: HTMLElement;
-
-    constructor(htmlObject: HTMLElement) {
+    constructor(htmlObject) {
         this._htmlObject = htmlObject;
     }
-
-    public setEvent(event: string, sender: any, callback: MouseHandlerEventCallback) {
+    setEvent(event, sender, callback) {
         switch (event) {
             case "mousewheel":
                 // this._htmlObject.addEventListener('mousewheel', function (event: WheelEventExt) {
@@ -27,10 +13,8 @@ class MouseHandler {
                 //     callback.call(sender, event);
                 //     event.preventDefault();
                 // }, false);
-
-                this._htmlObject.addEventListener('wheel', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('wheel', function (event) {
                     let delta = event.deltaY || event.detail || event.wheelDelta || 0;
-
                     if (event.wheelDelta == undefined) {
                         event.wheelDelta = delta * (-120);
                     }
@@ -38,9 +22,8 @@ class MouseHandler {
                     event.preventDefault();
                 }, false);
                 break;
-
             case "mousedown":
-                this._htmlObject.addEventListener('mousedown', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mousedown', function (event) {
                     let rect = this.getBoundingClientRect();
                     callback.call(sender, event, {
                         button: event.button,
@@ -48,14 +31,13 @@ class MouseHandler {
                         clientY: event.clientY - rect.top
                     });
                 });
-                this._htmlObject.addEventListener('contextmenu', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('contextmenu', function (event) {
                     event.preventDefault();
                     return false;
                 });
                 break;
-
             case "mouseup":
-                this._htmlObject.addEventListener('mouseup', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mouseup', function (event) {
                     let rect = this.getBoundingClientRect();
                     callback.call(sender, event, {
                         button: event.button,
@@ -64,9 +46,8 @@ class MouseHandler {
                     });
                 });
                 break;
-
             case "mousemove":
-                this._htmlObject.addEventListener('mousemove', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mousemove', function (event) {
                     let rect = this.getBoundingClientRect();
                     callback.call(sender, event, {
                         clientX: event.clientX - rect.left,
@@ -74,32 +55,27 @@ class MouseHandler {
                     });
                 });
                 break;
-
             case "mouseleave":
-                this._htmlObject.addEventListener('mouseleave', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mouseleave', function (event) {
                     callback.call(sender, event);
                 });
                 break;
-
             case "mouseout":
-                this._htmlObject.addEventListener('mouseout', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mouseout', function (event) {
                     callback.call(sender, event);
                 });
                 break;
-
             case "mouseover":
-                this._htmlObject.addEventListener('mouseover', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mouseover', function (event) {
                     callback.call(sender, event);
                 });
                 break;
-
             case "mouseenter":
-                this._htmlObject.addEventListener('mouseenter', function (event: MouseEventExt) {
+                this._htmlObject.addEventListener('mouseenter', function (event) {
                     callback.call(sender, event);
                 });
                 break;
         }
     }
 }
-
-export {MouseHandler};
+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/{src/input/TouchHandler.ts → lib/js/input/TouchHandler.js}

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

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

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

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

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

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 };