@openglobus/og 0.15.3 → 0.15.5

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;
@@ -1144,16 +1142,27 @@ export class Planet extends RenderNode {
         }
 
         if (this.camera.isFirstPass) {
+            this.camera.updateGeodeticPosition();
             this._firstPASS();
-        }
+            this.camera.checkTerrainCollision();
+            this.camera.update();
 
-        this._renderScreenNodesPASS();
-
-        //this._renderHeightPickingFramebufferPASS();
+            // Here is the planet node dispatches a draw event before
+            // rendering begins and we have got render nodes.
+            this.events.dispatch(this.events.draw, this);
+        }
 
         this.drawEntityCollections(this._frustumEntityCollections);
     }
 
+    /**
+     * Render node callback.
+     * @public
+     */
+    frame() {
+        this._renderScreenNodesPASS();
+    }
+
     _checkRendercompleted() {
         if (this._renderCompleted) {
             if (!this._renderCompletedActivated) {
@@ -1194,10 +1203,6 @@ export class Planet extends RenderNode {
         }
         this._skipPreRender = true;
 
-        // Here is the planet node dispatches a draw event before
-        // rendering begins and we have got render nodes.
-        this.events.dispatch(this.events.draw, this);
-
         this.transformLights();
 
         this._normalMapCreator.frame();
@@ -1299,6 +1304,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 +1320,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);
     }
 
@@ -1542,7 +1549,8 @@ export class Planet extends RenderNode {
         gl.uniform3fv(shu.frustumPickingColor, cam.frustum._pickingColorU);
 
         // drawing planet nodes
-        var rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()], sl = this._visibleTileLayerSlices;
+        let rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()],
+            sl = this._visibleTileLayerSlices;
 
         let i = rn.length;
         while (i--) {
@@ -1594,7 +1602,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

@@ -254,11 +254,10 @@ class Segment {
      * @public
      * @param {Entity} entity - Entity.
      * @param {Vec3} res - Point coordinates.
-     * @param {Vec3} [normal] - Terrain point normal.
      * @returns {Vec3} -
      */
-    getEntityTerrainPoint(entity, res, normal) {
-        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res, normal);
+    getEntityTerrainPoint(entity, res) {
+        return this.getTerrainPoint(entity._cartesian, entity._lonlatMerc, res);
     }
 
     isEntityInside(e) {
@@ -274,80 +273,74 @@ class Segment {
      * @param {Vec3} [normal] - Terrain point normal.
      * @returns {number} -
      */
-    getTerrainPoint(xyz, insideSegmentPosition, res, normal) {
-        var verts = this.tempVertices;
+    getTerrainPoint(xyz, insideSegmentPosition, res) {
+        let verts = this.tempVertices;
 
-        _ray.set(xyz, xyz.negateTo());
+        if (verts && verts.length) {
+            let norm = this.planet.ellipsoid.getSurfaceNormal3v(xyz);
+            _ray.set(xyz, norm.negateTo());
 
-        if (verts) {
-            var ne = this._extent.northEast,
+            let ne = this._extent.northEast,
                 sw = this._extent.southWest,
                 size = Math.sqrt(verts.length / 3) - 1;
 
-            var xmax = ne.lon,
+            let xmax = ne.lon,
                 ymax = ne.lat,
                 xmin = sw.lon,
                 ymin = sw.lat,
                 x = insideSegmentPosition.lon,
                 y = insideSegmentPosition.lat;
 
-            var sxn = xmax - xmin,
+            let sxn = xmax - xmin,
                 syn = ymax - ymin;
 
-            var qx = sxn / size,
+            let qx = sxn / size,
                 qy = syn / size;
 
-            var xn = x - xmin,
+            let xn = x - xmin,
                 yn = y - ymin;
 
-            var indX = Math.floor(xn / qx),
+            let indX = Math.floor(xn / qx),
                 indY = Math.floor(size - yn / qy);
 
-            if (verts && verts.length) {
-                var ind_v0 = ((size + 1) * indY + indX) * 3;
-                var ind_v2 = ((size + 1) * (indY + 1) + indX) * 3;
+            let ind_v0 = ((size + 1) * indY + indX) * 3;
+            let ind_v2 = ((size + 1) * (indY + 1) + indX) * 3;
 
-                _v0.set(verts[ind_v0], verts[ind_v0 + 1], verts[ind_v0 + 2]);
-                _v1.set(verts[ind_v0 + 3], verts[ind_v0 + 4], verts[ind_v0 + 5]);
-                _v2.set(verts[ind_v2], verts[ind_v2 + 1], verts[ind_v2 + 2]);
+            _v0.set(verts[ind_v0], verts[ind_v0 + 1], verts[ind_v0 + 2]);
+            _v1.set(verts[ind_v0 + 3], verts[ind_v0 + 4], verts[ind_v0 + 5]);
+            _v2.set(verts[ind_v2], verts[ind_v2 + 1], verts[ind_v2 + 2]);
 
-                let d = _ray.hitTriangle(_v0, _v1, _v2, res, normal);
+            let d = _ray.hitTriangle(_v0, _v1, _v2, res);
 
+            if (d === Ray.INSIDE) {
+                return xyz.distance(res);
+            } else if (d === Ray.AWAY) {
+                _rayEx.set(xyz, norm);
+                let d = _rayEx.hitTriangle(_v0, _v1, _v2, res);
                 if (d === Ray.INSIDE) {
-                    return xyz.distance(res);
-                } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, xyz);
-                    let d = _rayEx.hitTriangle(_v0, _v1, _v2, res, normal);
-                    if (d === Ray.INSIDE) {
-                        return -xyz.distance(res);
-                    }
+                    return -xyz.distance(res);
                 }
+            }
 
-                _v3.set(verts[ind_v2 + 3], verts[ind_v2 + 4], verts[ind_v2 + 5]);
+            _v3.set(verts[ind_v2 + 3], verts[ind_v2 + 4], verts[ind_v2 + 5]);
 
-                d = _ray.hitTriangle(_v1, _v3, _v2, res, normal);
+            d = _ray.hitTriangle(_v1, _v3, _v2, res);
+            if (d === Ray.INSIDE) {
+                return xyz.distance(res);
+            } else if (d === Ray.AWAY) {
+                _rayEx.set(xyz, norm);
+                let d = _rayEx.hitTriangle(_v1, _v3, _v2, res);
                 if (d === Ray.INSIDE) {
-                    return xyz.distance(res);
-                } else if (d === Ray.AWAY) {
-                    _rayEx.set(xyz, xyz);
-                    let d = _rayEx.hitTriangle(_v1, _v3, _v2, res, normal);
-                    if (d === Ray.INSIDE) {
-                        return -xyz.distance(res);
-                    }
-                }
-
-                if (d === Ray.AWAY) {
                     return -xyz.distance(res);
                 }
+            }
 
-                return xyz.distance(res);
+            if (d === Ray.AWAY) {
+                return -xyz.distance(res);
             }
 
-            res.copy(this.planet.ellipsoid.hitRay(_ray.origin, _ray.direction));
-            normal && normal.copy(xyz.normal());
             return xyz.distance(res);
         } else {
-            normal && normal.copy(xyz.normal());
             return xyz.distance(this.planet.ellipsoid.hitRay(_ray.origin, _ray.direction));
         }
     }
@@ -1597,7 +1590,7 @@ class Segment {
             shu = sh.uniforms;
 
         var currHeight;
-        if (layerSlice.length) {
+        if (layerSlice && layerSlice.length) {
             currHeight = layerSlice[0]._height;
         } else {
             currHeight = 0;
@@ -1675,4 +1668,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;