@openglobus/og 0.15.5 → 0.16.1

package/src/og/quadTree/Node.js

@@ -177,26 +177,21 @@ class Node {
         this.neighbors[2] = [];
         this.neighbors[3] = [];
 
-        let seg = this.segment, planet = this.planet;
+        let seg = this.segment,
+            planet = this.planet;
 
         this._cameraInside = false;
 
-        let insideLonLat = null;
-
         // Search a node which the camera is flying over.
         if (!this.parentNode || this.parentNode._cameraInside) {
             let inside;
             if (Math.abs(cam._lonLat.lat) <= MAX_LAT && seg._projection.id === EPSG3857.id) {
                 inside = seg._extent.isInside(cam._lonLatMerc);
-                insideLonLat = cam._lonLatMerc;
             } else if (seg._projection.id === EPSG4326.id) {
                 inside = seg._extent.isInside(cam._lonLat);
-                insideLonLat = cam._lonLat;
             }
 
             if (inside) {
-                cam._insideSegmentPosition.lon = insideLonLat.lon;
-                cam._insideSegmentPosition.lat = insideLonLat.lat;
                 cam._insideSegment = seg;
                 this._cameraInside = true;
             }
@@ -247,7 +242,7 @@ class Node {
                 seg._collectVisibleNodes();
             }
 
-            if (seg.tileZoom < 2 && seg.normalMapReady) {
+            if (seg.tileZoom < 2) {
                 this.traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading);
             } else if (seg.terrainReady && (!maxZoom && cam.projectedSize(seg.bsphere.center, seg._plainRadius) < planet._lodSize || maxZoom && ((seg.tileZoom === maxZoom) || !altVis))) {
 
@@ -285,7 +280,7 @@ class Node {
     }
 
     renderNode(inFrustum, onlyTerrain, terrainReadySegment, stopLoading) {
-        var seg = this.segment;
+        let seg = this.segment;
 
         // Create and load terrain data
         if (!seg.terrainReady) {
@@ -305,7 +300,7 @@ class Node {
         }
 
         // Create normal map texture
-        if (seg.planet.lightEnabled && !seg.normalMapReady /*&& !seg.parentNormalMapReady*/) {
+        if (seg.planet.lightEnabled && !seg.normalMapReady) {
             this.whileNormalMapCreating();
         }
 
@@ -487,36 +482,28 @@ class Node {
     }
 
     whileNormalMapCreating() {
-        var seg = this.segment;
-        var maxZ = this.planet.terrain.maxZoom;
 
-        if (seg.tileZoom <= maxZ && !seg.terrainIsLoading && seg.terrainReady && !seg._inTheQueue) {
+        let seg = this.segment;
+
+        if (/*seg.tileZoom <= seg.planet.terrain.maxNativeZoom && */!seg.terrainIsLoading && seg.terrainExists && !seg._inTheQueue) {
             seg.planet._normalMapCreator.queue(seg);
         }
 
-        var pn = this;
-
+        let pn = this;
         while (pn.parentNode && !pn.segment.normalMapReady) {
             pn = pn.parentNode;
         }
 
-        var dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1);
+        let dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1);
 
         seg.normalMapTexture = pn.segment.normalMapTexture;
         seg.normalMapTextureBias[0] = seg.tileX - pn.segment.tileX * dZ2;
         seg.normalMapTextureBias[1] = seg.tileY - pn.segment.tileY * dZ2;
         seg.normalMapTextureBias[2] = 1.0 / dZ2;
-
-        if (seg.tileZoom > maxZ) {
-            if (pn.segment.tileZoom === maxZ) {
-                seg.parentNormalMapReady = true;
-            }
-        }
     }
 
     whileTerrainLoading(terrainReadySegment, stopLoading) {
         const seg = this.segment;
-        const terrain = this.planet.terrain;
 
         let pn = this;
 
@@ -529,18 +516,23 @@ class Node {
         }
 
         if (pn.segment.terrainReady && this.appliedTerrainNodeId !== pn.nodeId) {
-            let dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1), offsetX = seg.tileX - pn.segment.tileX * dZ2,
+            let dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1),
+                offsetX = seg.tileX - pn.segment.tileX * dZ2,
                 offsetY = seg.tileY - pn.segment.tileY * dZ2;
 
             let pseg = pn.segment;
 
-            let tempVertices, tempVerticesHigh, tempVerticesLow, noDataVertices;
+            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;
+            let gridSize = pn.segment.gridSize / dZ2,
+                gridSizeExt = pn.segment.fileGridSize / dZ2;
 
             BOUNDS.xmin = MAX;
             BOUNDS.xmax = MIN;
@@ -562,7 +554,7 @@ class Node {
                 }
 
                 getMatrixSubArrayBoundsExt(pseg.terrainVertices, pseg.terrainVerticesHigh, pseg.terrainVerticesLow, pseg.noDataVertices, pseg.gridSize, gridSize * offsetY, gridSize * offsetX, gridSize, tempVertices, tempVerticesHigh, tempVerticesLow, BOUNDS, noDataVertices);
-            } else if (gridSizeExt >= 1) {
+            } else if (gridSizeExt >= 1 && pn.segment.terrainExists) {
                 seg.gridSize = gridSizeExt;
 
                 let len = (gridSizeExt + 1) * (gridSizeExt + 1) * 3;
@@ -658,9 +650,9 @@ class Node {
 
             seg.setBoundingVolume(BOUNDS.xmin, BOUNDS.ymin, BOUNDS.zmin, BOUNDS.xmax, BOUNDS.ymax, BOUNDS.zmax);
 
-            if (seg.tileZoom > terrain.maxZoom) {
-                if (pn.segment.tileZoom >= terrain.maxZoom) {
-                    //TODO: find better place for this
+            if (seg.tileZoom > seg.planet.terrain.maxZoom) {
+                if (pn.segment.tileZoom >= seg.planet.terrain.maxZoom) {
+
                     seg._plainRadius = pn.segment._plainRadius / dZ2;
 
                     seg.terrainReady = true;
@@ -670,11 +662,12 @@ class Node {
                     seg.terrainVerticesHigh = tempVerticesHigh;
                     seg.terrainVerticesLow = tempVerticesLow;
 
+                    seg.passReady = true;
+
                     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;
                         seg.normalMapVertices = tempVertices;
                         seg.fileGridSize = Math.sqrt(tempVertices.length / 3) - 1;
 
@@ -687,26 +680,27 @@ class Node {
                             seg.normalMapNormals = pseg.normalMapNormals;
                         }
                     }
-                } else {
-                    pn = this;
-                    while (pn.parentNode && pn.segment.tileZoom !== terrain.maxZoom) {
-                        pn = pn.parentNode;
-                    }
-
-                    let pns = pn.segment;
-
-                    if (!pns.initialized) {
-                        pns.initialize();
-                    }
-
-                    if (!pns.plainProcessing) {
-                        pn.segment.createPlainSegmentAsync();
-                    }
-
-                    if (pns.plainReady && !stopLoading) {
-                        pns.loadTerrain(true);
-                    }
                 }
+                // else {
+                //     pn = this;
+                //     while (pn.parentNode && pn.segment.tileZoom !== seg.planet.terrain.maxZoom) {
+                //         pn = pn.parentNode;
+                //     }
+                //
+                //     let pns = pn.segment;
+                //
+                //     if (!pns.initialized) {
+                //         pns.initialize();
+                //     }
+                //
+                //     if (!pns.plainProcessing) {
+                //         pn.segment.createPlainSegmentAsync();
+                //     }
+                //
+                //     if (pns.plainReady && !stopLoading) {
+                //         pns.loadTerrain(true);
+                //     }
+                // }
             }
         }
     }

package/src/og/quadTree/index.js

@@ -1,9 +1,11 @@
 import { EarthQuadTreeStrategy } from "./EarthQuadTreeStrategy.js";
 import { MarsQuadTreeStrategy } from "./MarsQuadTreeStrategy.js";
+import { EPSG4326QuadTreeStrategy } from "./EPSG4326QuadTreeStrategy.js";
 import { QuadTreeStrategy } from "./QuadTreeStrategy.js";
 import { Wgs84QuadTreeStrategy } from "./Wgs84QuadTreeStrategy.js";
 
 const quadTreeStrategyType = {
+    epsg4326: EPSG4326QuadTreeStrategy,
     earth: EarthQuadTreeStrategy,
     mars: MarsQuadTreeStrategy,
     wgs84: Wgs84QuadTreeStrategy

package/src/og/renderer/Renderer.js

@@ -24,6 +24,8 @@ let __depthCallbackCounter__ = 0;
 
 let __distanceCallbackCounter__ = 0;
 
+const MSAA_DEFAULT = 0;
+
 /**
  * Represents high level WebGL context interface that starts WebGL handler working in real time.
  * @class
@@ -177,7 +179,13 @@ class Renderer {
         this.depthFramebuffer = null;
 
         let urlParams = new URLSearchParams(location.search);
-        this._msaa = Number(urlParams.get('og_msaa') || params.msaa || 4);
+        let msaaParam = urlParams.get('og_msaa');
+        if (msaaParam) {
+            this._msaa = Number(urlParams.get('og_msaa'));
+        } else {
+            this._msaa = params.msaa != undefined ? params.msaa : MSAA_DEFAULT;
+        }
+
         this._internalFormat = "RGBA16F";
         this._format = "RGBA";
         this._type = "FLOAT";
@@ -797,6 +805,10 @@ class Renderer {
 
             i = rn.length;
             while (i--) {
+                gl.enable(gl.BLEND);
+                gl.blendEquation(gl.FUNC_ADD);
+                gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE);
+
                 rn[i].drawNode();
             }
 

package/src/og/scene/Planet.js

@@ -354,7 +354,7 @@ export class Planet extends RenderNode {
          */
         this._useSpecularTexture = isUndef(options.useSpecularTexture) ? true : options.useSpecularTexture;
 
-        this._maxGridSize = Math.log2(options.maxGridSize || 128);
+        this._maxGridSize = Math.log2(options.maxGridSize || 256);
 
         /**
          * Segment multiple textures size.(4 - convinient value for the most devices)
@@ -1142,7 +1142,7 @@ export class Planet extends RenderNode {
         }
 
         if (this.camera.isFirstPass) {
-            this.camera.updateGeodeticPosition();
+            this.camera.update();
             this._firstPASS();
             this.camera.checkTerrainCollision();
             this.camera.update();
@@ -1231,7 +1231,7 @@ export class Planet extends RenderNode {
 
         gl.enable(gl.BLEND);
         gl.blendEquation(gl.FUNC_ADD);
-        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
 
         if (this.lightEnabled) {
             h.programs.drawnode_screen_wl.activate();
@@ -1341,7 +1341,7 @@ export class Planet extends RenderNode {
 
         gl.enable(gl.BLEND);
         gl.blendEquation(gl.FUNC_ADD);
-        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
 
         if (this.lightEnabled) {
             h.programs.drawnode_screen_wl.activate();

package/src/og/scene/index.js

@@ -1,5 +1,5 @@
-import { Axes } from "./Axes";
-import { Planet } from "./Planet";
-import { SkyBox } from "./SkyBox";
+import { Axes } from "./Axes.js";
+import { Planet } from "./Planet.js";
+import { SkyBox } from "./SkyBox.js";
 
 export { Planet, Axes, SkyBox };

package/src/og/segment/Segment.js

@@ -174,12 +174,6 @@ class Segment {
          */
         this.normalMapReady = false;
 
-        /**
-         * Parent normal map is made allready(optimization parameter).
-         * @type {boolean}
-         */
-        this.parentNormalMapReady = false;
-
         /**
          * Terrain is allready applied flag.
          * @type {boolean}
@@ -360,7 +354,7 @@ class Segment {
      * @param {boolean} forceLoading
      */
     loadTerrain(forceLoading) {
-        if (this.tileZoom < this.planet.terrain.minZoom) {
+        if (this.tileZoom < this.planet.terrain.minZoom || this.planet.terrain.isEmpty) {
             this.terrainIsLoading = true;
 
             this.elevationsNotExists();
@@ -374,6 +368,9 @@ class Segment {
             } else if (!this.terrainIsLoading && !this.terrainReady) {
                 this.planet.terrain.loadTerrain(this, forceLoading);
             }
+            // if (!this.terrainIsLoading && !this.terrainReady) {
+            //     this.planet.terrain.loadTerrain(this, forceLoading);
+            // }
         }
     }
 
@@ -382,9 +379,8 @@ class Segment {
      * @param {Float32Array} elevations - Elevation data.
      */
     elevationsExists(elevations) {
-        const segment = this;
         if (this.plainReady && this.terrainIsLoading) {
-            this.planet._terrainWorker.make(segment, elevations);
+            this.planet._terrainWorker.make(this, elevations);
 
             this.plainVerticesHigh = null;
             this.plainVerticesLow = null;
@@ -399,6 +395,63 @@ class Segment {
         }
     }
 
+    /**
+     * Keep plain elevation segment for rendering
+     *
+     * 'this.tileZoom <= this.planet.terrain.maxZoom' it means, that the segment is plain
+     *
+     */
+    elevationsNotExists() {
+        if (this.planet && this.tileZoom <= this.planet.terrain.maxNativeZoom) {
+            if (this.plainReady && this.terrainIsLoading) {
+                this.terrainIsLoading = false;
+
+                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);
+                }
+
+                this.readyToEngage = true;
+            }
+
+            // plain terrain only
+            this.terrainVertices = this.plainVertices;
+            this.terrainVerticesHigh = this.plainVerticesHigh;
+            this.terrainVerticesLow = this.plainVerticesLow;
+
+            this.tempVertices = this.terrainVertices;
+            this.tempVerticesHigh = this.terrainVerticesHigh;
+            this.tempVerticesLow = this.terrainVerticesLow;
+
+            this.noDataVertices = null;
+
+            this.fileGridSize = Math.sqrt(this.terrainVertices.length / 3) - 1;
+            this.gridSize = this.fileGridSize;
+            this.terrainReady = true;
+            this.terrainExists = false;
+        } else {
+
+            if (this.plainReady && this.terrainIsLoading) {
+                this.terrainIsLoading = false;
+
+                let n = this.node;
+                n.appliedTerrainNodeId = this.node.nodeId;
+                n.equalizedSideWithNodeId[N] = n.equalizedSideWithNodeId[E] = n.equalizedSideWithNodeId[S] =
+                    n.equalizedSideWithNodeId[W] = n.appliedTerrainNodeId;
+
+                this.readyToEngage = true;
+                this.terrainReady = true;
+                this.passReady = true;
+
+                this.terrainExists = false;
+            }
+        }
+    }
+
     _checkEqualization(neighborSide, neigborNode) {
         return neigborNode && this.tileZoom >= neigborNode.segment.tileZoom &&
             this.node.equalizedSideWithNodeId[neighborSide] !== neigborNode.equalizedSideWithNodeId[OPSIDE[neighborSide]];
@@ -582,33 +635,6 @@ class Segment {
         this.createCoordsBuffers(this.tempVerticesHigh, this.tempVerticesLow, this.gridSize);
     }
 
-    _plainSegmentWorkerCallback(data) {
-        this.plainProcessing = false;
-
-        if (this.initialized && !this.terrainReady) {
-            this.plainVertices = data.plainVertices;
-            this.plainVerticesHigh = data.plainVerticesHigh;
-            this.plainVerticesLow = data.plainVerticesLow;
-
-            this.plainNormals = data.plainNormals;
-
-            this.normalMapNormals = data.normalMapNormals;
-            this.normalMapVertices = data.normalMapVertices;
-            this.normalMapVerticesHigh = data.normalMapVerticesHigh;
-            this.normalMapVerticesLow = data.normalMapVerticesLow;
-
-            this.terrainVertices = this.plainVertices;
-            this.terrainVerticesHigh = this.plainVerticesHigh;
-            this.terrainVerticesLow = this.plainVerticesLow;
-
-            this.fileGridSize = Math.sqrt(data.normalMapVertices.length / 3) - 1;
-
-            this._plainRadius = data.plainRadius;
-
-            this.plainReady = true;
-        }
-    }
-
     _terrainWorkerCallback(data) {
         if (this.plainReady) {
             this.readyToEngage = true;
@@ -654,7 +680,6 @@ class Segment {
 
             this.terrainReady = true;
             this.terrainIsLoading = false;
-            this.parentNormalMapReady = true;
             this.terrainExists = true;
 
             if (!this.normalMapTexturePtr) {
@@ -671,43 +696,6 @@ class Segment {
         }
     }
 
-    /**
-     * Terrain is not obtained or not exists on the server.
-     */
-    elevationsNotExists() {
-        if (this.planet && this.tileZoom <= this.planet.terrain.maxZoom) {
-            if (this.plainReady && this.terrainIsLoading) {
-                this.terrainIsLoading = false;
-
-                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);
-                }
-
-                this.readyToEngage = true;
-            }
-
-            this.terrainVertices = this.plainVertices;
-            this.terrainVerticesHigh = this.plainVerticesHigh;
-            this.terrainVerticesLow = this.plainVerticesLow;
-
-            this.tempVertices = this.terrainVertices;
-            this.tempVerticesHigh = this.terrainVerticesHigh;
-            this.tempVerticesLow = this.terrainVerticesLow;
-
-            this.noDataVertices = null;
-
-            this.fileGridSize = Math.sqrt(this.terrainVertices.length / 3) - 1;
-            this.gridSize = this.fileGridSize;
-            this.terrainReady = true;
-            this.terrainExists = false;
-        }
-    }
-
     _normalMapEdgeEqualize(side) {
         let nn = this.node.neighbors;
         let n = nn[side][0];
@@ -867,7 +855,6 @@ class Segment {
             this.handler.gl.deleteTexture(this.normalMapTexture);
         }
         this.normalMapReady = false;
-        this.parentNormalMapReady = false;
         this._appliedNeighborsZoom = [0, 0, 0, 0];
         this.normalMapTextureBias[0] = 0;
         this.normalMapTextureBias[1] = 0;
@@ -1256,12 +1243,37 @@ class Segment {
         let p = this.planet,
             t = p.terrain;
 
-        if (t.isReady() && this.tileZoom <= t.maxZoom && !this.plainReady) {
+        if (t.isReady() && !this.plainReady && this.tileZoom <= t.maxZoom) {
             this.plainProcessing = true;
             p._plainSegmentWorker.make(this);
         }
     }
 
+    _plainSegmentWorkerCallback(data) {
+        this.plainProcessing = false;
+
+        if (this.initialized && !this.terrainReady) {
+            this.plainReady = true;
+
+            this.plainVertices = data.plainVertices;
+            this.plainVerticesHigh = data.plainVerticesHigh;
+            this.plainVerticesLow = data.plainVerticesLow;
+            this.plainNormals = data.plainNormals;
+            this._plainRadius = data.plainRadius;
+
+            this.normalMapNormals = data.normalMapNormals;
+            this.normalMapVertices = data.normalMapVertices;
+            this.normalMapVerticesHigh = data.normalMapVerticesHigh;
+            this.normalMapVerticesLow = data.normalMapVerticesLow;
+
+            //this.terrainVertices = this.plainVertices;
+            //this.terrainVerticesHigh = this.plainVerticesHigh;
+            //this.terrainVerticesLow = this.plainVerticesLow;
+
+            this.fileGridSize = Math.sqrt(data.normalMapVertices.length / 3) - 1;
+        }
+    }
+
     createPlainSegment() {
         this.initialize();
         this._createPlainVertices();