@openglobus/og 0.18.0 → 0.18.2

package/lib/js/entity/StripHandler.d.ts

@@ -0,0 +1,42 @@
+import { EntityCollection } from "./EntityCollection";
+import { Renderer } from "../renderer/Renderer";
+import { RenderNode } from "../scene/RenderNode";
+import { Strip } from "./Strip";
+declare class StripHandler {
+    static __counter__: number;
+    protected __id: number;
+    /**
+     * Picking rendering option.
+     * @public
+     * @type {boolean}
+     */
+    pickingEnabled: boolean;
+    /**
+     * Parent collection
+     * @protected
+     * @type {EntityCollection}
+     */
+    protected _entityCollection: EntityCollection;
+    /**
+     * Renderer
+     * @protected
+     * @type {Renderer | null}
+     */
+    protected _renderer: Renderer | null;
+    /**
+     * Strip objects array
+     * @protected
+     * @type {Array.<Strip>}
+     */
+    protected _strips: Strip[];
+    constructor(entityCollection: EntityCollection);
+    protected _initProgram(): void;
+    setRenderNode(renderNode: RenderNode): void;
+    add(strip: Strip): void;
+    remove(strip: Strip): void;
+    reindexStripArray(startIndex: number): void;
+    draw(): void;
+    drawPicking(): void;
+    clear(): void;
+}
+export { StripHandler };

package/{src/entity/StripHandler.ts → lib/js/entity/StripHandler.js}

@@ -1,71 +1,27 @@
-import {EntityCollection} from "./EntityCollection";
-import {Program} from "../webgl/Program";
-import {Renderer} from "../renderer/Renderer";
-import {RenderNode} from "../scene/RenderNode";
-import {Strip} from "./Strip";
-
+import { Program } from "../webgl/Program";
 class StripHandler {
-
-    static __counter__: number = 0;
-    protected __id: number;
-
-    /**
-     * Picking rendering option.
-     * @public
-     * @type {boolean}
-     */
-    public pickingEnabled: boolean;
-
-    /**
-     * Parent collection
-     * @protected
-     * @type {EntityCollection}
-     */
-    protected _entityCollection: EntityCollection;
-
-    /**
-     * Renderer
-     * @protected
-     * @type {Renderer | null}
-     */
-    protected _renderer: Renderer | null;
-
-    /**
-     * Strip objects array
-     * @protected
-     * @type {Array.<Strip>}
-     */
-    protected _strips: Strip[];
-
-    constructor(entityCollection: EntityCollection) {
-
+    constructor(entityCollection) {
         this.__id = StripHandler.__counter__++;
-
         this.pickingEnabled = true;
-
         this._entityCollection = entityCollection;
-
         this._renderer = null;
-
         this._strips = [];
     }
-
-    protected _initProgram() {
+    _initProgram() {
         if (this._renderer && this._renderer.handler) {
             !this._renderer.handler.programs.strip &&
-            this._renderer.handler.addProgram(
-                new Program("strip", {
+                this._renderer.handler.addProgram(new Program("strip", {
                     uniforms: {
-                        projectionMatrix: {type: "mat4"},
-                        viewMatrix: {type: "mat4"},
+                        projectionMatrix: { type: "mat4" },
+                        viewMatrix: { type: "mat4" },
                         eyePositionHigh: "vec3",
                         eyePositionLow: "vec3",
-                        uColor: {type: "vec4"},
-                        uOpacity: {type: "float"}
+                        uColor: { type: "vec4" },
+                        uOpacity: { type: "float" }
                     },
                     attributes: {
-                        aVertexPositionHigh: {type: "vec3"},
-                        aVertexPositionLow: {type: "vec3"}
+                        aVertexPositionHigh: { type: "vec3" },
+                        aVertexPositionLow: { type: "vec3" }
                     },
                     vertexShader: `attribute vec3 aVertexPositionHigh;
                         attribute vec3 aVertexPositionLow;
@@ -89,31 +45,27 @@ class StripHandler {
                         void main(void) {
                             gl_FragColor = vec4(uColor.rgb, uColor.a * uOpacity);
                         }`
-                })
-            );
+                }));
         }
     }
-
-    public setRenderNode(renderNode: RenderNode) {
+    setRenderNode(renderNode) {
         this._renderer = renderNode.renderer;
         this._initProgram();
         for (let i = 0; i < this._strips.length; i++) {
             this._strips[i].setRenderNode(renderNode);
         }
     }
-
-    public add(strip: Strip) {
+    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);
+                this._entityCollection.renderNode &&
+                strip.setRenderNode(this._entityCollection.renderNode);
         }
     }
-
-    public remove(strip: Strip) {
+    remove(strip) {
         let index = strip._handlerIndex;
         if (index !== -1) {
             strip._deleteBuffers();
@@ -123,22 +75,19 @@ class StripHandler {
             this.reindexStripArray(index);
         }
     }
-
-    public reindexStripArray(startIndex: number) {
+    reindexStripArray(startIndex) {
         let pc = this._strips;
         for (let i = startIndex; i < pc.length; i++) {
             pc[i]._handlerIndex = i;
         }
     }
-
-    public draw() {
+    draw() {
         let i = this._strips.length;
         while (i--) {
             this._strips[i].draw();
         }
     }
-
-    public drawPicking() {
+    drawPicking() {
         if (this.pickingEnabled) {
             let i = this._strips.length;
             while (i--) {
@@ -146,8 +95,7 @@ class StripHandler {
             }
         }
     }
-
-    public clear() {
+    clear() {
         let i = this._strips.length;
         while (i--) {
             this._strips[i]._deleteBuffers();
@@ -158,5 +106,5 @@ class StripHandler {
         this._strips = [];
     }
 }
-
-export {StripHandler};
+StripHandler.__counter__ = 0;
+export { StripHandler };

package/{src/entity/index.ts → lib/js/entity/index.d.ts}

@@ -8,5 +8,4 @@ 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 };
+export { Billboard, Entity, EntityCollection, Geometry, GeoObject, Label, PointCloud, Polyline, Ray, Strip };

package/lib/js/entity/index.js

@@ -0,0 +1,11 @@
+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/lib/js/index.d.ts

@@ -0,0 +1,33 @@
+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/lib/js/index.js

@@ -0,0 +1,33 @@
+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/lib/js/input/KeyboardHandler.d.ts

@@ -0,0 +1,33 @@
+import { 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/{src/input/KeyboardHandler.ts → lib/js/input/KeyboardHandler.js}

@@ -1,29 +1,10 @@
-import {input} from './input';
-import {stamp} from "../utils/shared";
-import {EventCallback, EventCallbackStamp} from "../Events";
-
+import { input } from './input';
+import { stamp } from "../utils/shared";
 const STAMP_SPACER = "_";
-
-interface ICallbackHandler {
-    callback: EventCallbackStamp,
-    sender: any,
-    priority: number
-}
-
-const _sortByPriority = function (a: ICallbackHandler, b: ICallbackHandler): number {
+const _sortByPriority = function (a, b) {
     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 = {};
@@ -33,63 +14,54 @@ class KeyboardHandler {
         this._event = null;
         this._active = true;
         this._stampCache = {};
-
-        document.onkeydown = (event: KeyboardEvent) => {
+        document.onkeydown = (event) => {
             this._event = event;
             this._active && this.handleKeyDown();
         };
-
-        document.onkeyup = (event: KeyboardEvent) => {
+        document.onkeyup = (event) => {
             this._event = event;
             this._active && this.handleKeyUp();
         };
     }
-
-    public getcurrentlyPressedKeys(): Record<number, boolean> {
+    getcurrentlyPressedKeys() {
         return this._currentlyPressedKeys;
     }
-
-    public getPressedKeysCallbacks() {
+    getPressedKeysCallbacks() {
         return this._pressedKeysCallbacks;
     }
-
-    public getUnpressedKeysCallbacks() {
+    getUnpressedKeysCallbacks() {
         return this._unpressedKeysCallbacks;
     }
-
-    public getCharkeysCallbacks() {
+    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]) {
+    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") {
+            }
+            else if (event === "keyfree") {
                 this._removeCallback(this._unpressedKeysCallbacks[keyCode], callback);
-            } else if (event === "charkeypress") {
+            }
+            else if (event === "charkeypress") {
                 this._removeCallback(this._charkeysCallbacks[keyCode], callback);
             }
         }
     }
-
-    protected _removeCallback(handlers: ICallbackHandler[], callback: EventCallbackStamp) {
+    _removeCallback(handlers, callback) {
         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) {
+    _getStamp(name, keyCode, ogid) {
         return `${name}${STAMP_SPACER}${keyCode}${STAMP_SPACER}${ogid}`;
     }
-
-    protected _stamp(name: string, keyCode: number, obj: any) {
+    _stamp(name, keyCode, obj) {
         const ogid = stamp(obj);
         const st = this._getStamp(name, keyCode, ogid);
         if (!this._stampCache[st]) {
@@ -98,20 +70,16 @@ class KeyboardHandler {
         }
         return false;
     }
-
-    public setActivity(activity: boolean) {
+    setActivity(activity) {
         this._active = activity;
     }
-
-    public releaseKeys() {
+    releaseKeys() {
         this._currentlyPressedKeys = {};
     }
-
-    public addEvent(event: string, keyCode: number, callback: EventCallback, sender?: any, priority?: number) {
-
+    addEvent(event, keyCode, callback, sender, priority) {
         // Event is already bound with the callback
-        if (!this._stamp(event, keyCode, callback)) return;
-
+        if (!this._stamp(event, keyCode, callback))
+            return;
         if (priority === undefined) {
             priority = 1600;
         }
@@ -120,77 +88,70 @@ class KeyboardHandler {
                 if (!this._unpressedKeysCallbacks[keyCode]) {
                     this._unpressedKeysCallbacks[keyCode] = [];
                 }
-                this._unpressedKeysCallbacks[keyCode].push({callback: callback, sender: sender, priority: priority});
+                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 {
+                    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].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].push({ callback: callback, sender: sender, priority: priority });
                 this._charkeysCallbacks[keyCode].sort(_sortByPriority);
                 break;
         }
     }
-
-    public isKeyPressed(keyCode: number) {
+    isKeyPressed(keyCode) {
         return this._currentlyPressedKeys[keyCode];
     }
-
-    public handleKeyDown() {
+    handleKeyDown() {
         this._anykeyCallback && this._anykeyCallback.callback.call(this._anykeyCallback.sender, this._event);
-        this._currentlyPressedKeys[this._event!.keyCode] = true;
+        this._currentlyPressedKeys[this._event.keyCode] = true;
         for (let ch in this._charkeysCallbacks) {
-            if (String.fromCharCode(this._event!.keyCode) === String.fromCharCode(Number(ch))) {
+            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);
+                    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();
+        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) {
+    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) {
+                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);
+                        cpk[i].callback.call(cpk[i].sender, this._event);
                     }
                 }
             }
         }
-        this._currentlyPressedKeys[this._event!.keyCode] = false;
+        this._currentlyPressedKeys[this._event.keyCode] = false;
     }
-
-    public handleEvents() {
+    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);
+                    cpk[i].callback.call(cpk[i].sender, this._event);
                 }
             }
         }
     }
 }
-
-export {KeyboardHandler};
+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 };