@openglobus/og 0.13.8 → 0.13.12

package/src/og/math.js

@@ -135,12 +135,12 @@ export function isPowerOfTwo(x) {
  * @param {number} x - Input value.
  * @returns {number} -
  */
-export function nextHighestPowerOfTwo(x) {
+export function nextHighestPowerOfTwo(x, maxValue = 4096) {
     --x;
     for (var i = 1; i < 32; i <<= 1) {
         x = x | (x >> i);
     }
-    return x + 1;
+    return (x + 1) > maxValue ? maxValue : x + 1
 }
 
 /**

package/src/og/quadTree/Node.js

@@ -75,8 +75,7 @@ class Node {
         this.sideSizeLog2 = [0, 0, 0, 0];
         this.ready = false;
         this.neighbors = [[], [], [], []];
-        this.equalizedNeighborId = [-1, -1, -1, -1];
-        this.equalizedNeighborGridSize = [-1, -1, -1, -1];
+        this.equalizedSideWithNodeId = [this.nodeId, this.nodeId, this.nodeId, this.nodeId];
         this.nodes = [null, null, null, null];
         this.segment = new SegmentPrototype(this, planet, tileZoom, extent);
         this._cameraInside = false;
@@ -639,6 +638,9 @@ class Node {
             let tempVertices, tempVerticesHigh, tempVerticesLow, noDataVertices;
 
             this.appliedTerrainNodeId = pn.nodeId;
+            this.equalizedSideWithNodeId[N] = this.equalizedSideWithNodeId[E] =
+                this.equalizedSideWithNodeId[S] = this.equalizedSideWithNodeId[W] = this.appliedTerrainNodeId;
+
 
             let gridSize = pn.segment.gridSize / dZ2,
                 gridSizeExt = pn.segment.fileGridSize / dZ2;
@@ -819,6 +821,8 @@ class Node {
                     seg.terrainVerticesLow = tempVerticesLow;
 
                     this.appliedTerrainNodeId = this.nodeId;
+                    this.equalizedSideWithNodeId[N] = this.equalizedSideWithNodeId[E] =
+                        this.equalizedSideWithNodeId[S] = this.equalizedSideWithNodeId[W] = this.appliedTerrainNodeId;
 
                     if (pn.segment.terrainExists) {
                         seg.terrainExists = true;
@@ -883,9 +887,7 @@ class Node {
     clearTree() {
         var state = this.getState();
 
-        if (state === NOTRENDERING) {
-            this.destroyBranches();
-        } else if (state === RENDERING) {
+        if (state === NOTRENDERING || state === RENDERING) {
             this.destroyBranches();
         } else {
             for (var i = 0; i < this.nodes.length; i++) {

package/src/og/renderer/Renderer.js

@@ -477,7 +477,7 @@ class Renderer {
             };
         }
 
-        this.handler.onCanvasResize = () => {
+        this.handler.ONCANVASRESIZE = () => {
             this.resize();
             this.events.dispatch(this.events.resize, this.handler.canvas);
         };

package/src/og/scene/Planet.js

@@ -94,7 +94,13 @@ const EVENT_NAMES = [
      * Triggered when all data is loaded
      * @event og.scene.Planet#terraincompleted
      */
-    "terraincompleted"
+    "terraincompleted",
+
+    /**
+     * Triggered when layer data is laded
+     * @event og.scene.Planet#terraincompleted
+     */
+    "layerloadend"
 ];
 
 /**
@@ -145,11 +151,18 @@ export class Planet extends RenderNode {
         this._planetRadius2 = this.ellipsoid.getPolarSize() * this.ellipsoid.getPolarSize();
 
         /**
-         * All layers array.
-         * @public
+         * Layers array.
+         * @protected
          * @type {Array.<Layer>}
          */
-        this.layers = [];
+        this._layers = [];
+
+        /**
+         * Flag to trigger layer update in a next frame
+         * @type {boolean}
+         * @private
+         */
+        this._updateLayer = false;
 
         /**
          * Current visible imagery tile layers array.
@@ -188,6 +201,13 @@ export class Planet extends RenderNode {
          */
         this.terrain = null;
 
+        /**
+         * Terrain provider Pool.
+         * @public
+         * @type {Terrain}
+         */
+        this._terrainPool = null;
+
         /**
          * Camera is this.renderer.activeCamera pointer.
          * @public
@@ -446,6 +466,10 @@ export class Planet extends RenderNode {
         return Quat.getLookRotation(t, n);
     }
 
+    get layers() {
+        return [...this._layers];
+    }
+
     /**
      * Add the given control to the renderer of the planet scene.
      * @param {control.Control} control - Control.
@@ -484,10 +508,9 @@ export class Planet extends RenderNode {
      * @returns {Layer} -
      */
     getLayerByName(name) {
-        var i = this.layers.length;
-        while (i--) {
-            if (this.layers[i].name === name) {
-                return this.layers[i];
+        for (let i = 0, len = this._layers.length; i < len; i++) {
+            if (name === this._layers[i].name) {
+                return this._layers[i];
             }
         }
     }
@@ -516,7 +539,7 @@ export class Planet extends RenderNode {
      * @public
      */
     addLayers(layers) {
-        for (var i = 0; i < layers.length; i++) {
+        for (let i = 0, len = layers.length; i < len; i++) {
             this.addLayer(layers[i]);
         }
     }
@@ -543,10 +566,30 @@ export class Planet extends RenderNode {
             if (mats[lid]) {
                 mats[lid].clear();
                 mats[lid] = null;
+                delete mats[lid];
+            }
+        });
+
+        this._quadTreeNorth.traverseTree(function (node) {
+            var mats = node.segment.materials;
+            if (mats[lid]) {
+                mats[lid].clear();
+                mats[lid] = null;
+                delete mats[lid];
+            }
+        });
+
+        this._quadTreeSouth.traverseTree(function (node) {
+            var mats = node.segment.materials;
+            if (mats[lid]) {
+                mats[lid].clear();
+                mats[lid] = null;
+                delete mats[lid];
             }
         });
     }
 
+
     /**
      * Get the collection of layers associated with this planet.
      * @return {Array.<Layer>} Layers array.
@@ -689,11 +732,18 @@ export class Planet extends RenderNode {
         this.renderer.screenTexture.height = this._heightPickingFramebuffer.textures[0];
     }
 
+    _onLayerLoadend(layer) {
+        this.events.dispatch(this.events.layerloadend, layer);
+    }
+
     /**
      * @virtual
      * @public
      */
     init() {
+
+        this._tileLoader.events.on("layerloadend", this._onLayerLoadend, this);
+
         // Initialization indexes table
         segmentHelper.getInstance().setMaxGridSize(this._maxGridSize);
         const TABLESIZE = this._maxGridSize;
@@ -705,10 +755,10 @@ export class Planet extends RenderNode {
                 !this._indexesCache[i][j] && (this._indexesCache[i][j] = new Array(TABLESIZE));
                 for (var k = 0; k <= TABLESIZE; k++) {
                     !this._indexesCache[i][j][k] &&
-                        (this._indexesCache[i][j][k] = new Array(TABLESIZE));
+                    (this._indexesCache[i][j][k] = new Array(TABLESIZE));
                     for (var m = 0; m <= TABLESIZE; m++) {
                         !this._indexesCache[i][j][k][m] &&
-                            (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
+                        (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
                         for (var q = 0; q <= TABLESIZE; q++) {
                             let ptr = {
                                 buffer: null
@@ -795,7 +845,7 @@ export class Planet extends RenderNode {
         // Applying shaders
         this._initializeShaders();
 
-        this.updateVisibleLayers();
+        this._updateVisibleLayers();
 
         this.renderer.addPickingCallback(this, this._frustumEntityCollectionPickingCallback);
 
@@ -936,9 +986,9 @@ export class Planet extends RenderNode {
      * @public
      */
     updateAttributionsList() {
-        var html = "";
-        for (var i = 0; i < this.layers.length; i++) {
-            var li = this.layers[i];
+        let html = "";
+        for (let i = 0, len = this._layers.length; i < len; i++) {
+            let li = this._layers[i];
             if (li._visibility) {
                 if (li._attribution.length) {
                     html += "<li>" + li._attribution + "</li>";
@@ -949,20 +999,24 @@ export class Planet extends RenderNode {
         this._applyAttribution(html)
     }
 
+    updateVisibleLayers() {
+        this._updateLayer = true;
+    }
+
     /**
      * Updates visible layers.
      * @public
      */
-    updateVisibleLayers() {
+    _updateVisibleLayers() {
         this.visibleTileLayers = [];
         this.visibleTileLayers.length = 0;
 
         this.visibleVectorLayers = [];
         this.visibleVectorLayers.length = 0;
 
-        var html = "";
-        for (var i = 0; i < this.layers.length; i++) {
-            var li = this.layers[i];
+        let html = "";
+        for (let i = 0, len = this._layers.length; i < len; i++) {
+            let li = this._layers[i];
             if (li._visibility) {
                 if (li._isBaseLayer) {
                     this.createDefaultTextures(li._defaultTextures[0], li._defaultTextures[1]);
@@ -1021,21 +1075,21 @@ export class Planet extends RenderNode {
      * @protected
      */
     _sortLayers() {
-        this.visibleVectorLayers.sort(function (a, b) {
-            return a._zIndex - b._zIndex || a._height - b._height;
-        });
+        this.visibleVectorLayers.sort(
+            (a, b) => (a._zIndex - b._zIndex) || (a._height - b._height)
+        );
 
         this._visibleTileLayerSlices = [];
         this._visibleTileLayerSlices.length = 0;
 
         if (this.visibleTileLayers.length) {
-            this.visibleTileLayers.sort(function (a, b) {
-                return a._height - b._height || a._zIndex - b._zIndex;
-            });
+            this.visibleTileLayers.sort((a, b) =>
+                (a._height - b._height) || (a._zIndex - b._zIndex)
+            );
 
             var k = -1;
             var currHeight = this.visibleTileLayers[0]._height;
-            for (var i = 0; i < this.visibleTileLayers.length; i++) {
+            for (let i = 0, len = this.visibleTileLayers.length; i < len; i++) {
                 if (i % this.SLICE_SIZE === 0 || this.visibleTileLayers[i]._height !== currHeight) {
                     k++;
                     this._visibleTileLayerSlices[k] = [];
@@ -1154,6 +1208,12 @@ export class Planet extends RenderNode {
      * @public
      */
     frame() {
+
+        if (this._updateLayer) {
+            this._updateLayer = false;
+            this._updateVisibleLayers();
+        }
+
         this._renderScreenNodesPASS();
 
         this._renderHeightPickingFramebufferPASS();
@@ -1188,16 +1248,16 @@ export class Planet extends RenderNode {
      * @protected
      */
     _renderScreenNodesPASS() {
+
         let sh, shu;
         let renderer = this.renderer;
         let h = renderer.handler;
         let gl = h.gl;
         let cam = renderer.activeCamera;
-        let frustumIndex = cam.getCurrentFrustum();
-
-        gl.disable(gl.POLYGON_OFFSET_FILL);
+        let frustumIndex = cam.getCurrentFrustum(),
+            firstPass = frustumIndex === cam.FARTHEST_FRUSTUM_INDEX;
 
-        if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
+        if (firstPass) {
             if (this._skipPreRender/* && (!this._renderCompletedActivated || cam.isMoved)*/) {
                 this._collectRenderNodes();
             }
@@ -1274,7 +1334,7 @@ export class Planet extends RenderNode {
             let sli = sl[0];
             for (var i = sli.length - 1; i >= 0; --i) {
                 let li = sli[i];
-                if (li._fading && li._refreshFadingOpacity()) {
+                if (li._fading && firstPass && li._refreshFadingOpacity()) {
                     sli.splice(i, 1);
                 }
             }
@@ -1289,22 +1349,23 @@ export class Planet extends RenderNode {
             s.screenRendering(sh, sl[0], 0);
         }
 
-        //gl.enable(gl.POLYGON_OFFSET_FILL);
+        gl.enable(gl.POLYGON_OFFSET_FILL);
         for (let j = 1, len = sl.length; j < len; j++) {
             let slj = sl[j];
             for (i = slj.length - 1; i >= 0; --i) {
                 let li = slj[i];
-                if (li._fading && li._refreshFadingOpacity()) {
+                if (li._fading && firstPass && li._refreshFadingOpacity()) {
                     slj.splice(i, 1);
                 }
             }
 
+            gl.polygonOffset(0, -j);
             i = rn.length;
-            //gl.polygonOffset(0, -j);
             while (i--) {
                 rn[i].segment.screenRendering(sh, sl[j], j, this.transparentTexture, true);
             }
         }
+        gl.disable(gl.POLYGON_OFFSET_FILL);
 
         gl.disable(gl.BLEND);
     }
@@ -1342,7 +1403,7 @@ export class Planet extends RenderNode {
             gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
 
             // drawing planet nodes
-            var rn = this._renderedNodesInFrustum[frustumIndex],
+            let rn = this._renderedNodesInFrustum[frustumIndex],
                 sl = this._visibleTileLayerSlices;
 
             let i = rn.length;
@@ -1387,15 +1448,15 @@ export class Planet extends RenderNode {
             rn[i].segment.colorPickingRendering(sh, sl[0], 0);
         }
 
-        //gl.enable(gl.POLYGON_OFFSET_FILL);
+        gl.enable(gl.POLYGON_OFFSET_FILL);
         for (let j = 1, len = sl.length; j < len; j++) {
             i = rn.length;
-            //gl.polygonOffset(0, -j);
+            gl.polygonOffset(0, -j);
             while (i--) {
                 rn[i].segment.colorPickingRendering(sh, sl[j], j, this.transparentTexture, true);
             }
         }
-        //gl.disable(gl.POLYGON_OFFSET_FILL);
+        gl.disable(gl.POLYGON_OFFSET_FILL);
 
         gl.disable(gl.BLEND);
     }
@@ -1438,7 +1499,7 @@ export class Planet extends RenderNode {
         this._frustumEntityCollections.length = 0;
         this._frustumEntityCollections = [];
 
-        var i = this.visibleVectorLayers.length;
+        let i = this.visibleVectorLayers.length;
         while (i--) {
             let vi = this.visibleVectorLayers[i];
 
@@ -1474,7 +1535,7 @@ export class Planet extends RenderNode {
 
         this._normalMapCreator.clear();
         this.terrain.abortLoading();
-        this._tileLoader.abort();
+        this._tileLoader.abortAll();
 
         var that = this;
         // setTimeout(function () {
@@ -1811,8 +1872,8 @@ export class Planet extends RenderNode {
         }
 
         let readyCollections = {};
-        for (let i = 0; i < this.layers.length; i++) {
-            let li = this.layers[i];
+        for (let i = 0; i < this._layers.length; i++) {
+            let li = this._layers[i];
             if (li instanceof Vector) {
                 li.each(function (e) {
                     if (e._entityCollection && !readyCollections[e._entityCollection.id]) {

package/src/og/segment/Segment.js

@@ -386,8 +386,9 @@ class Segment {
      * @param {Float32Array} elevations - Elevation data.
      */
     elevationsExists(elevations) {
+        const segment = this;
         if (this.plainReady && this.terrainIsLoading) {
-            this.planet._terrainWorker.make(this, elevations);
+            this.planet._terrainWorker.make(segment, elevations);
 
             this.plainVerticesHigh = null;
             this.plainVerticesLow = null;
@@ -403,19 +404,8 @@ class Segment {
     }
 
     _checkEqualization(neighborSide, neigborNode) {
-        return (
-            neigborNode && this.tileZoom >= neigborNode.segment.tileZoom
-
-            //&&
-            //(
-            //    this.node.equalizedNeighborId[neighborSide] !== neigborNode.appliedTerrainNodeId ||
-            //    this.node.equalizedNeighborGridSize[neighborSide] !== neigborNode.segment.gridSize
-            //||
-
-            //    neigborNode.equalizedNeighborId[OPSIDE[neighborSide]] !== this.node.appliedTerrainNodeId ||
-            //    neigborNode.equalizedNeighborGridSize[OPSIDE[neighborSide]] !== this.gridSize
-            //)
-        );
+        return neigborNode && this.tileZoom >= neigborNode.segment.tileZoom &&
+            this.node.equalizedSideWithNodeId[neighborSide] !== neigborNode.equalizedSideWithNodeId[OPSIDE[neighborSide]];
     }
 
     equalize() {
@@ -433,11 +423,8 @@ class Segment {
 
         let n = nn[N][0];
         if (this._checkEqualization(N, n)) {
-            //this.node.equalizedNeighborId[N] = n.appliedTerrainNodeId;
-            //this.node.equalizedNeighborGridSize[N] = n.segment.gridSize;
 
-            //n.equalizedNeighborId[OPSIDE[N]] = this.node.appliedTerrainNodeId;
-            //n.equalizedNeighborGridSize[OPSIDE[N]] = this.gridSize;
+            this.node.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[S];
 
             this.readyToEngage = true;
 
@@ -476,11 +463,8 @@ class Segment {
 
         n = nn[E][0];
         if (this._checkEqualization(E, n)) {
-            //this.node.equalizedNeighborId[E] = n.appliedTerrainNodeId;
-            //this.node.equalizedNeighborGridSize[E] = n.segment.gridSize;
 
-            //n.equalizedNeighborId[OPSIDE[E]] = this.node.appliedTerrainNodeId;
-            //n.equalizedNeighborGridSize[OPSIDE[E]] = this.gridSize;
+            this.node.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[W];
 
             this.readyToEngage = true;
 
@@ -519,11 +503,8 @@ class Segment {
 
         n = nn[S][0];
         if (this._checkEqualization(S, n)) {
-            //this.node.equalizedNeighborId[S] = n.appliedTerrainNodeId;
-            //this.node.equalizedNeighborGridSize[S] = n.segment.gridSize;
 
-            //n.equalizedNeighborId[OPSIDE[S]] = this.node.appliedTerrainNodeId;
-            //n.equalizedNeighborGridSize[OPSIDE[S]] = this.gridSize;
+            this.node.equalizedSideWithNodeId[S] = n.equalizedSideWithNodeId[N];
 
             this.readyToEngage = true;
 
@@ -561,11 +542,8 @@ class Segment {
 
         n = nn[W][0];
         if (this._checkEqualization(W, n)) {
-            //this.node.equalizedNeighborId[W] = n.appliedTerrainNodeId;
-            //this.node.equalizedNeighborGridSize[W] = n.segment.gridSize;
 
-            //n.equalizedNeighborId[OPSIDE[W]] = this.node.appliedTerrainNodeId;
-            //n.equalizedNeighborGridSize[OPSIDE[W]] = this.gridSize;
+            this.node.equalizedSideWithNodeId[W] = n.equalizedSideWithNodeId[E];
 
             this.readyToEngage = true;
 
@@ -671,17 +649,12 @@ class Segment {
 
             this.setBoundingVolumeArr(data.bounds);
 
-            //var b = data.bounds;
-
-            //this.setBoundingSphere(
-            //    b[0] + (b[1] - b[0]) * 0.5,
-            //    b[2] + (b[3] - b[2]) * 0.5,
-            //    b[4] + (b[5] - b[4]) * 0.5,
-            //    new Vec3(b[0], b[2], b[4])
-            //);
-
             this.gridSize = Math.sqrt(this.terrainVertices.length / 3) - 1;
-            this.node.appliedTerrainNodeId = this.node.nodeId;
+
+            let n = this.node;
+            n.appliedTerrainNodeId = n.nodeId;
+            n.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[S] =
+                n.equalizedSideWithNodeId[W] = n.appliedTerrainNodeId;
 
             this.terrainReady = true;
             this.terrainIsLoading = false;
@@ -710,7 +683,10 @@ class Segment {
             if (this.plainReady && this.terrainIsLoading) {
                 this.terrainIsLoading = false;
 
-                this.node.appliedTerrainNodeId = this.node.nodeId;
+                let n = this.node;
+                n.appliedTerrainNodeId = this.node.nodeId;
+                n.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[S] =
+                    n.equalizedSideWithNodeId[W] = n.appliedTerrainNodeId;
 
                 if (this.planet.lightEnabled && !this._inTheQueue) {
                     this.planet._normalMapCreator.queue(this);
@@ -735,6 +711,7 @@ class Segment {
             this.terrainExists = false;
         }
     }
+
     _normalMapEdgeEqualize(side) {
         let nn = this.node.neighbors;
         let n = nn[side][0];
@@ -1080,10 +1057,10 @@ class Segment {
                     v_rb = new Vec3(bigOne[9], bigOne[10], bigOne[11]);
 
                 let vn = new Vec3(
-                    bigOne[3] - bigOne[0],
-                    bigOne[4] - bigOne[1],
-                    bigOne[5] - bigOne[2]
-                ),
+                        bigOne[3] - bigOne[0],
+                        bigOne[4] - bigOne[1],
+                        bigOne[5] - bigOne[2]
+                    ),
                     vw = new Vec3(
                         bigOne[6] - bigOne[0],
                         bigOne[7] - bigOne[1],
@@ -1256,16 +1233,16 @@ class Segment {
 
         n.sideSize[0] =
             n.sideSize[1] =
-            n.sideSize[2] =
-            n.sideSize[3] =
-            this.gridSize =
-            p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize;
+                n.sideSize[2] =
+                    n.sideSize[3] =
+                        this.gridSize =
+                            p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize;
 
         n.sideSizeLog2[0] =
             n.sideSizeLog2[1] =
-            n.sideSizeLog2[2] =
-            n.sideSizeLog2[3] =
-            Math.log2(p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize);
+                n.sideSizeLog2[2] =
+                    n.sideSizeLog2[3] =
+                        Math.log2(p.terrain.gridSizeByZoom[this.tileZoom] || p.terrain.plainGridSize);
 
         if (this.tileZoom <= p.terrain.maxZoom) {
             var nmc = this.planet._normalMapCreator;
@@ -1435,7 +1412,7 @@ class Segment {
             p = this.planet;
 
         var currHeight, li;
-        if (layerSlice) {
+        if (layerSlice && layerSlice.length) {
             li = layerSlice[0];
             currHeight = li._height;
         } else {
@@ -1541,7 +1518,7 @@ class Segment {
             p = this.planet;
 
         var currHeight;
-        if (layerSlice) {
+        if (layerSlice && layerSlice.length) {
             currHeight = layerSlice[0]._height;
         } else {
             currHeight = 0;
@@ -1568,7 +1545,7 @@ class Segment {
             p = this.planet;
 
         var currHeight;
-        if (layerSlice) {
+        if (layerSlice && layerSlice.length) {
             currHeight = layerSlice[0]._height;
         } else {
             currHeight = 0;
@@ -1632,7 +1609,7 @@ class Segment {
             shu = sh.uniforms;
 
         var currHeight;
-        if (layerSlice) {
+        if (layerSlice.length) {
             currHeight = layerSlice[0]._height;
         } else {
             currHeight = 0;
@@ -1709,4 +1686,5 @@ class Segment {
         return -1;
     }
 }
+
 export { Segment };

package/src/og/segment/Slice.js

@@ -23,7 +23,7 @@ class Slice {
 
         this.layers.push(layer);
 
-        this.layerOpacityArr[n] = layer.opacity;
+        this.layerOpacityArr[n] = layer.screenOpacity;
 
         let n4 = n * 4;
 

package/src/og/shaders/drawnode.js

@@ -16,7 +16,7 @@ import { Program } from "../webgl/Program.js";
 const NIGHT = `const vec3 nightStep = 10.0 * vec3(0.58, 0.48, 0.25);`;
 
 const DEF_BLEND = `#define blend(DEST, SAMPLER, OFFSET, OPACITY) \
-                    src = texture( SAMPLER, OFFSET.xy + vTextureCoord.xy * OFFSET.zw ); \
+                    src = texture( SAMPLER, OFFSET.xy + vTextureCoord.xy * OFFSET.zw );\
                     DEST = DEST * (1.0 - src.a * OPACITY) + src * OPACITY;`;
 
 const DEF_BLEND_WEBGL1 = `#define blend(DEST, SAMPLER, OFFSET, OPACITY) \