@openglobus/og 0.13.4 → 0.13.7

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