@openglobus/og 0.11.7 → 0.12.3

package/src/og/scene/Planet.js

@@ -4,6 +4,7 @@
 
 "use strict";
 
+import * as utils from "../utils/shared.js";
 import * as shaders from "../shaders/drawnode.js";
 import * as math from "../math.js";
 import * as mercator from "../mercator.js";
@@ -31,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.
@@ -48,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.
@@ -107,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}
@@ -335,6 +347,16 @@ export class Planet extends RenderNode {
          */
         this._specularTexture = null;
 
+        //TODO: replace to a function
+        let a = utils.createColorRGB(options.ambient, new Vec3(0.2, 0.2, 0.2));
+        let d = utils.createColorRGB(options.diffuse, new Vec3(0.8, 0.8, 0.8));
+        let s = utils.createColorRGB(options.specular, new Vec3(0.0003, 0.0003, 0.0003));
+        let shininess = options.shininess || 20.0;
+
+        this._ambient = new Float32Array([a.x, a.y, a.z]);
+        this._diffuse = new Float32Array([d.x, d.y, d.z]);
+        this._specular = new Float32Array([s.x, s.y, s.z, shininess]);
+
         /**
          * True for rendering night glowing texture.
          * @protected
@@ -367,18 +389,12 @@ export class Planet extends RenderNode {
          * @public
          * @type {number}
          */
-        this._lodRatio = MAX_LOD;
-        this._maxLodRatio = MAX_LOD;
-        this._minLodRatio = MIN_LOD;
-
-        this._diffuseMaterialArr = new Float32Array(this.SLICE_SIZE_3 + 3);
-        this._ambientMaterialArr = new Float32Array(this.SLICE_SIZE_3 + 3);
-        this._specularMaterialArr = new Float32Array(this.SLICE_SIZE_4 + 4);
-
-        this._tileOffsetArr = new Float32Array(this.SLICE_SIZE_4);
-        this._visibleExtentOffsetArr = new Float32Array(this.SLICE_SIZE_4);
-        this._transparentColorArr = new Float32Array(this.SLICE_SIZE_4);
-        this._pickingColorArr = new Float32Array(this.SLICE_SIZE_3);
+        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);
         this._pickingMaskArr = new Int32Array(this.SLICE_SIZE);
 
@@ -393,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();
 
@@ -429,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;
     }
 
@@ -619,11 +638,8 @@ export class Planet extends RenderNode {
         var h = this.renderer.handler;
 
         h.addProgram(shaders.drawnode_screen_nl(), true);
-
         //h.addProgram(shaders.drawnode_screen_wl(), true);
-
         h.addProgram(shaders.drawnode_screen_wl_webgl2(), true);
-
         h.addProgram(shaders.drawnode_colorPicking(), true);
         h.addProgram(shaders.drawnode_depth(), true);
         h.addProgram(shaders.drawnode_heightPicking(), true);
@@ -716,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),
@@ -798,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);
     }
 
     /**
@@ -907,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);
@@ -980,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();
 
@@ -1004,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,
@@ -1025,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;
@@ -1135,7 +1180,6 @@ export class Planet extends RenderNode {
         gl.enable(gl.BLEND);
         gl.blendEquation(gl.FUNC_ADD);
         gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-        //gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ZERO);
 
         if (this.lightEnabled) {
             h.programs.drawnode_screen_wl.activate();
@@ -1148,13 +1192,14 @@ export class Planet extends RenderNode {
             gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
             gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
 
+            gl.uniform3fv(shu.diffuse, this._diffuse);
+            gl.uniform3fv(shu.ambient, this._ambient);
+            gl.uniform4fv(shu.specular, this._specular);
+
             // 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);
 
@@ -1163,34 +1208,6 @@ export class Planet extends RenderNode {
             gl.bindTexture(gl.TEXTURE_2D, this._specularTexture || this.transparentTexture);
             gl.uniform1i(shu.specularTexture, this.SLICE_SIZE + 1);
 
-            var b = this.baseLayer;
-            if (b) {
-                this._diffuseMaterialArr[0] = b.diffuse.x;
-                this._diffuseMaterialArr[1] = b.diffuse.y;
-                this._diffuseMaterialArr[2] = b.diffuse.z;
-
-                this._ambientMaterialArr[0] = b.ambient.x;
-                this._ambientMaterialArr[1] = b.ambient.y;
-                this._ambientMaterialArr[2] = b.ambient.z;
-
-                this._specularMaterialArr[0] = b.specular.x;
-                this._specularMaterialArr[1] = b.specular.y;
-                this._specularMaterialArr[2] = b.specular.z;
-                this._specularMaterialArr[3] = b.shininess;
-            } else {
-                this._diffuseMaterialArr[0] = 0.89;
-                this._diffuseMaterialArr[1] = 0.9;
-                this._diffuseMaterialArr[2] = 0.83;
-
-                this._ambientMaterialArr[0] = 0.0;
-                this._ambientMaterialArr[1] = 0.0;
-                this._ambientMaterialArr[2] = 0.0;
-
-                this._specularMaterialArr[0] = 0.0003;
-                this._specularMaterialArr[1] = 0.00012;
-                this._specularMaterialArr[2] = 0.00001;
-                this._specularMaterialArr[3] = 20.0;
-            }
         } else {
             h.programs.drawnode_screen_nl.activate();
             sh = h.programs.drawnode_screen_nl._program;
@@ -1249,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();
+        }
     }
 
     /**
@@ -1368,6 +1367,7 @@ export class Planet extends RenderNode {
         let cam = renderer.activeCamera;
 
         gl.disable(gl.BLEND);
+        gl.disable(gl.POLYGON_OFFSET_FILL);
 
         gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
         gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
@@ -1383,16 +1383,7 @@ export class Planet extends RenderNode {
 
         let i = rn.length;
         while (i--) {
-            rn[i].segment.depthRendering(sh, sl[0], 0);
-        }
-
-        gl.enable(gl.POLYGON_OFFSET_FILL);
-        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]);
         }
     }
 
@@ -1492,12 +1483,11 @@ export class Planet extends RenderNode {
      * Returns 3d cartesian coordinates on the relief planet by mouse cursor
      * position or null if mouse cursor is outside the planet.
      * @public
-     * @param {Boolean} [force=false] - Force framebuffer rendering.
      * @returns {Vec3} -
      */
-    getCartesianFromMouseTerrain(force) {
+    getCartesianFromMouseTerrain() {
         var ms = this.renderer.events.mouseState;
-        var distance = this.getDistanceFromPixel(ms, force);
+        var distance = this.getDistanceFromPixel(ms);
         if (distance) {
             return ms.direction.scaleTo(distance).addA(this.renderer.activeCamera.eye);
         }
@@ -1512,8 +1502,8 @@ export class Planet extends RenderNode {
      * @param {Boolean} [force=false] - Force framebuffer rendering.
      * @returns {Vec3} -
      */
-    getCartesianFromPixelTerrain(px, force) {
-        var distance = this.getDistanceFromPixel(px, force);
+    getCartesianFromPixelTerrain(px) {
+        var distance = this.getDistanceFromPixel(px);
         if (distance) {
             var direction = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
             return direction.scaleTo(distance).addA(this.renderer.activeCamera.eye);
@@ -1584,40 +1574,48 @@ export class Planet extends RenderNode {
      * @returns {number} -
      */
     getDistanceFromPixel(px) {
-        let r = this.renderer,
-            cnv = this.renderer.handler.canvas;
-
-        let spx = px.x / cnv.width,
-            spy = (cnv.height - px.y) / cnv.height;
-
-        // HEIGHT
-        this._heightPickingFramebuffer.activate();
-        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();
-            r.screenDepthFramebuffer.readPixels(_tempDepthColor_, spx, spy, 0);
-            r.screenDepthFramebuffer.deactivate();
-
-            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());
-        }
+        if (this.terrain.isEmpty) {
+            return this.getDistanceFromPixelEllipsoid(px) || 0;
+        } else {
+
+            let r = this.renderer,
+                cnv = this.renderer.handler.canvas;
+
+            let spx = px.x / cnv.width,
+                spy = (cnv.height - px.y) / cnv.height;
 
-        return dist;
+            _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_);
+            }
+            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;
+        }
     }
 
     /**