@openglobus/og 0.11.8 → 0.12.4

package/src/og/scene/Planet.js

@@ -32,14 +32,16 @@ import { wgs84 } from "../ellipsoid/wgs84.js";
 import { NIGHT, SPECULAR } from "../res/images.js";
 import { Geoid } from "../terrain/Geoid.js";
 import { isUndef } from "../utils/shared.js";
+import { MAX_RENDERED_NODES } from "../quadTree/quadTree.js";
 
-const MAX_LOD = 1.0;
-const MIN_LOD = 0.75;
+const CUR_LOD_SIZE = 250; //px
+const MIN_LOD_SIZE = 312; //px
+const MAX_LOD_SIZE = 190; //px
 
 let _tempPickingPix_ = new Uint8Array(4),
     _tempDepthColor_ = new Uint8Array(4);
 
-const DEPTH_DISTANCE = 11;
+const DEPTH_DISTANCE = 11;//m
 
 /**
  * Maximum created nodes count. The more nodes count the more memory usage.
@@ -49,6 +51,8 @@ const DEPTH_DISTANCE = 11;
  */
 const MAX_NODES = 200;
 
+const HORIZON_TANGENT = 0.81;
+
 const EVENT_NAMES = [
     /**
      * Triggered before globe frame begins to render.
@@ -108,6 +112,13 @@ export class Planet extends RenderNode {
     constructor(options = {}) {
         super(options.name);
 
+        this._cameraFrustums = options.frustums || [
+            [1, 100 + 0.075],
+            [100, 1000 + 0.075],
+            [1000, 1e6 + 10000],
+            [1e6, 1e9]
+        ];
+
         /**
          * @public
          * @type {Ellipsoid}
@@ -378,9 +389,10 @@ export class Planet extends RenderNode {
          * @public
          * @type {number}
          */
-        this._lodRatio = MAX_LOD;
-        this._maxLodRatio = MAX_LOD;
-        this._minLodRatio = MIN_LOD;
+        this._lodSize = CUR_LOD_SIZE;
+        this._curLodSize = CUR_LOD_SIZE;
+        this._minLodSize = MIN_LOD_SIZE;
+        this._maxLodSize = MAX_LOD_SIZE;
 
         this._pickingColorArr = new Float32Array(this.SLICE_SIZE_4);
         this._samplerArr = new Int32Array(this.SLICE_SIZE);
@@ -397,11 +409,11 @@ export class Planet extends RenderNode {
 
         this._normalMapCreator = null;
 
-        this._terrainWorker = new TerrainWorker(2);
+        this._terrainWorker = new TerrainWorker(3);
 
-        this._plainSegmentWorker = new PlainSegmentWorker(2);
+        this._plainSegmentWorker = new PlainSegmentWorker(4);
 
-        this._tileLoader = new Loader(14);
+        this._tileLoader = new Loader(options.loadingBatchSize || 12);
 
         this._memKey = new Key();
 
@@ -433,11 +445,14 @@ export class Planet extends RenderNode {
         control.addTo(this.renderer);
     }
 
-    setRatioLod(maxLod, minLod) {
-        this._maxLodRatio = maxLod;
-        if (minLod) {
-            this._minLodRatio = minLod;
-        }
+    get lodSize() {
+        return this._lodSize;
+    }
+
+    setLodSize(currentLodSize, minLodSize, maxLodSize) {
+        this._maxLodSize = maxLodSize || this._maxLodSize;
+        this._minLodSize = minLodSize || this._minLodSize;
+        this._curLodSize = currentLodSize || this._curLodSize;
         this._renderCompletedActivated = false;
     }
 
@@ -717,6 +732,7 @@ export class Planet extends RenderNode {
         this.transparentTexture = this.renderer.handler.transparentTexture;
 
         this.camera = this.renderer.activeCamera = new PlanetCamera(this, {
+            frustums: this._cameraFrustums,
             eye: new Vec3(0, 0, 28000000),
             look: new Vec3(0, 0, 0),
             up: new Vec3(0, 1, 0),
@@ -799,38 +815,70 @@ export class Planet extends RenderNode {
     }
 
     _preRender() {
+        // Zoom 0
         this._quadTree.createChildrenNodes();
-        this._quadTree.segment.createPlainSegment();
-        this._quadTree.renderNode(true);
-        this._normalMapCreator.drawSingle(this._quadTree.segment);
+        this._quadTree.segment.createPlainSegment();        
 
+        // Zoom 1
         for (let i = 0; i < this._quadTree.nodes.length; i++) {
             this._quadTree.nodes[i].segment.createPlainSegment();
-            this._quadTree.nodes[i].renderNode(true);
-            this._normalMapCreator.drawSingle(this._quadTree.nodes[i].segment);
         }
 
+        // same for poles
         this._quadTreeNorth.createChildrenNodes();
         this._quadTreeNorth.segment.createPlainSegment();
+
+        for (let i = 0; i < this._quadTreeNorth.nodes.length; i++) {
+            this._quadTreeNorth.nodes[i].segment.createPlainSegment();
+        }
+
+        this._quadTreeSouth.createChildrenNodes();
+        this._quadTreeSouth.segment.createPlainSegment();
+
+        for (let i = 0; i < this._quadTreeSouth.nodes.length; i++) {
+            this._quadTreeSouth.nodes[i].segment.createPlainSegment();
+        }
+
+        this._preLoad();
+    }
+
+    _preLoad() {
+        this._clearRenderedNodeList();
+
+        this._skipPreRender = false;
+
+        // Same for poles
+        this._quadTreeNorth.segment.passReady = true;
         this._quadTreeNorth.renderNode(true);
         this._normalMapCreator.drawSingle(this._quadTreeNorth.segment);
 
         for (let i = 0; i < this._quadTreeNorth.nodes.length; i++) {
-            this._quadTreeNorth.nodes[i].segment.createPlainSegment();
+            this._quadTreeNorth.nodes[i].segment.passReady = true;
             this._quadTreeNorth.nodes[i].renderNode(true);
             this._normalMapCreator.drawSingle(this._quadTreeNorth.nodes[i].segment);
         }
 
-        this._quadTreeSouth.createChildrenNodes();
-        this._quadTreeSouth.segment.createPlainSegment();
+        this._quadTreeSouth.segment.passReady = true;
         this._quadTreeSouth.renderNode(true);
         this._normalMapCreator.drawSingle(this._quadTreeSouth.segment);
 
         for (let i = 0; i < this._quadTreeSouth.nodes.length; i++) {
-            this._quadTreeSouth.nodes[i].segment.createPlainSegment();
+            this._quadTreeSouth.nodes[i].segment.passReady = true;
             this._quadTreeSouth.nodes[i].renderNode(true);
             this._normalMapCreator.drawSingle(this._quadTreeSouth.nodes[i].segment);
         }
+
+        // Zoom 1
+        for (let i = 0; i < this._quadTree.nodes.length; i++) {
+            this._quadTree.nodes[i].segment.passReady = true;
+            this._quadTree.nodes[i].renderNode(true);
+            this._normalMapCreator.drawSingle(this._quadTree.nodes[i].segment);
+        }
+
+        // Zoom 0
+        this._quadTree.segment.passReady = true;
+        this._quadTree.renderNode(true);
+        this._normalMapCreator.drawSingle(this._quadTree.segment);
     }
 
     /**
@@ -908,6 +956,7 @@ export class Planet extends RenderNode {
                 if (li._attribution.length) {
                     html += "<li>" + li._attribution + "</li>";
                 }
+
             } else if (li._fading && li._fadingOpacity > 0) {
                 if (li.hasImageryTiles()) {
                     this.visibleTileLayers.push(li);
@@ -981,16 +1030,10 @@ export class Planet extends RenderNode {
     _collectRenderNodes() {
         let cam = this.camera;
 
-        this._lodRatio = math.lerp(
-            cam.slope < 0.0 ? 0.0 : cam.slope,
-            this._maxLodRatio,
-            this._minLodRatio
-        );
+        this._lodSize = math.lerp(cam.slope < 0.0 ? 0.0 : cam.slope, this._curLodSize, this._minLodSize);
 
         cam._insideSegment = null;
 
-        this._nodeCounterError_ = 0;
-
         // clear first
         this._clearRenderedNodeList();
 
@@ -1005,11 +1048,11 @@ export class Planet extends RenderNode {
 
         this._quadTree.renderTree(cam, 0, null);
 
-        if (
-            cam.slope > this.minEqualZoomCameraSlope &&
+        if (cam.slope > this.minEqualZoomCameraSlope &&
             cam._lonLat.height < this.maxEqualZoomAltitude &&
             cam._lonLat.height > this.minEqualZoomAltitude
         ) {
+
             this.minCurrZoom = this.maxCurrZoom;
 
             let temp = this._renderedNodes,
@@ -1026,7 +1069,8 @@ export class Planet extends RenderNode {
 
             for (var i = 0, len = temp.length; i < len; i++) {
                 var ri = temp[i];
-                if (ri.segment.tileZoom === this.maxCurrZoom) {
+                let ht = ri.segment.centerNormal.dot(cam._b);
+                if (ri.segment.tileZoom === this.maxCurrZoom || ht < HORIZON_TANGENT) {
                     this._renderedNodes.push(ri);
                     let k = 0,
                         inFrustum = ri.inFrustum;
@@ -1076,9 +1120,7 @@ export class Planet extends RenderNode {
     frame() {
         this._renderScreenNodesPASS();
 
-        if (this.renderer.isActiveBackbuffers) {
-            this._renderHeightPickingFramebufferPASS();
-        }
+        this._renderHeightPickingFramebufferPASS();
 
         this.drawEntityCollections(this._frustumEntityCollections);
     }
@@ -1156,11 +1198,8 @@ export class Planet extends RenderNode {
 
             // bind night glowing material
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
-            gl.bindTexture(
-                gl.TEXTURE_2D,
-                (this.camera._lonLat.height > 329958.0 &&
-                    (this._nightTexture || this.transparentTexture)) ||
-                this.transparentTexture
+            gl.bindTexture(gl.TEXTURE_2D,
+                (this.camera._lonLat.height > 329958.0 && (this._nightTexture || this.transparentTexture)) || this.transparentTexture
             );
             gl.uniform1i(shu.nightTexture, this.SLICE_SIZE);
 
@@ -1227,63 +1266,45 @@ export class Planet extends RenderNode {
      * @protected
      */
     _renderHeightPickingFramebufferPASS() {
-        this._heightPickingFramebuffer.activate();
-
-        let sh;
-        let renderer = this.renderer;
-        let h = renderer.handler;
-        let gl = h.gl;
-        let cam = renderer.activeCamera;
-        let frustumIndex = cam.getCurrentFrustum();
+        if (!this.terrain.isEmpty) {
 
-        if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
-            gl.clearColor(0.0, 0.0, 0.0, 1.0);
-            gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
-        } else {
-            gl.clear(gl.DEPTH_BUFFER_BIT);
-        }
+            this._heightPickingFramebuffer.activate();
 
-        gl.enable(gl.CULL_FACE);
-        gl.blendEquation(gl.FUNC_ADD);
-        gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
-        gl.enable(gl.BLEND);
+            let sh;
+            let renderer = this.renderer;
+            let h = renderer.handler;
+            let gl = h.gl;
+            let cam = renderer.activeCamera;
+            let frustumIndex = cam.getCurrentFrustum();
 
-        h.programs.drawnode_heightPicking.activate();
-        sh = h.programs.drawnode_heightPicking._program;
-        let shu = sh.uniforms;
+            if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
+                gl.clearColor(0.0, 0.0, 0.0, 1.0);
+                gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+            } else {
+                gl.clear(gl.DEPTH_BUFFER_BIT);
+            }
 
-        gl.uniformMatrix4fv(shu.viewMatrix, false, renderer.activeCamera.getViewMatrix());
-        gl.uniformMatrix4fv(
-            shu.projectionMatrix,
-            false,
-            renderer.activeCamera.getProjectionMatrix()
-        );
+            h.programs.drawnode_heightPicking.activate();
+            sh = h.programs.drawnode_heightPicking._program;
+            let shu = sh.uniforms;
 
-        gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
-        gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
+            gl.uniformMatrix4fv(shu.viewMatrix, false, renderer.activeCamera.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, renderer.activeCamera.getProjectionMatrix());
 
-        // drawing planet nodes
-        var rn = this._renderedNodesInFrustum[frustumIndex],
-            sl = this._visibleTileLayerSlices;
+            gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
+            gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
 
-        let i = rn.length;
-        while (i--) {
-            rn[i].segment.heightPickingRendering(sh, sl[0], 0);
-        }
+            // drawing planet nodes
+            var rn = this._renderedNodesInFrustum[frustumIndex],
+                sl = this._visibleTileLayerSlices;
 
-        //gl.enable(gl.POLYGON_OFFSET_FILL);
-        for (let j = 1, len = sl.length; j < len; j++) {
-            i = rn.length;
-            //gl.polygonOffset(0, -j);
+            let i = rn.length;
             while (i--) {
-                rn[i].segment.heightPickingRendering(sh, sl[j], j, this.transparentTexture, true);
+                rn[i].segment.heightPickingRendering(sh, sl[0]);
             }
-        }
-        //gl.disable(gl.POLYGON_OFFSET_FILL);
-
-        gl.disable(gl.BLEND);
 
-        this._heightPickingFramebuffer.deactivate();
+            this._heightPickingFramebuffer.deactivate();
+        }
     }
 
     /**
@@ -1362,15 +1383,7 @@ export class Planet extends RenderNode {
 
         let i = rn.length;
         while (i--) {
-            rn[i].segment.depthRendering(sh, sl[0], 0);
-        }
-
-        for (let j = 1, len = sl.length; j < len; j++) {
-            i = rn.length;
-            gl.polygonOffset(0, -j);
-            while (i--) {
-                rn[i].segment.depthRendering(sh, sl[j], j, this.transparentTexture, true);
-            }
+            rn[i].segment.depthRendering(sh, sl[0]);
         }
     }
 
@@ -1561,41 +1574,48 @@ export class Planet extends RenderNode {
      * @returns {number} -
      */
     getDistanceFromPixel(px) {
-        let r = this.renderer,
-            cnv = this.renderer.handler.canvas;
+        if (this.terrain.isEmpty) {
+            return this.getDistanceFromPixelEllipsoid(px) || 0;
+        } else {
 
-        let spx = px.x / cnv.width,
-            spy = (cnv.height - px.y) / cnv.height;
+            let r = this.renderer,
+                cnv = this.renderer.handler.canvas;
 
-        // HEIGHT
-        this._heightPickingFramebuffer.activate();
-        if (this._heightPickingFramebuffer.isComplete()) {
-            this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
-        }
-        this._heightPickingFramebuffer.deactivate();
-
-        let dist = decodeFloatFromRGBAArr(_tempPickingPix_);
-
-        if (!(_tempPickingPix_[0] || _tempPickingPix_[1] || _tempPickingPix_[2])) {
-            dist = this.getDistanceFromPixelEllipsoid(px) || 0;
-        } else if (dist < DEPTH_DISTANCE) {
-            r.screenDepthFramebuffer.activate();
-            if (r.screenDepthFramebuffer.isComplete()) {
-                r.screenDepthFramebuffer.readPixels(_tempDepthColor_, spx, spy);
-                let screenPos = new Vec4(
-                    spx * 2.0 - 1.0,
-                    spy * 2.0 - 1.0,
-                    (_tempDepthColor_[0] / 255.0) * 2.0 - 1.0,
-                    1.0 * 2.0 - 1.0
-                );
-                let viewPosition = this.camera.frustums[0]._inverseProjectionMatrix.mulVec4(screenPos);
-                let dir = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
-                dist = -(viewPosition.z / viewPosition.w) / dir.dot(this.renderer.activeCamera.getForward());
+            let spx = px.x / cnv.width,
+                spy = (cnv.height - px.y) / cnv.height;
+
+            _tempPickingPix_[0] = _tempPickingPix_[1] = _tempPickingPix_[2] = 0.0;
+
+            let dist = 0;
+
+            // HEIGHT
+            this._heightPickingFramebuffer.activate();
+            if (this._heightPickingFramebuffer.isComplete()) {
+                this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
+                dist = decodeFloatFromRGBAArr(_tempPickingPix_);
             }
-            r.screenDepthFramebuffer.deactivate();
+            this._heightPickingFramebuffer.deactivate();
+
+            if (!(_tempPickingPix_[0] || _tempPickingPix_[1] || _tempPickingPix_[2])) {
+                dist = this.getDistanceFromPixelEllipsoid(px) || 0;
+            } else if (dist < DEPTH_DISTANCE) {
+                r.screenDepthFramebuffer.activate();
+                if (r.screenDepthFramebuffer.isComplete()) {
+                    r.screenDepthFramebuffer.readPixels(_tempDepthColor_, spx, spy);
+                    let screenPos = new Vec4(
+                        spx * 2.0 - 1.0,
+                        spy * 2.0 - 1.0,
+                        (_tempDepthColor_[0] / 255.0) * 2.0 - 1.0,
+                        1.0 * 2.0 - 1.0
+                    );
+                    let viewPosition = this.camera.frustums[0]._inverseProjectionMatrix.mulVec4(screenPos);
+                    let dir = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
+                    dist = -(viewPosition.z / viewPosition.w) / dir.dot(this.renderer.activeCamera.getForward());
+                }
+                r.screenDepthFramebuffer.deactivate();
+            }
+            return dist;
         }
-
-        return dist;
     }
 
     /**