@openglobus/og 0.13.8 → 0.13.10

package/src/og/terrain/GlobusTerrain.js

@@ -10,8 +10,7 @@ import { Events } from "../Events.js";
 import { Loader } from "../utils/Loader.js";
 import { NOTRENDERING } from "../quadTree/quadTree.js";
 // import { QueueArray } from '../QueueArray.js';
-import { stringTemplate, createExtent } from "../utils/shared.js";
-import { Geoid } from "./Geoid.js";
+import { createExtent, stringTemplate } from "../utils/shared.js";
 import { Layer } from "../layer/Layer.js";
 import { Vec3 } from "../math/Vec3.js";
 import { Ray } from "../math/Ray.js";
@@ -56,7 +55,7 @@ class GlobusTerrain extends EmptyTerrain {
      */
     constructor(name, options = {}) {
         super({ geoidSrc: "//openglobus.org/geoid/egm84-30.pgm", ...options });
-
+        this._s = options.subdomains || ["a", "b", "c"];
         /**
          * Events handler.
          * @public
@@ -64,6 +63,10 @@ class GlobusTerrain extends EmptyTerrain {
          */
         this.events = new Events(EVENT_NAMES, this);
 
+        this._requestCount = 0;
+
+        this._requestsPeerSubdomian = 4;
+
         this.isEmpty = false;
 
         this.equalizeNormals = true;
@@ -73,7 +76,7 @@ class GlobusTerrain extends EmptyTerrain {
          * @public
          * @type {string}
          */
-        this.name = name || "";
+        this.name = name || "openglobus";
 
         /**
          * Minimal visible zoom index when terrain handler works.
@@ -94,7 +97,7 @@ class GlobusTerrain extends EmptyTerrain {
          * @public
          * @type {string}
          */
-        this.url = options.url || "//srtm3.openglobus.org/{z}/{y}/{x}.ddm";
+        this.url = options.url || "//{s}.srtm3.openglobus.org/{z}/{y}/{x}.ddm";
 
         /**
          * Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
@@ -192,11 +195,7 @@ class GlobusTerrain extends EmptyTerrain {
             return true;
         } else {
             if (!this._fetchCache[tileIndex]) {
-                let url = stringTemplate(this.url, {
-                    x: x,
-                    y: y,
-                    z: z
-                });
+                let url = this._buildURL(x, y, z);
                 this._fetchCache[tileIndex] = this._loader.fetch({
                     src: url,
                     type: this._dataType
@@ -279,10 +278,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);
@@ -308,7 +307,7 @@ class GlobusTerrain extends EmptyTerrain {
      * @public
      */
     abortLoading() {
-        this._loader.abort();
+        this._loader.abortAll();
     }
 
     /**
@@ -356,6 +355,7 @@ class GlobusTerrain extends EmptyTerrain {
                 } else {
                     this._loader.load(
                         {
+                            sender: this,
                             src: this._getHTTPRequestString(segment),
                             segment: segment,
                             type: this._dataType,
@@ -397,6 +397,17 @@ class GlobusTerrain extends EmptyTerrain {
         }
     }
 
+    _getSubdomain() {
+        this._requestCount++;
+        return  this._s[Math.floor(this._requestCount % (this._requestsPeerSubdomian * this._s.length) / this._requestsPeerSubdomian)];
+    }
+
+    _buildURL(x, y, z) {
+        return stringTemplate(this.url, {
+            s: this._getSubdomain(), x, y, z
+        });
+    }
+
     /**
      * Creates query url.
      * @protected
@@ -405,11 +416,11 @@ class GlobusTerrain extends EmptyTerrain {
      * @returns {string} -
      */
     _createUrl(segment) {
-        return stringTemplate(this.url, {
-            x: segment.tileX.toString(),
-            y: segment.tileY.toString(),
-            z: segment.tileZoom.toString()
-        });
+        return this._buildURL(
+            segment.tileX.toString(),
+            segment.tileY.toString(),
+            segment.tileZoom.toString()
+        )
     }
 
     /**

package/src/og/terrain/MapboxTerrain.js

@@ -8,7 +8,7 @@ const KEY =
 
 class MapboxTerrain extends GlobusTerrain {
     constructor(name, options = {}) {
-        super(name, options);
+        super(name || "mapbox", options);
 
         this.equalizeVertices =
             options.equalizeVertices != undefined ? options.equalizeVertices : true;

package/src/og/utils/BaseWorker.js

@@ -0,0 +1,46 @@
+export class BaseWorker {
+    constructor(numWorkers = 2, program) {
+        this._id = 0;
+        this._pendingQueue = [];
+        this._numWorkers = numWorkers;
+        this._workerQueue = [];
+        if (program) this.setProgram(program);
+    }
+
+    /**
+     * @virtual
+     */
+    make() {
+    }
+
+    check() {
+        if (this._pendingQueue && this._pendingQueue.length) {
+            this.make(this._pendingQueue.pop());
+        }
+    }
+
+    setProgram(program) {
+        let elevationProgramm = new Blob([program], { type: "application/javascript" });
+
+        for (let i = 0; i < this._numWorkers; i++) {
+            let w = new Worker(URL.createObjectURL(elevationProgramm));
+            w.onmessage = (e) => {
+                this._onMessage(e);
+                this._workerQueue && this._workerQueue.unshift(e.target);
+                this.check();
+            }
+            this._workerQueue.push(w);
+        }
+    }
+
+    destroy() {
+        for (let i = 0; i < this._workerQueue.length; i++) {
+            const w = this._workerQueue[i];
+            w.onmessage = undefined;
+            w.terminate();
+        }
+        this._pendingQueue = undefined;
+        this._numWorkers = undefined;
+        this._workerQueue = undefined;
+    }
+}

package/src/og/utils/GeoImageCreator.js

@@ -1,163 +1,166 @@
-'use strict';
-
-import { LonLat } from '../LonLat.js';
-import * as utils from '../utils/shared.js';
-import { Framebuffer } from '../webgl/Framebuffer.js';
-import { Program } from '../webgl/Program.js';
-import { types } from '../webgl/types.js';
-
-export class GeoImageCreator {
-
-    constructor(planet, maxFrames) {
-        this._gridSize = 64;
-        this._planet = planet;
-        this._framebuffer = null;
-        this._texCoordsBuffer = null;
-        this._indexBuffer = null;
-        this.MAX_FRAMES = maxFrames || 5;
-        this._currentFrame = 0;
-        this._queue = [];
-        this._animate = [];
-        this._initialize();
-    }
-
-    _initialize() {
-        this._initShaders();
-        this._initBuffers();
-    }
-
-    /**
-     * Creates geoImage corners coordinates grid buffer.
-     * @public
-     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
-     * @return{WebGLBuffer} Grid coordinates buffer.
-     */
-    createGridBuffer(c, toMerc) {
-        var gs = this._gridSize;
-
-        var v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
-            v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs),
-            v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs),
-            v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
-
-        var grid = new Float32Array((gs + 1) * (gs + 1) * 2);
-        var k = 0;
-        for (let i = 0; i <= gs; i++) {
-            var P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
-                P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
-            for (let j = 0; j <= gs; j++) {
-                var P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
-                    P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
-                var xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
-                grid[k++] = xx.lon;
-                grid[k++] = xx.lat;
-            }
-        }
-
-        if (toMerc) {
-            for (let i = 0; i < grid.length; i += 2) {
-                let c = new LonLat(grid[i], grid[i + 1]).forwardMercator();
-                grid[i] = c.lon;
-                grid[i + 1] = c.lat;
-            }
-        }
-        return this._planet.renderer.handler.createArrayBuffer(grid, 2, grid.length / 2);
-    }
-
-    frame() {
-        var i = this.MAX_FRAMES;
-        while (i-- && this._queue.length) {
-            var q = this._queue.shift();
-            q._isRendering = false;
-            q.rendering();
-        }
-
-        i = this._animate.length;
-        while (i--) {
-            this._animate[i].rendering();
-        }
-    }
-
-    add(geoImage) {
-        if (!geoImage._isRendering) {
-            geoImage._isRendering = true;
-            if (geoImage._animate) {
-                this._animate.push(geoImage);
-            } else {
-                this._queue.push(geoImage);
-            }
-        }
-    }
-
-    remove(geoImage) {
-        if (geoImage._isRendering) {
-            geoImage._creationProceeding = false;
-            geoImage._isRendering = false;
-            var arr;
-            if (geoImage._animate) {
-                arr = this._animate;
-            } else {
-                arr = this._queue;
-            }
-            for (var i = 0; i < arr.length; i++) {
-                if (arr[i].isEqual(geoImage)) {
-                    arr.splice(i, 1);
-                    return;
-                }
-            }
-        }
-    }
-
-    _initBuffers() {
-
-        let h = this._planet.renderer.handler;
-
-        this._framebuffer = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
-        this._framebuffer.init();
-
-        this._framebufferMercProj = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
-        this._framebufferMercProj.init();
-
-        let gs = Math.log2(this._gridSize);
-
-        this._texCoordsBuffer = this._planet._textureCoordsBufferCache[gs];
-
-        this._indexBuffer = this._planet._indexesCache[gs][gs][gs][gs][gs].buffer;
-
-        this._quadTexCoordsBuffer = h.createArrayBuffer(new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]), 2, 4);
-        this._quadVertexBuffer = h.createArrayBuffer(new Float32Array([-1, 1, 1, 1, -1, -1, 1, -1]), 2, 4);
-    }
-
-    _initShaders() {
-
-        this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
-            uniforms: {
-                sourceTexture: { type: types.SAMPLER2D },
-                extentParams: { type: types.VEC4 }
-            },
-            attributes: {
-                corners: "vec2",
-                texCoords: "vec2"
-            },
-            vertexShader: `attribute vec2 corners; 
-                      attribute vec2 texCoords; 
-                      varying vec2 v_texCoords; 
-                      uniform vec4 extentParams; 
-                      void main() { 
-                          v_texCoords = texCoords; 
-                          gl_Position = vec4((-1.0 + (corners - extentParams.xy) * extentParams.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
-                      }`,
-            fragmentShader:
-                `precision highp float;
-                        uniform sampler2D sourceTexture;
-                        varying vec2 v_texCoords;
+'use strict';
+
+import { LonLat } from '../LonLat.js';
+import * as utils from '../utils/shared.js';
+import { Framebuffer } from '../webgl/Framebuffer.js';
+import { Program } from '../webgl/Program.js';
+import { types } from '../webgl/types.js';
+
+export class GeoImageCreator {
+
+    constructor(planet, maxFrames) {
+        this._gridSize = 64;
+        this._planet = planet;
+        this._framebuffer = null;
+        this._texCoordsBuffer = null;
+        this._indexBuffer = null;
+        this.MAX_FRAMES = maxFrames || 5;
+        this._currentFrame = 0;
+        this._queue = [];
+        this._animate = [];
+        this._initialize();
+    }
+
+    _initialize() {
+        this._initShaders();
+        this._initBuffers();
+    }
+
+    /**
+     * Creates geoImage corners coordinates grid buffer.
+     * @public
+     * @param{Array.<LonLat>} c - GeoImage corners coordinates.
+     * @return{WebGLBuffer} Grid coordinates buffer.
+     */
+    createGridBuffer(c, toMerc) {
+        var gs = this._gridSize;
+
+        var v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
+            v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs),
+            v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs),
+            v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
+
+        var grid = new Float32Array((gs + 1) * (gs + 1) * 2);
+        var k = 0;
+        for (let i = 0; i <= gs; i++) {
+            var P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
+                P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
+            for (let j = 0; j <= gs; j++) {
+                var P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
+                    P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
+                var xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
+                grid[k++] = xx.lon;
+                grid[k++] = xx.lat;
+            }
+        }
+
+        if (toMerc) {
+            for (let i = 0; i < grid.length; i += 2) {
+                let c = new LonLat(grid[i], grid[i + 1]).forwardMercator();
+                grid[i] = c.lon;
+                grid[i + 1] = c.lat;
+            }
+        }
+        return this._planet.renderer.handler.createArrayBuffer(grid, 2, grid.length / 2);
+    }
+
+    frame() {
+        var i = this.MAX_FRAMES;
+        while (i-- && this._queue.length) {
+            var q = this._queue.shift();
+            q._isRendering = false;
+            q.rendering();
+            q.events.dispatch(q.events.loadend);
+        }
+
+        i = this._animate.length;
+        while (i--) {
+            this._animate[i].rendering();
+        }
+    }
+
+    add(geoImage) {
+        if (!geoImage._isRendering) {
+            geoImage._isRendering = true;
+            if (geoImage._animate) {
+                this._animate.push(geoImage);
+            } else {
+                this._queue.push(geoImage);
+            }
+        }
+    }
+
+    remove(geoImage) {
+        if (geoImage._isRendering) {
+            geoImage._creationProceeding = false;
+            geoImage._isRendering = false;
+            var arr;
+            if (geoImage._animate) {
+                arr = this._animate;
+            } else {
+                arr = this._queue;
+            }
+            for (var i = 0; i < arr.length; i++) {
+                if (arr[i].isEqual(geoImage)) {
+                    arr.splice(i, 1);
+                    return;
+                }
+            }
+        }
+    }
+
+    _initBuffers() {
+
+        let h = this._planet.renderer.handler;
+
+        this._framebuffer = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
+        this._framebuffer.init();
+
+        this._framebufferMercProj = new Framebuffer(h, { width: 2, height: 2, useDepth: false });
+        this._framebufferMercProj.init();
+
+        let gs = Math.log2(this._gridSize);
+
+        this._texCoordsBuffer = this._planet._textureCoordsBufferCache[gs];
+
+        this._indexBuffer = this._planet._indexesCache[gs][gs][gs][gs][gs].buffer;
+
+        this._quadTexCoordsBuffer = h.createArrayBuffer(new Float32Array([0, 1, 1, 1, 0, 0, 1, 0]), 2, 4);
+        this._quadVertexBuffer = h.createArrayBuffer(new Float32Array([-1, 1, 1, 1, -1, -1, 1, -1]), 2, 4);
+    }
+
+    _initShaders() {
+
+        this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
+            uniforms: {
+                sourceTexture: "sampler2d",
+                extentParams: "vec4",
+                isFullExtent: "bool"
+            },
+            attributes: {
+                corners: "vec2",
+                texCoords: "vec2"
+            },
+            vertexShader: `attribute vec2 corners; 
+                      attribute vec2 texCoords; 
+                      varying vec2 v_texCoords; 
+                      uniform vec4 extentParams; 
+                      void main() { 
+                          v_texCoords = texCoords; 
+                          gl_Position = vec4((-1.0 + (corners - extentParams.xy) * extentParams.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
+                      }`,
+            fragmentShader:
+                `precision highp float;
+                        uniform sampler2D sourceTexture;
+                        uniform bool isFullExtent;
+                        varying vec2 v_texCoords;
                         void main () {
-                            if(v_texCoords.x <= 0.001 || v_texCoords.x >= 0.999 ||
-                                v_texCoords.y <= 0.001 || v_texCoords.y >= 0.999) {
-                                discard;
-                            }
-                            gl_FragColor = texture2D(sourceTexture, v_texCoords);
-                        }`
-        }));
-    }
+                            if(!isFullExtent && (v_texCoords.x <= 0.001 || v_texCoords.x >= 0.999 ||
+                                v_texCoords.y <= 0.001 || v_texCoords.y >= 0.999)) {
+                                discard;
+                            }
+                            gl_FragColor = texture2D(sourceTexture, v_texCoords);
+                        }`
+        }));
+    }
 }

package/src/og/utils/Loader.js

@@ -2,17 +2,17 @@
 
 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);
-        });
-    };
-}
+// 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 {
 
@@ -32,7 +32,10 @@ export class Loader {
             'json': r => r.json(),
             'blob': r => r.blob(),
             'arrayBuffer': r => r.arrayBuffer(),
-            'imageBitmap': r => r.blob().then(createImageBitmap),
+            'imageBitmap': r => r.blob().then(
+                (r) => createImageBitmap(r, {
+                    premultiplyAlpha: "premultiply"
+                })),
             'text': r => r.text()
         };
     }
@@ -41,9 +44,7 @@ export class Loader {
         if (params.sender) {
             if (!this._senderRequestCounter[params.sender._id]) {
                 this._senderRequestCounter[params.sender._id] = {
-                    sender: params.sender,
-                    counter: 0,
-                    __requestCounterFrame__: null
+                    sender: params.sender, counter: 0, __requestCounterFrame__: null
                 };
             }
             this._senderRequestCounter[params.sender._id].counter++;
@@ -53,10 +54,7 @@ export class Loader {
     }
 
     fetch(params) {
-        return fetch(
-            params.src,
-            params.options || {}
-        )
+        return fetch(params.src, params.options || {})
             .then(response => {
                 if (!response.ok) {
                     throw Error(`Unable to load '${params.src}'`);
@@ -74,10 +72,18 @@ export class Loader {
             });
     }
 
-    isIdle(sender) {
-        let request = this._senderRequestCounter[sender._id];
-        return request && request.counter === 0 && (!sender._planet || sender._planet._terrainCompletedActivated);
+    getRequestCounter(sender) {
+        if (sender) {
+            let r = this._senderRequestCounter[sender._id];
+            if (r) {
+                return r.counter;
+            }
+        }
+        return 0;
+    }
 
+    isIdle(sender) {
+        return sender.isIdle;
     }
 
     _checkLoadend(request, sender) {
@@ -112,8 +118,11 @@ export class Loader {
 
         if (this._queue.length > 0 && this._loading < this.MAX_REQUESTS) {
 
-            let q = this._queue.pop(),
-                p = q.params;
+            let q = this._queue.pop();
+
+            if (!q) return;
+
+            let p = q.params;
 
             if (!p.filter || p.filter(p)) {
 
@@ -143,19 +152,37 @@ export class Loader {
         }
     }
 
-    abort() {
+    abort(sender) {
+
+        if (this._senderRequestCounter[sender._id]) {
+            this._senderRequestCounter[sender._id].counter = 0;
+            cancelAnimationFrame(this._senderRequestCounter[sender._id].__requestCounterFrame__);
+            this._senderRequestCounter[sender._id].__requestCounterFrame__ = null;
+        }
+
         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;
+            if (qi && sender.isEqual(qi.params.sender)) {
+                qi.callback({ 'status': "abort" });
+                this._queue[i] = null;
+            }
+        }
+    }
+
+    abortAll() {
+        for (let i = 0, len = this._queue.length; i < len; i++) {
+            let qi = this._queue[i];
+            if (qi) {
+                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;
             }
-            qi.callback({ 'status': "abort" });
-            this._queue[i] = null;
         }
         this._queue = [];
-        this._loading = 0;
     }
 }