@openglobus/og 0.15.3 → 0.15.4

package/src/og/scene/BaseNode.js

@@ -1,113 +1,113 @@
-/**
- * @module og/scene/BaseNode
- */
-
-"use strict";
-
-/**
- * Scene node base class.
- * @class
- * @param {string} name - Node name.
- */
-class BaseNode {
-    constructor(name) {
-        /**
-         * Node name.
-         * @public
-         * @type {string}
-         */
-        this.name = name;
-
-        /**
-         * Top scene tree node pointer.
-         * @public
-         * @type {RenderNode}
-         */
-        this.topNode = this;
-
-        this._dictionary = [];
-        this._dictionary[name] = this;
-
-        /**
-         * Children nodes.
-         * @public
-         * @type {Array.<RenderNode>}
-         */
-        this.childNodes = [];
-
-        /**
-         * Parent node pointer.
-         * @public
-         * @type {RenderNode}
-         */
-        this.parentNode = null;
-
-        this.__staticId = BaseNode._staticCounter++;
-    }
-
-    static get _staticCounter() {
-        if (!this.__counter__ && this.__counter__ !== 0) {
-            this.__counter__ = 0;
-        }
-        return this.__counter__;
-    }
-
-    static set _staticCounter(n) {
-        this.__counter__ = n;
-    }
-
-    /**
-     * Adds node to the current hierarchy.
-     * @public
-     * @type {BaseNode}
-     */
-    addNode(node) {
-        if (this.parentNode == null) {
-            node.topNode = this;
-        } else {
-            node.topNode = this.topNode;
-        }
-        node.parentNode = this;
-        node._dictionary = this.topNode._dictionary;
-        this.childNodes.push(node);
-        this.topNode._dictionary[node.name] = node;
-    }
-
-    /**
-     * Destroy node.
-     * @public
-     */
-    destroy() {
-        for (var i = 0; i < this.childNodes.length; i++) {
-            this.childNodes[i].destroy();
-        }
-        this._clear();
-    }
-
-    /**
-     * Gets node by name in the current.
-     * @public
-     * @param {string} name - Node name.
-     * @return {RenderNode} Node object in the current node.
-     */
-    getNodeByName(name) {
-        return this._dictionary[name];
-    }
-
-    /**
-     * Clear current node.
-     * @protected
-     */
-    _clear() {
-        this.name = "";
-        this.parentNode = null;
-        this.topNode = null;
-        this.childNodes.length = 0;
-    }
-
-    isEqual(node) {
-        return node.__staticId === this.__staticId;
-    }
-}
-
-export { BaseNode };
+/**
+ * @module og/scene/BaseNode
+ */
+
+"use strict";
+
+/**
+ * Scene node base class.
+ * @class
+ * @param {string} name - Node name.
+ */
+class BaseNode {
+    constructor(name) {
+        /**
+         * Node name.
+         * @public
+         * @type {string}
+         */
+        this.name = name;
+
+        /**
+         * Top scene tree node pointer.
+         * @public
+         * @type {BaseNode}
+         */
+        this.topNode = this;
+
+        this._dictionary = [];
+        this._dictionary[name] = this;
+
+        /**
+         * Children nodes.
+         * @public
+         * @type {Array.<RenderNode>}
+         */
+        this.childNodes = [];
+
+        /**
+         * Parent node pointer.
+         * @public
+         * @type {RenderNode}
+         */
+        this.parentNode = null;
+
+        this.__staticId = BaseNode._staticCounter++;
+    }
+
+    static get _staticCounter() {
+        if (!this.__counter__ && this.__counter__ !== 0) {
+            this.__counter__ = 0;
+        }
+        return this.__counter__;
+    }
+
+    static set _staticCounter(n) {
+        this.__counter__ = n;
+    }
+
+    /**
+     * Adds node to the current hierarchy.
+     * @public
+     * @type {BaseNode}
+     */
+    addNode(node) {
+        if (this.parentNode == null) {
+            node.topNode = this;
+        } else {
+            node.topNode = this.topNode;
+        }
+        node.parentNode = this;
+        node._dictionary = this.topNode._dictionary;
+        this.childNodes.push(node);
+        this.topNode._dictionary[node.name] = node;
+    }
+
+    /**
+     * Destroy node.
+     * @public
+     */
+    destroy() {
+        for (var i = 0; i < this.childNodes.length; i++) {
+            this.childNodes[i].destroy();
+        }
+        this._clear();
+    }
+
+    /**
+     * Gets node by name in the current.
+     * @public
+     * @param {string} name - Node name.
+     * @return {RenderNode} Node object in the current node.
+     */
+    getNodeByName(name) {
+        return this._dictionary[name];
+    }
+
+    /**
+     * Clear current node.
+     * @protected
+     */
+    _clear() {
+        this.name = "";
+        this.parentNode = null;
+        this.topNode = null;
+        this.childNodes.length = 0;
+    }
+
+    isEqual(node) {
+        return node.__staticId === this.__staticId;
+    }
+}
+
+export { BaseNode };

package/src/og/scene/Planet.js

@@ -740,9 +740,7 @@ export class Planet extends RenderNode {
         h.addProgram(shaders.drawnode_heightPicking(), true);
 
         this.renderer.addPickingCallback(this, this._renderColorPickingFramebufferPASS);
-
         this.renderer.addDepthCallback(this, this._renderDepthFramebufferPASS);
-
         this.renderer.addDistanceCallback(this, this._renderDistanceFramebufferPASS);
     }
 
@@ -1136,7 +1134,7 @@ export class Planet extends RenderNode {
      * Render node callback.
      * @public
      */
-    frame() {
+    preFrame() {
 
         if (this._updateLayer) {
             this._updateLayer = false;
@@ -1147,13 +1145,17 @@ export class Planet extends RenderNode {
             this._firstPASS();
         }
 
-        this._renderScreenNodesPASS();
-
-        //this._renderHeightPickingFramebufferPASS();
-
         this.drawEntityCollections(this._frustumEntityCollections);
     }
 
+    /**
+     * Render node callback.
+     * @public
+     */
+    frame() {
+        this._renderScreenNodesPASS();
+    }
+
     _checkRendercompleted() {
         if (this._renderCompleted) {
             if (!this._renderCompletedActivated) {
@@ -1299,6 +1301,7 @@ export class Planet extends RenderNode {
         }
 
         gl.enable(gl.POLYGON_OFFSET_FILL);
+        //gl.disable(gl.CULL_FACE);
         for (let j = 1, len = sl.length; j < len; j++) {
             let slj = sl[j];
             for (i = slj.length - 1; i >= 0; --i) {
@@ -1314,6 +1317,7 @@ export class Planet extends RenderNode {
                 rn[i].segment.screenRendering(sh, sl[j], j, this.transparentTexture, true);
             }
         }
+        //gl.enable(gl.CULL_FACE);
         gl.disable(gl.POLYGON_OFFSET_FILL);
     }
 
@@ -1594,7 +1598,6 @@ export class Planet extends RenderNode {
         this.terrain.abortLoading();
         this._tileLoader.abortAll();
 
-
         this.quadTreeStrategy.clear();
         this.layerLock.free(this._memKey);
         this.terrainLock.free(this._memKey);

package/src/og/scene/RenderNode.js

@@ -5,16 +5,17 @@ import { BaseNode } from "./BaseNode.js";
 
 /**
  * Render node is a logical part of a render mechanism. Represents scene rendering.
- * Forexample one scene node for rendering the Earth, another one for rendering the Moon, another node for rendering stars etc.
+ * For example one scene node for rendering the Earth, another one for rendering the Moon, another node for rendering stars etc.
  * Each render node has own model view space defined with matrices(scale, rotation, translation, transformation).
  * There are collections of ligh sources, entities and so on in the node.
  * Access to the node is renderer.renderNodes["Earth"]
  * @class
- * @extends {RenderNode}
+ * @extends {BaseNode}
  * @param {string} name - Node name.
  */
+
 class RenderNode extends BaseNode {
-    constructor(name) {
+    constructor(name = "") {
         super(name);
 
         /**
@@ -167,6 +168,15 @@ class RenderNode extends BaseNode {
         light.remove();
     }
 
+    /**
+     * Calls render frame node's callback. Used in renderer.
+     * @public
+     */
+    preDrawNode(frustum, frustumIndex) {
+        this._isActive && this._preDrawNodes(frustum, frustumIndex);
+    }
+
+
     /**
      * Calls render frame node's callback. Used in renderer.
      * @public
@@ -194,6 +204,8 @@ class RenderNode extends BaseNode {
 
         if (this.renderer) {
             if (this._isActive && this._pickingId === -1) {
+                // This picking callback MUST be the first picking callback
+                // in the rendering queue in the renderer. It affects on blending.
                 this._pickingId = this.renderer.addPickingCallback(
                     this,
                     this._entityCollectionPickingCallback
@@ -264,6 +276,31 @@ class RenderNode extends BaseNode {
         }
     }
 
+    frame() {
+
+    }
+
+    preFrame() {
+
+    }
+
+    /**
+     * @private
+     */
+    _preDrawNodes() {
+        for (var i = 0; i < this.childNodes.length; i++) {
+            if (this.childNodes[i]._isActive) {
+                this.childNodes[i]._preDrawNodes();
+            }
+        }
+
+        if (this.show) {
+            //this.lightEnabled && this.transformLights();
+            this.preFrame();
+            this.drawEntityCollections(this.entityCollections);
+        }
+    }
+
     /**
      * @private
      */
@@ -275,11 +312,7 @@ class RenderNode extends BaseNode {
         }
 
         if (this.show) {
-            if (this.frame) {
-                //this.lightEnabled && this.transformLights();
-                this.frame();
-            }
-            this.drawEntityCollections(this.entityCollections);
+            this.frame();
         }
     }
 
@@ -296,7 +329,7 @@ class RenderNode extends BaseNode {
         if (ec.length) {
 
             // billoard pass
-            let  i = ec.length;
+            let i = ec.length;
             while (i--) {
                 ec[i]._fadingOpacity && ec[i].billboardHandler.drawPicking();
             }

package/src/og/segment/Segment.js

@@ -316,7 +316,7 @@ class Segment {
                 if (d === Ray.INSIDE) {
                     return xyz.distance(res);
                 } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, xyz);
+                    _rayEx.set(xyz, this.planet.ellipsoid.getSurfaceNormal3v(xyz));
                     let d = _rayEx.hitTriangle(_v0, _v1, _v2, res, normal);
                     if (d === Ray.INSIDE) {
                         return -xyz.distance(res);
@@ -329,7 +329,7 @@ class Segment {
                 if (d === Ray.INSIDE) {
                     return xyz.distance(res);
                 } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, xyz);
+                    _rayEx.set(xyz, this.planet.ellipsoid.getSurfaceNormal3v(xyz));
                     let d = _rayEx.hitTriangle(_v1, _v3, _v2, res, normal);
                     if (d === Ray.INSIDE) {
                         return -xyz.distance(res);
@@ -1675,4 +1675,4 @@ class Segment {
     }
 }
 
-export { Segment };
+export { Segment };

package/src/og/shaders/geoObject.js

@@ -211,20 +211,21 @@ export const geo_object_picking = () =>
             const float RADIANS = 3.141592653589793 / 180.0;
 
             void main(void) {
-                         
+
                 if (aDispose == 0.0) {
                    return;
                 }
             
                 vColor = aPickingColor;
-                float roll = aPitchRoll.y * RADIANS;
+              
+                float roll = aPitchRoll.y;
                 mat3 rotZ = mat3(
                      vec3(cos(roll), sin(roll), 0.0),
                      vec3(-sin(roll), cos(roll), 0.0), 
                      vec3(0.0, 0.0, 1.0) 
                 );
 
-                float pitch = aPitchRoll.x * RADIANS;
+                float pitch = aPitchRoll.x;
                 mat3 rotX = mat3(
                     vec3(1.0, 0.0, 0.0),
                     vec3(0.0, cos(pitch), sin(pitch)), 
@@ -232,10 +233,11 @@ export const geo_object_picking = () =>
                );
 
                 vec3 position = aPositionHigh + aPositionLow;
+                vec3 cameraPosition = eyePositionHigh + eyePositionLow;
                 vec3 r = cross(normalize(-position), aDirection);
-                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ; /*up=-cross(aDirection, r)*/
+                mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
 
-                float dist = length(eyePositionHigh + eyePositionLow);
+                float dist = length(cameraPosition);
 
                 mat4 viewMatrixRTE = viewMatrix;
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
@@ -243,14 +245,14 @@ export const geo_object_picking = () =>
                 vec3 highDiff = aPositionHigh - eyePositionHigh;
                 vec3 lowDiff = aPositionLow - eyePositionLow;
              
-                vec3 look = position - (eyePositionHigh + eyePositionLow);
+                vec3 look = cameraPosition - position;
                 float lookLength = length(look);
-                
+                               
                 float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
                 
-                vec4 pos = vec4((highDiff + lowDiff) + modelMatrix * aVertexPosition * aScale * pickingScale * scd, 1.0);
-                                
-                gl_Position = projectionMatrix * viewMatrixRTE * pos;
+                vec3 vert = modelMatrix * aVertexPosition * aScale * pickingScale * scd;
+                               
+                gl_Position = projectionMatrix * viewMatrixRTE  * vec4(highDiff + lowDiff + vert, 1.0);
             }`,
         fragmentShader:
             `precision highp float;

package/src/og/shaders/pickingMask.js

@@ -20,7 +20,7 @@ export function pickingMask() {
             void main() {
             
                 gl_Position = vec4(coordinates + offset, 0.0, 1.0);
-                gl_PointSize = 20.0;
+                gl_PointSize = 5.0;
             }`,
         fragmentShader:
             `precision highp float;

package/src/og/utils/GeoImageCreator.js

@@ -4,6 +4,7 @@ import { LonLat } from '../LonLat.js';
 import * as utils from '../utils/shared.js';
 import { Framebuffer } from '../webgl/Framebuffer.js';
 import { Program } from '../webgl/Program.js';
+import { doubleToTwoFloats2 } from "../math/coder.js";
 
 export class GeoImageCreator {
 
@@ -32,35 +33,67 @@ export class GeoImageCreator {
      * @return{WebGLBuffer} Grid coordinates buffer.
      */
     createGridBuffer(c, toMerc) {
-        var gs = this._gridSize;
+        let gs = this._gridSize;
 
-        var v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
+        let v03 = new LonLat((c[3].lon - c[0].lon) / gs, (c[3].lat - c[0].lat) / gs),
             v12 = new LonLat((c[2].lon - c[1].lon) / gs, (c[2].lat - c[1].lat) / gs),
             v01 = new LonLat((c[1].lon - c[0].lon) / gs, (c[1].lat - c[0].lat) / gs),
             v32 = new LonLat((c[2].lon - c[3].lon) / gs, (c[2].lat - c[3].lat) / gs);
 
-        var grid = new Float32Array((gs + 1) * (gs + 1) * 2);
-        var k = 0;
+        const size = (gs + 1) * (gs + 1) * 2,
+            halfSize = size / 2;
+
+        let gridHigh = new Float32Array(size),
+            gridLow = new Float32Array(size);
+
+        let lonLatArr = new Array(halfSize);
+
+        let kh = 0,
+            kl = 0,
+            k = 0;
+
+        let tempArr = new Float32Array(2);
+
         for (let i = 0; i <= gs; i++) {
-            var P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
+
+            let P03i = new LonLat(c[0].lon + i * v03.lon, c[0].lat + i * v03.lat),
                 P12i = new LonLat(c[1].lon + i * v12.lon, c[1].lat + i * v12.lat);
+
             for (let j = 0; j <= gs; j++) {
-                var P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
+                let P01j = new LonLat(c[0].lon + j * v01.lon, c[0].lat + j * v01.lat),
                     P32j = new LonLat(c[3].lon + j * v32.lon, c[3].lat + j * v32.lat);
-                var xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
-                grid[k++] = xx.lon;
-                grid[k++] = xx.lat;
+                let xx = utils.getLinesIntersectionLonLat(P03i, P12i, P01j, P32j);
+                doubleToTwoFloats2(xx.lon, tempArr);
+                gridHigh[kh++] = tempArr[0];
+                gridLow[kl++] = tempArr[1];
+                doubleToTwoFloats2(xx.lat, tempArr);
+                gridHigh[kh++] = tempArr[0];
+                gridLow[kl++] = tempArr[1];
+
+                lonLatArr[k++] = xx;
             }
         }
 
         if (toMerc) {
-            for (let i = 0; i < grid.length; i += 2) {
-                let c = new LonLat(grid[i], grid[i + 1]).forwardMercator();
-                grid[i] = c.lon;
-                grid[i + 1] = c.lat;
+            for (let i = 0; i < halfSize; i++) {
+                let c = lonLatArr[i].forwardMercator();
+                doubleToTwoFloats2(c.lon, tempArr);
+                gridHigh[i * 2] = tempArr[0];
+                gridLow[i * 2] = tempArr[1];
+
+                doubleToTwoFloats2(c.lat, tempArr);
+                gridHigh[i * 2 + 1] = tempArr[0];
+                gridLow[i * 2 + 1] = tempArr[1];
+
+                //grid[i] = c.lon;
+                //grid[i + 1] = c.lat;
             }
         }
-        return this._planet.renderer.handler.createArrayBuffer(grid, 2, grid.length / 2);
+
+        return [
+            this._planet.renderer.handler.createArrayBuffer(gridHigh, 2, halfSize),
+            this._planet.renderer.handler.createArrayBuffer(gridLow, 2, halfSize)
+        ];
     }
 
     frame() {
@@ -133,20 +166,27 @@ export class GeoImageCreator {
         this._planet.renderer.handler.addProgram(new Program("geoImageTransform", {
             uniforms: {
                 sourceTexture: "sampler2d",
-                extentParams: "vec4",
+                extentParamsHigh: "vec4",
+                extentParamsLow: "vec4",
                 isFullExtent: "bool"
             },
             attributes: {
-                corners: "vec2",
+                cornersHigh: "vec2",
+                cornersLow: "vec2",
                 texCoords: "vec2"
             },
-            vertexShader: `attribute vec2 corners; 
+            vertexShader:
+                `attribute vec2 cornersHigh; 
+                     attribute vec2 cornersLow;
                       attribute vec2 texCoords; 
-                      varying vec2 v_texCoords; 
-                      uniform vec4 extentParams; 
-                      void main() { 
+                      uniform vec4 extentParamsHigh; 
+                      uniform vec4 extentParamsLow; 
+                      varying vec2 v_texCoords;
+                      void main() {                                                             
                           v_texCoords = texCoords; 
-                          gl_Position = vec4((-1.0 + (corners - extentParams.xy) * extentParams.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
+                          vec2 highDiff = cornersHigh - extentParamsHigh.xy;
+                          vec2 lowDiff = cornersLow - extentParamsLow.xy;                                        
+                          gl_Position = vec4((-1.0 + (highDiff + lowDiff) * extentParamsHigh.zw) * vec2(1.0, -1.0), 0.0, 1.0); 
                       }`,
             fragmentShader:
                 `precision highp float;