@openglobus/og 0.13.5 → 0.13.8

package/src/og/utils/Loader.js

@@ -1,113 +1,161 @@
-'use strict';
-
-import { Events } from '../Events.js';
-
-if (window && !('createImageBitmap' in window)) {
-    window.createImageBitmap = function (blob) {
-        return new Promise((resolve, reject) => {
-            let img = document.createElement('img');
-            img.addEventListener('load', function () {
-                resolve(this);
-            });
-            img.src = URL.createObjectURL(blob);
-        });
-    };
-}
-
-export class Loader {
-
-    constructor(maxRequests = 24) {
-
-        this.MAX_REQUESTS = maxRequests;
-
-        this.events = new Events(["loadend"]);
-
-        this._loading = 0;
-
-        this._queue = [];//new QueueArray();
-
-        this._promises = {
-            'json': r => r.json(),
-            'blob': r => r.blob(),
-            'arrayBuffer': r => r.arrayBuffer(),
-            'imageBitmap': r => r.blob().then(createImageBitmap),
-            'text': r => r.text()
-        };
-    }
-
-    load(params, callback) {
-        this._queue.push({ 'params': params, 'callback': callback });
-        this._exec();
-    }
-
-    fetch(params) {
-        return fetch(
-            params.src,
-            params.options || {})
-
-            .then(response => {
-                if (!response.ok) {
-                    throw Error(`Unable to load '${params.src}'`);
-                }
-                return this._promises[params.type || "blob"](response);
-            })
-
-            .then(data => {
-                return { 'status': "ready", 'data': data };
-
-            })
-
-            .catch(err => {
-                return { 'status': "error", 'msg': err.toString() };
-            });
-    }
-
-    _exec() {
-
-        if (this._queue.length > 0 && this._loading < this.MAX_REQUESTS) {
-
-            let q = this._queue.pop(),
-                p = q.params;
-
-            if (!p.filter || p.filter(p)) {
-
-                this._loading++;
-
-                return fetch(p.src, p.options || {})
-                    .then(response => {
-                        if (!response.ok) {
-                            throw Error(`Unable to load '${p.src}'`);
-                        }
-                        return this._promises[p.type || "blob"](response);
-                    })
-                    .then(data => {
-                        this._loading--;
-                        q.callback({ 'status': "ready", 'data': data });
-                        this._exec();
-                    })
-                    .catch(err => {
-                        this._loading--;
-                        q.callback({ 'status': "error", 'msg': err.toString() });
-                        this._exec();
-                    });
-
-            } else {
-                q.callback({ 'status': "abort" });
-                this._exec();
-            }
-        } else if (this._loading === 0) {
-            this.events.dispatch(this.events.loadend);
-        }
-    }
-
-    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" });
-            this._queue[i] = null;
-        }
-        this._queue = [];
-    }
+'use strict';
+
+import { Events } from '../Events.js';
+
+if (window && !('createImageBitmap' in window)) {
+    window.createImageBitmap = function (blob) {
+        return new Promise((resolve, reject) => {
+            let img = document.createElement('img');
+            img.addEventListener('load', function () {
+                resolve(this);
+            });
+            img.src = URL.createObjectURL(blob);
+        });
+    };
+}
+
+export class Loader {
+
+    constructor(maxRequests = 24) {
+
+        this.MAX_REQUESTS = maxRequests;
+
+        this.events = new Events(["loadend", "layerloadend"]);
+
+        this._loading = 0;
+
+        this._queue = [];//new QueueArray();
+
+        this._senderRequestCounter = [];
+
+        this._promises = {
+            'json': r => r.json(),
+            'blob': r => r.blob(),
+            'arrayBuffer': r => r.arrayBuffer(),
+            'imageBitmap': r => r.blob().then(createImageBitmap),
+            'text': r => r.text()
+        };
+    }
+
+    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();
+    }
+
+    fetch(params) {
+        return fetch(
+            params.src,
+            params.options || {}
+        )
+            .then(response => {
+                if (!response.ok) {
+                    throw Error(`Unable to load '${params.src}'`);
+                }
+                return this._promises[params.type || "blob"](response);
+            })
+
+            .then(data => {
+                return { 'status': "ready", 'data': data };
+
+            })
+
+            .catch(err => {
+                return { 'status': "error", 'msg': err.toString() };
+            });
+    }
+
+    isIdle(sender) {
+        let request = this._senderRequestCounter[sender._id];
+        return request && request.counter === 0 && (!sender._planet || sender._planet._terrainCompletedActivated);
+
+    }
+
+    _checkLoadend(request, sender) {
+        if (request.counter === 0 && (sender._planet._terrainCompletedActivated || !sender._planet)) {
+            sender.events.dispatch(sender.events.loadend, sender);
+            this.events.dispatch(this.events.layerloadend, sender);
+            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 || this.events.layerloadend.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) {
+
+            let q = this._queue.pop(),
+                p = q.params;
+
+            if (!p.filter || p.filter(p)) {
+
+                this._loading++;
+
+                return fetch(p.src, p.options || {})
+                    .then(response => {
+                        if (!response.ok) {
+                            throw Error(`Unable to load '${p.src}'`);
+                        }
+                        return this._promises[p.type || "blob"](response);
+                    })
+                    .then(data => {
+                        this._loading--;
+                        this._handleResponse(q, { status: "ready", data: data });
+                    })
+                    .catch(err => {
+                        this._loading--;
+                        this._handleResponse(q, { status: "error", msg: err.toString() });
+                    });
+
+            } else {
+                this._handleResponse(q, { status: "abort" });
+            }
+        } else if (this._loading === 0) {
+            this.events.dispatch(this.events.loadend);
+        }
+    }
+
+    abort() {
+        for (let i = 0, len = this._queue.length; i < len; i++) {
+            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/PlainSegmentWorker.js

@@ -49,30 +49,42 @@ class PlainSegmentWorker {
     }
 
     setGeoid(geoid) {
-        let m = geoid.model;
-
-        let model = {
-            scale: m.scale,
-            offset: m.offset,
-            width: m.width,
-            height: m.height,
-            rlonres: m.rlonres,
-            rlatres: m.rlatres,
-            i: m.i
-        };
-
-        this._workerQueue.forEach((w) => {
-            let rawfile = new Uint8Array(m.rawfile.length);
-            rawfile.set(m.rawfile);
-
-            w.postMessage(
-                {
-                    model: model,
-                    rawfile: rawfile
-                },
-                [rawfile.buffer]
-            );
-        });
+
+        let model = null;
+
+        if (geoid.model) {
+            let m = geoid.model;
+            model = {
+                scale: m.scale,
+                offset: m.offset,
+                width: m.width,
+                height: m.height,
+                rlonres: m.rlonres,
+                rlatres: m.rlatres,
+                i: m.i
+            };
+
+            this._workerQueue.forEach((w) => {
+                let rawfile = new Uint8Array(m.rawfile.length);
+                rawfile.set(m.rawfile);
+
+                w.postMessage(
+                    {
+                        model: model,
+                        rawfile: rawfile
+                    },
+                    [rawfile.buffer]
+                );
+            });
+        } else {
+            this._workerQueue.forEach((w) => {
+                w.postMessage(
+                    {
+                        model: null
+                    }
+                );
+            });
+        }
     }
 
     make(segment) {
@@ -116,6 +128,8 @@ class PlainSegmentWorker {
 
 const _programm = `
     'use strict';
+    
+    let model = null;
 
     let cached_ix = null;
     let cached_iy = null;
@@ -185,8 +199,6 @@ const _programm = `
         return model.offset + model.scale * h;
     };
 
-    let model = null;
-
     const HALF_PI = Math.PI * 0.5;
     const POLE = 20037508.34;
     const PI_BY_POLE = Math.PI / POLE;

package/src/og/utils/VectorTileCreator.js

@@ -237,7 +237,7 @@ export class VectorTileCreator {
                         height = _h;
                     }
 
-                    texture = (material._updateTexture && material._updateTexture) || h.createEmptyTexture_l(width, height);
+                    texture = material._updateTexture || h.createEmptyTexture_l(width, height);
 
                     f.setSize(width, height);
 

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