@openglobus/og 0.11.8 → 0.12.4

package/src/og/layer/XYZ.js

@@ -151,8 +151,9 @@ class XYZ extends Layer {
         } else {
             material.texture = seg.planet.transparentTexture;
         }
-
-        if (this._planet.layerLock.isFree()) {
+
+        // Q: Maybe we should change "<2" to material.segment.tileZoom < (material.layer.minZoom + 1)
+        if (this._planet.layerLock.isFree() || material.segment.tileZoom < 2) {
             material.isReady = false;
             material.isLoading = true;
 
@@ -237,9 +238,6 @@ class XYZ extends Layer {
         if (material.isReady) {
             return material.texOffset;
         } else {
-            // if (material.loadingAttempts > 20) {
-            //     debugger;
-            // }
 
             let segment = material.segment,
                 pn = segment.node,
@@ -248,34 +246,35 @@ class XYZ extends Layer {
             let mId = this._id;
             let psegm = material;
             while (pn.parentNode) {
+                pn = pn.parentNode;
+                psegm = pn.segment.materials[mId];
                 if (psegm && psegm.textureExists) {
                     notEmpty = true;
                     break;
                 }
-                pn = pn.parentNode;
-                psegm = pn.segment.materials[mId];
             }
-
-            let maxNativeZoom = material.layer.maxNativeZoom;
-
-            if (pn.segment.tileZoom === maxNativeZoom) {
-                material.textureNotExists();
-            } else if (material.segment.tileZoom <= maxNativeZoom) {
-                !material.isLoading && !material.isReady && this.loadMaterial(material);
-            } else {
-                let pn = segment.node;
-                while (pn.segment.tileZoom > material.layer.maxNativeZoom) {
-                    pn = pn.parentNode;
-                }
-                let pnm = pn.segment.materials[material.layer._id];
-                if (pnm) {
-                    !pnm.isLoading && !pnm.isReady && this.loadMaterial(pnm, true);
+
+            if (segment.passReady) {
+                let maxNativeZoom = material.layer.maxNativeZoom;
+                if (pn.segment.tileZoom === maxNativeZoom) {
+                    material.textureNotExists();
+                } else if (material.segment.tileZoom <= maxNativeZoom) {
+                    !material.isLoading && !material.isReady && this.loadMaterial(material);
                 } else {
-                    pnm = pn.segment.materials[material.layer._id] = material.layer.createMaterial(
-                        pn.segment
-                    );
-                    this.loadMaterial(pnm, true);
-                }
+                    let pn = segment.node;
+                    while (pn.segment.tileZoom > material.layer.maxNativeZoom) {
+                        pn = pn.parentNode;
+                    }
+                    let pnm = pn.segment.materials[material.layer._id];
+                    if (pnm) {
+                        !pnm.isLoading && !pnm.isReady && this.loadMaterial(pnm, true);
+                    } else {
+                        pnm = pn.segment.materials[material.layer._id] = material.layer.createMaterial(
+                            pn.segment
+                        );
+                        this.loadMaterial(pnm, true);
+                    }
+                }
             }
 
             if (notEmpty) {
@@ -313,7 +312,7 @@ class XYZ extends Layer {
 
         material.isReady = false;
         material.textureExists = false;
-        material.isLoading = false;
+        material.isLoading = false;        
     }
 
     /**

package/src/og/math/Vec3.js

@@ -699,8 +699,24 @@ export class Vec3 {
      * @param {Vec3} point3 - Distant point.
      * @returns {number} -
      */
-    distance(point3) {
-        return Vec3.sub(this, point3).length();
+    distance(point3) {
+        let dx = this.x - point3.x,
+            dy = this.y - point3.y,
+            dz = this.z - point3.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+
+    /**
+     * Gets square distance to point.
+     * @public
+     * @param {Vec3} point3 - Distant point.
+     * @returns {number} -
+     */
+    distance2(point3) {
+        let dx = this.x - point3.x,
+            dy = this.y - point3.y,
+            dz = this.z - point3.z;
+        return dx * dx + dy * dy + dz * dz;
     }
 
     /**

package/src/og/quadTree/Node.js

@@ -7,7 +7,6 @@ import { Vec3 } from "../math/Vec3.js";
 import { MAX_LAT } from "../mercator.js";
 import { EPSG3857 } from "../proj/EPSG3857.js";
 import { EPSG4326 } from "../proj/EPSG4326.js";
-import { MAX_NORMAL_ZOOM } from "../segment/Segment.js";
 import { getMatrixSubArray, getMatrixSubArrayBoundsExt } from "../utils/shared.js";
 import {
     COMSIDE,
@@ -30,8 +29,6 @@ import {
     WALKTHROUGH
 } from "./quadTree.js";
 
-const VISIBLE_HEIGHT = 1400000.0;
-
 let _tempHigh = new Vec3(),
     _tempLow = new Vec3();
 
@@ -67,6 +64,7 @@ class Node {
 
     constructor(SegmentPrototype, planet, partId, parent, id, tileZoom, extent) {
         this.SegmentPrototype = SegmentPrototype;
+        planet._createdNodesCount++;
         this.planet = planet;
         this.parentNode = parent;
         this.partId = partId;
@@ -84,7 +82,6 @@ class Node {
         this._cameraInside = false;
         this.inFrustum = 0;
         this.createBounds();
-        this.planet._createdNodesCount++;
     }
 
     createChildrenNodes() {
@@ -102,45 +99,10 @@ class Node {
         var c = new LonLat(sw.lon + size_x, sw.lat + size_y);
         var nd = this.nodes;
 
-        nd[NW] = new Node(
-            this.SegmentPrototype,
-            p,
-            NW,
-            this,
-            id,
-            z,
-            new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat))
-        );
-
-        nd[NE] = new Node(
-            this.SegmentPrototype,
-            p,
-            NE,
-            this,
-            id,
-            z,
-            new Extent(c, new LonLat(ne.lon, ne.lat))
-        );
-
-        nd[SW] = new Node(
-            this.SegmentPrototype,
-            p,
-            SW,
-            this,
-            id,
-            z,
-            new Extent(new LonLat(sw.lon, sw.lat), c)
-        );
-
-        nd[SE] = new Node(
-            this.SegmentPrototype,
-            p,
-            SE,
-            this,
-            id,
-            z,
-            new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y))
-        );
+        nd[NW] = new Node(this.SegmentPrototype, p, NW, this, id, z, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)));
+        nd[NE] = new Node(this.SegmentPrototype, p, NE, this, id, z, new Extent(c, new LonLat(ne.lon, ne.lat)));
+        nd[SW] = new Node(this.SegmentPrototype, p, SW, this, id, z, new Extent(new LonLat(sw.lon, sw.lat), c));
+        nd[SE] = new Node(this.SegmentPrototype, p, SE, this, id, z, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)));
     }
 
     createBounds() {
@@ -153,6 +115,15 @@ class Node {
         } else {
             seg.createBoundsByParent();
         }
+
+        let x = seg.bsphere.center.x,
+            y = seg.bsphere.center.y,
+            z = seg.bsphere.center.z;
+
+        let length = 1.0 / Math.sqrt(x * x + y * y + z * z);
+        seg.centerNormal.x = x * length;
+        seg.centerNormal.y = y * length;
+        seg.centerNormal.z = z * length;
     }
 
     getState() {
@@ -204,15 +175,10 @@ class Node {
     }
 
     renderTree(cam, maxZoom, terrainReadySegment, stopLoading) {
-        if (
-            this.planet._renderedNodes.length >= MAX_RENDERED_NODES ||
-            this.planet._nodeCounterError_ > 2000
-        ) {
+        if (this.planet._renderedNodes.length >= MAX_RENDERED_NODES) {
             return;
         }
 
-        this.planet._nodeCounterError_++;
-
         this.state = WALKTHROUGH;
 
         this.neighbors[0] = null;
@@ -282,27 +248,49 @@ class Node {
         if (this.inFrustum || this._cameraInside || seg.tileZoom < 3) {
             let h = cam._lonLat.height;
 
-            let altVis =
-                cam.eye.distance(seg.bsphere.center) - seg.bsphere.radius <
-                VISIBLE_DISTANCE * Math.sqrt(h) ||
+            let eye = cam.eye;
+            let horizonDist = eye.length2() - this.planet.ellipsoid._b2;
+
+            let altVis = seg.tileZoom > 19 ||
                 (seg.tileZoom < 4 && !seg.terrainReady) ||
                 seg.tileZoom < 2;
 
+            if (h > 21000) {
+                altVis = altVis || eye.distance2(seg._sw) < horizonDist
+                    || eye.distance2(seg._nw) < horizonDist
+                    || eye.distance2(seg._ne) < horizonDist
+                    || eye.distance2(seg._se) < horizonDist;
+            } else {
+                altVis = altVis || cam.eye.distance(seg.bsphere.center) - seg.bsphere.radius < VISIBLE_DISTANCE * Math.sqrt(h);
+            }
+
             if ((this.inFrustum && (altVis || h > 10000.0)) || this._cameraInside) {
                 seg._collectVisibleNodes();
             }
 
             if (seg.tileZoom < 2 && seg.normalMapReady) {
                 this.traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading);
-            } else if ((!maxZoom && seg.acceptForRendering(cam)) || seg.tileZoom === maxZoom || !altVis && maxZoom) {
-                this.prepareForRendering(cam, altVis, this.inFrustum, terrainReadySegment, stopLoading);
-            } else if (seg.tileZoom < planet.terrain._maxNodeZoom && seg.terrainReady) {
-                // Deleting terrainReady here, you have to remove
-                // this.appliedTerrainNodeId !== pn.nodeId in whileTerrainLoading,
-                // also have to fix createBoundsByParent(*)
+            } else if (seg.terrainReady && (
+                !maxZoom && cam.projectedSize(seg.bsphere.center, seg._plainRadius) < planet._lodSize ||
+                maxZoom && ((seg.tileZoom === maxZoom) || !altVis))) {
+
+                if (altVis) {
+                    seg.passReady = true;
+                    this.renderNode(this.inFrustum, !this.inFrustum, terrainReadySegment, stopLoading);
+                } else {
+                    this.state = NOTRENDERING;
+                }
+
+            } else if (
+                seg.terrainReady &&
+                seg.tileZoom < planet.terrain._maxNodeZoom &&
+                (!maxZoom || maxZoom && cam.projectedSize(seg.bsphere.center, seg.bsphere.radius) > this.planet._maxLodSize)) {
                 this.traverseNodes(cam, maxZoom, seg, stopLoading);
+            } else if (altVis) {
+                seg.passReady = maxZoom ? seg.terrainReady : false;
+                this.renderNode(this.inFrustum, !this.inFrustum, terrainReadySegment, stopLoading);
             } else {
-                this.prepareForRendering(cam, altVis, this.inFrustum, terrainReadySegment, stopLoading);
+                this.state = NOTRENDERING;
             }
         } else {
             this.state = NOTRENDERING;
@@ -322,39 +310,6 @@ class Node {
         n[3].renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
     }
 
-    prepareForRendering(
-        cam,
-        altVis,
-        inFrustum,
-        terrainReadySegment,
-        stopLoading
-    ) {
-        let seg = this.segment;
-
-        if (cam._lonLat.height < VISIBLE_HEIGHT) {
-            if (altVis) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else {
-                this.state = NOTRENDERING;
-            }
-        } else {
-            if (seg.tileZoom < 2) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else if (seg.tileZoom > MAX_NORMAL_ZOOM) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else if (
-                seg._swNorm.dot(cam._n) > 0.0 ||
-                seg._nwNorm.dot(cam._n) > 0.0 ||
-                seg._neNorm.dot(cam._n) > 0.0 ||
-                seg._seNorm.dot(cam._n) > 0.0
-            ) {
-                this.renderNode(inFrustum, !inFrustum, terrainReadySegment, stopLoading);
-            } else {
-                this.state = NOTRENDERING;
-            }
-        }
-    }
-
     renderNode(inFrustum, onlyTerrain, terrainReadySegment, stopLoading) {
         var seg = this.segment;
 
@@ -376,7 +331,7 @@ class Node {
         }
 
         // Create normal map texture
-        if (seg.planet.lightEnabled && !seg.normalMapReady && !seg.parentNormalMapReady) {
+        if (seg.planet.lightEnabled && !seg.normalMapReady /*&& !seg.parentNormalMapReady*/) {
             this.whileNormalMapCreating();
         }
 

package/src/og/quadTree/quadTree.js

@@ -1,7 +1,7 @@
 "use strict";
 
 export const VISIBLE_DISTANCE = 3570.0;
-export const MAX_RENDERED_NODES = 700;
+export const MAX_RENDERED_NODES = 1000;
 
 export const NW = 0;
 export const NE = 1;

package/src/og/renderer/Renderer.js

@@ -210,8 +210,6 @@ class Renderer {
 
         this._currentOutput = "screen";
 
-        this.isActiveBackbuffers = true;
-
         this.labelWorker = new LabelWorker();
     }
 
@@ -481,8 +479,8 @@ class Renderer {
         }
 
         this.handler.onCanvasResize = () => {
+            this.resize();
             this.events.dispatch(this.events.resize, this.handler.canvas);
-            this._resize();
         };
 
         this._screenFrameCornersBuffer = this.handler.createArrayBuffer(
@@ -509,7 +507,7 @@ class Renderer {
         }
     }
 
-    _resize() {
+    resize() {
         let c = this.handler.canvas;
         this.activeCamera.setAspectRatio(c.width / c.height);
         this.sceneFramebuffer.setSize(c.width, c.height);
@@ -744,7 +742,7 @@ class Renderer {
 
         let frustums = this.activeCamera.frustums;
 
-        let anyEvent = this.events.mouseState.anyEvent() && this.isActiveBackbuffers;
+        let anyEvent = this.events.mouseState.anyEvent();
 
         // Rendering scene nodes and entityCollections
         let rn = this._renderNodesArr;