@openglobus/og 0.13.6 → 0.13.7

package/src/og/terrain/GlobusTerrain.js

@@ -185,7 +185,7 @@ class GlobusTerrain extends EmptyTerrain {
 
         if (cache) {
             if (!cache.heights) {
-                callback(this._geoid.getHeightLonLat(lonLat));
+                callback(0);
             } else {
                 callback(this._getGroundHeightMerc(merc, cache));
             }
@@ -220,7 +220,7 @@ class GlobusTerrain extends EmptyTerrain {
                         extent: extent
                     };
                     this._elevationCache[tileIndex] = cache;
-                    callback(this._geoid.getHeightLonLat(lonLat));
+                    callback(0);
                 } else {
                     this._fetchCache[tileIndex] = null;
                     delete this._fetchCache[tileIndex];
@@ -279,10 +279,10 @@ class GlobusTerrain extends EmptyTerrain {
             h3 = tileData.heights[v3Ind];
 
         let v0 = new Vec3(
-                tileData.extent.southWest.lon + size * j,
-                h0,
-                tileData.extent.northEast.lat - size * i - size
-            ),
+            tileData.extent.southWest.lon + size * j,
+            h0,
+            tileData.extent.northEast.lat - size * i - size
+        ),
             v1 = new Vec3(v0.x + size, h1, v0.z),
             v2 = new Vec3(v0.x, h2, v0.z + size),
             v3 = new Vec3(v0.x + size, h3, v0.z + size);

package/src/og/utils/Loader.js

@@ -26,6 +26,8 @@ export class Loader {
 
         this._queue = [];//new QueueArray();
 
+        this._senderRequestCounter = [];
+
         this._promises = {
             'json': r => r.json(),
             'blob': r => r.blob(),
@@ -36,6 +38,16 @@ export class Loader {
     }
 
     load(params, callback) {
+        if (params.sender) {
+            if (!this._senderRequestCounter[params.sender._id]) {
+                this._senderRequestCounter[params.sender._id] = {
+                    sender: params.sender,
+                    counter: 0,
+                    __requestCounterFrame__: null
+                };
+            }
+            this._senderRequestCounter[params.sender._id].counter++;
+        }
         this._queue.push({ 'params': params, 'callback': callback });
         this._exec();
     }
@@ -43,8 +55,8 @@ export class Loader {
     fetch(params) {
         return fetch(
             params.src,
-            params.options || {})
-
+            params.options || {}
+        )
             .then(response => {
                 if (!response.ok) {
                     throw Error(`Unable to load '${params.src}'`);
@@ -62,6 +74,33 @@ export class Loader {
             });
     }
 
+    _checkLoadend(request, sender) {
+        if (request.counter === 0 && sender._planet._terrainCompletedActivated) {
+            sender.events.dispatch(sender.events.loadend);
+            request.__requestCounterFrame__ = null;
+        } else {
+            request.__requestCounterFrame__ = requestAnimationFrame(() => {
+                this._checkLoadend(request, sender);
+            });
+        }
+    }
+
+    _handleResponse(q, response) {
+        q.callback(response);
+        let sender = q.params.sender;
+        if (sender && sender.events.loadend.handlers.length) {
+            let request = this._senderRequestCounter[sender._id];
+            if (request && request.counter > 0) {
+                request.counter--;
+                cancelAnimationFrame(request.__requestCounterFrame__);
+                request.__requestCounterFrame__ = requestAnimationFrame(() => {
+                    this._checkLoadend(request, sender);
+                });
+            }
+        }
+        this._exec();
+    }
+
     _exec() {
 
         if (this._queue.length > 0 && this._loading < this.MAX_REQUESTS) {
@@ -82,18 +121,15 @@ export class Loader {
                     })
                     .then(data => {
                         this._loading--;
-                        q.callback({ 'status': "ready", 'data': data });
-                        this._exec();
+                        this._handleResponse(q, { status: "ready", data: data });
                     })
                     .catch(err => {
                         this._loading--;
-                        q.callback({ 'status': "error", 'msg': err.toString() });
-                        this._exec();
+                        this._handleResponse(q, { status: "error", msg: err.toString() });
                     });
 
             } else {
-                q.callback({ 'status': "abort" });
-                this._exec();
+                this._handleResponse(q, { status: "abort" });
             }
         } else if (this._loading === 0) {
             this.events.dispatch(this.events.loadend);
@@ -101,13 +137,18 @@ export class Loader {
     }
 
     abort() {
-        //this._queue.each(e => e.callback({ 'status': "abort" }));
-        //this._queue.clear();
-
         for (let i = 0, len = this._queue.length; i < len; i++) {
-            this._queue[i].callback({ 'status': "abort" });
+            let qi = this._queue[i];
+            let sender = qi.params.sender;
+            if (sender && this._senderRequestCounter[sender._id]) {
+                this._senderRequestCounter[sender._id].counter = 0;
+                cancelAnimationFrame(this._senderRequestCounter[sender._id].__requestCounterFrame__);
+                this._senderRequestCounter[sender._id].__requestCounterFrame__ = null;
+            }
+            qi.callback({ 'status': "abort" });
             this._queue[i] = null;
         }
         this._queue = [];
+        this._loading === 0;
     }
 }

package/src/og/utils/units.js

@@ -0,0 +1,78 @@
+'use strict';
+
+export const ELL = 0;
+export const MSL = 1;
+export const GND = 2;
+
+export const heightMode = {
+    "ell": ELL,
+    "msl": MSL,
+    "gnd": GND
+};
+
+const KM_to_M = 1000.0;
+const M_to_KM = 1.0 / KM_to_M;
+const FT_to_M = 0.3048;
+const M_to_FT = 1.0 / FT_to_M;
+const MS_to_KMH = 3.6;
+const KMH_to_MS = 1.0 / MS_to_KMH;
+const MS_to_FTS = 3.28084;
+const FT_to_KM = FT_to_M * M_to_KM;
+const KM_to_FT = 1.0 / FT_to_KM;
+
+export const m = 0;
+export const km = 1;
+export const ft = 2;
+export const s = 3;
+export const h = 4;
+export const ms = 5;
+export const kmh = 6;
+export const fts = 7;
+
+const DEFAULT_NAN = "--";
+
+const _abbr = ["m", "km", "ft", "s", "h", "m/s", "km/h", "ft/s"];
+
+export const _tenth = [0, 2, 0, 0, 0, 0, 0, 0];
+
+let _convFn = [];
+
+_convFn[m] = [];
+_convFn[m][m] = (v) => v;
+_convFn[m][km] = (v) => v * M_to_KM;
+_convFn[m][ft] = (v) => v * M_to_FT;
+
+_convFn[ft] = [];
+_convFn[ft][m] = (v) => v * FT_to_M;
+_convFn[ft][km] = (v) => v * FT_to_KM;
+_convFn[ft][ft] = (v) => v;
+
+_convFn[km] = [];
+_convFn[km][m] = (v) => v * KM_to_M;
+_convFn[km][km] = (v) => v;
+_convFn[km][ft] = (v) => v * KM_to_FT;
+
+_convFn[ms] = [];
+_convFn[ms][ms] = (v) => v;
+_convFn[ms][kmh] = (v) => v * MS_to_KMH;
+_convFn[ms][fts] = (v) => v * MS_to_FTS;
+
+_convFn[kmh] = [];
+_convFn[kmh][ms] = (v) => v * KMH_to_MS;
+_convFn[kmh][kmh] = (v) => v;
+//_convFn[kmh][fts] = (v) => v * KMH_to_FTS;
+
+export function convert(from, to, val) {
+    return _convFn[from][to](val);
+}
+
+export function convertExt(isNotNaN, unitFrom, unitTo, val, fixed) {
+    if (isNotNaN) {
+        return convert(unitFrom, unitTo, val).toFixed(fixed || _tenth[unitTo]);
+    }
+    return DEFAULT_NAN;
+}
+
+export function toString(u) {
+    return _abbr[u];
+}

package/types/control/EarthCoordinates.d.ts

@@ -1,47 +1,44 @@
-export function earthCoordinates(options: any): EarthCoordinates;
 /**
  * Control displays mouse or screen center Earth coordinates.
  * @class
- * @extends {Control}
+ * @extends {og.control.Control}
  * @param {Object} [options] - Options:
  * @param {Boolean} [options.center] - Earth coordiantes by screen center otherwise mouse pointer. False is default.
  * @param {Boolean} [options.type] - Coordinates shown: 0 - is decimal degrees, 1 - degrees, 2 - mercator geodetic coordinates.
  */
-export class EarthCoordinates extends Control {
+export class EarthCoordinates {
+    constructor(options: any);
     /**
      * Display type.
      * @private
      * @type {Boolean}
      */
-    private _displayType;
-    /**
-     * Current coordinates type converter.
-     * @private
-     * @function
-     */
-    private _converter;
-    /**
-     * Display dom element.
-     * @private
-     * @type {Object}
-     */
-    private _display;
-    _center: any;
-    _centerDiv: HTMLDivElement;
+    private _type;
+    _TYPE_FUNC: ((ll: any) => void)[];
+    _showFn: any;
     /**
      * Current position.
      * @public
-     * @type {Vec3}
-     */
-    public position: Vec3;
-    /**
-     * Sets coordinates capturing type.
-     * @public
-     * @param {Boolean} center - True - capture screen center, false - mouse pointer.
+     * @type {og.Vec3}
      */
-    public setCenter(center: boolean): void;
-    _showPosition(): void;
-    _grabCoordinates(): void;
-    _onMouseMove(): void;
+    public _lonLat: og.Vec3;
+    _latSideEl: Element;
+    _lonSideEl: Element;
+    _latValEl: Element;
+    _lonValEl: Element;
+    _heightEl: Element;
+    _altUnitVal: any;
+    _heightModeVal: any;
+    _altUnit: any;
+    _heightMode: any;
+    _centerMode: any;
+    _SHOW_DECIMAL(ll: any): void;
+    _SHOW_DEGREE(ll: any): void;
+    _createCenterEl(): HTMLDivElement;
+    _updateUnits(): void;
+    _refreshCoordinates(): void;
+    oninit(): void;
+    _el: HTMLDivElement;
+    _grabCoordinates(px: any): void;
+    _showHeight(): Promise<void>;
 }
-import { Control } from "./Control.js";

package/types/scene/Planet.d.ts

@@ -259,6 +259,9 @@ export class Planet extends RenderNode {
     _initialized: boolean;
     always: any[];
     _renderCompleted: boolean;
+    _renderCompletedActivated: boolean;
+    _terrainCompleted: boolean;
+    _terrainCompletedActivated: boolean;
     /**
      * Add the given control to the renderer of the planet scene.
      * @param {control.Control} control - Control.
@@ -266,7 +269,6 @@ export class Planet extends RenderNode {
     addControl(control: control.Control): void;
     get lodSize(): number;
     setLodSize(currentLodSize: any, minLodSize: any, maxLodSize: any): void;
-    _renderCompletedActivated: boolean;
     /**
      * Add the given controls array to the renderer of the planet.
      * @param {Array.<control.Control>} cArr - Control array.
@@ -566,6 +568,8 @@ export class Planet extends RenderNode {
      */
     public stopFlying(): void;
     getEntityTerrainPoint(entity: any, res: any): any;
+    getHeightDefault(lonLat: any): Promise<any>;
+    getHeightAboveELL(lonLat: any): Promise<any>;
 }
 import { RenderNode } from "./RenderNode.js";
 import { PlanetCamera } from "../camera/PlanetCamera.js";

package/types/terrain/EmptyTerrain.d.ts

@@ -72,4 +72,5 @@ export class EmptyTerrain {
      * @abstract
      */
     public clearCache(): void;
+    getHeightAsync(lonLat: any, callback: any): boolean;
 }

package/types/terrain/GlobusTerrain.d.ts

@@ -48,7 +48,6 @@ export class GlobusTerrain extends EmptyTerrain {
      * @returns {string} - Url query string.
      */
     private _urlRewriteCallback;
-    getHeightAsync(lonLat: any, callback: any, zoom: any): boolean;
     getTileCache(lonLat: any, z: any): any;
     _getGroundHeightMerc(merc: any, tileData: any): number;
     /**

package/types/utils/Loader.d.ts

@@ -4,6 +4,7 @@ export class Loader {
     events: Events;
     _loading: number;
     _queue: any[];
+    _senderRequestCounter: any[];
     _promises: {
         json: (r: any) => any;
         blob: (r: any) => any;
@@ -19,6 +20,8 @@ export class Loader {
         status: string;
         msg: any;
     }>;
+    _checkLoadend(request: any, sender: any): void;
+    _handleResponse(q: any, response: any): void;
     _exec(): Promise<void>;
     abort(): void;
 }

package/types/utils/units.d.ts

@@ -0,0 +1,20 @@
+export function convert(from: any, to: any, val: any): any;
+export function convertExt(isNotNaN: any, unitFrom: any, unitTo: any, val: any, fixed: any): any;
+export function toString(u: any): string;
+export const ELL: 0;
+export const MSL: 1;
+export const GND: 2;
+export namespace heightMode {
+    export { ELL as ell };
+    export { MSL as msl };
+    export { GND as gnd };
+}
+export const m: 0;
+export const km: 1;
+export const ft: 2;
+export const s: 3;
+export const h: 4;
+export const ms: 5;
+export const kmh: 6;
+export const fts: 7;
+export const _tenth: number[];