@openglobus/og 0.19.0 → 0.19.2

package/lib/js/quadTree/Node.js

@@ -155,9 +155,9 @@ class Node {
         }
         this.state = WALKTHROUGH;
         this.clearNeighbors();
-        for (let i = 0; i < this._fadingNodes.length; i++) {
-            this._fadingNodes[i].neighbors && this._fadingNodes[i].clearNeighbors();
-        }
+        // for (let i = 0; i < this._fadingNodes.length; i++) {
+        //     this._fadingNodes[i].neighbors && this._fadingNodes[i].clearNeighbors();
+        // }
         let seg = this.segment, planet = this.planet;
         this._cameraInside = false;
         // Search a node which the camera is flying over.
@@ -352,22 +352,10 @@ class Node {
         else {
             if (this._fadingNodes.length === 4 && !this.childrenPrevStateEquals(RENDERING)) {
                 this.segment._transitionOpacity = 1.0;
+                this._fadingNodes = [];
             }
             else {
                 this.segment.increaseTransitionOpacity();
-                for (let i = 0; i < this._fadingNodes.length; i++) {
-                    let n = this._fadingNodes[i];
-                    if (n.segment) {
-                        if (n.segment._transitionOpacity > 0 && !this.planet._fadingNodes.has(n.nodeId)) {
-                            this.planet._fadingNodes.set(n.nodeId, n);
-                            n.segment.fadingTransitionOpacity();
-                        }
-                    }
-                    else {
-                        this.segment._transitionOpacity = 1.0;
-                        break;
-                    }
-                }
             }
         }
     }

package/lib/js/renderer/Renderer.js

@@ -720,7 +720,7 @@ class Renderer {
         this.enableBlendDefault();
         e.dispatch(e.draw, this);
         let frustums = this.activeCamera.frustums;
-        let pointerEvent = e.pointerEvent() || this.activeCamera.isMoving;
+        let pointerEvent = !(e.mouseState.leftButtonDown || e.mouseState.rightButtonDown || this.activeCamera.isMoving) && (e.pointerEvent() /* || this.activeCamera!.isMoving*/);
         // Rendering scene nodes and entityCollections
         let rn = this._renderNodesArr;
         let k = frustums.length;

package/lib/js/scene/Planet.js

@@ -1059,28 +1059,36 @@ export class Planet extends RenderNode {
         let transparentSegments = [];
         let isEq = this.terrain.equalizeVertices;
         let i = renderedNodes.length;
-        let _renderingFadingNodes = this._renderingFadingNodes;
-        if (cam.slope > 0.78 || cam.getAltitude() > 10000) {
-            _renderingFadingNodes = this._renderingFadingNodesNoDepth;
-        }
-        while (i--) {
-            let ri = renderedNodes[i];
-            let s = ri.segment;
-            _renderingFadingNodes(nodes, sh, ri, sl[0], 0, transparentSegments);
-            if (s._transitionOpacity < 1) {
-                transparentSegments.push(s);
-            }
-            else {
+        if (cam.slope > 0.8 /*|| cam.getAltitude() > 10000*/) {
+            while (i--) {
+                let ri = renderedNodes[i];
+                let s = ri.segment;
+                this._renderingFadingNodesNoDepth(nodes, sh, ri, sl[0], 0);
                 isEq && s.equalize();
                 s.readyToEngage && s.engage();
                 s.screenRendering(sh, sl[0], 0);
             }
         }
-        for (let j = 0; j < transparentSegments.length; j++) {
-            let tj = transparentSegments[j];
-            isEq && tj.equalize();
-            tj.readyToEngage && tj.engage();
-            tj.screenRendering(sh, sl[0], 0);
+        else {
+            while (i--) {
+                let ri = renderedNodes[i];
+                let s = ri.segment;
+                this._renderingFadingNodes(nodes, sh, ri, sl[0], 0, transparentSegments);
+                if (s._transitionOpacity < 1) {
+                    transparentSegments.push(s);
+                }
+                else {
+                    isEq && s.equalize();
+                    s.readyToEngage && s.engage();
+                    s.screenRendering(sh, sl[0], 0);
+                }
+            }
+            for (let j = 0; j < transparentSegments.length; j++) {
+                let tj = transparentSegments[j];
+                isEq && tj.equalize();
+                tj.readyToEngage && tj.engage();
+                tj.screenRendering(sh, sl[0], 0);
+            }
         }
     }
     _renderingScreenNodesWithHeight(sh, cam, renderedNodes) {

package/lib/js/segment/Segment.js

@@ -1028,13 +1028,30 @@ class Segment {
         //this._transitionOpacity += 0.01;
         this._transitionOpacity += (window.performance.now() - this._transitionTimestamp) / this.planet.transitionTime;
         this._transitionTimestamp = window.performance.now();
-        if (this._transitionOpacity > 1.0) {
-            this._transitionOpacity = 1.0;
+        if (this._transitionOpacity > 2.0) {
+            this._transitionOpacity = 2.0;
+        }
+        let i = this.node._fadingNodes.length;
+        while (i--) {
+            let n = this.node._fadingNodes[i];
+            if (n.segment) {
+                if (n.segment._transitionOpacity > 0 && !this.planet._fadingNodes.has(n.nodeId)) {
+                    this.planet._fadingNodes.set(n.nodeId, n);
+                    n.segment._transitionOpacity = 2.0 - this._transitionOpacity;
+                    if (n.segment._transitionOpacity === 0) {
+                        this.node._fadingNodes.splice(i, 1);
+                    }
+                }
+            }
+            else {
+                this._transitionOpacity = 1.0;
+                break;
+            }
         }
     }
     fadingTransitionOpacity() {
-        //this._transitionOpacity -= 0.01;
-        this._transitionOpacity -= (window.performance.now() - this._transitionTimestamp) / this.planet.transitionTime;
+        this._transitionOpacity -= 0.01;
+        // this._transitionOpacity -= (window.performance.now() - this._transitionTimestamp) / this.planet.transitionTime;
         this._transitionTimestamp = window.performance.now();
         if (this._transitionOpacity < 0.0) {
             this._transitionOpacity = 0;

package/lib/js/shaders/geoObject.js

@@ -38,7 +38,6 @@ export const geo_object = () => new Program("geo_object", {
             attribute float aUseTexture;
             attribute vec2 aTexCoord;
             
-            uniform float uUseTexture;
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
@@ -51,20 +50,31 @@ export const geo_object = () => new Program("geo_object", {
             varying vec3 v_vertex;           
             varying vec4 vColor;
             varying float vDispose;
-            varying float vUseTexture;
             varying vec2 vTexCoords;
+            varying float useLighting;
             
             const float PI = 3.141592653589793;
             
             const float RADIANS = PI / 180.0;
            
             void main(void) {
-            
+                        
                 if (aDispose == 0.0) {
                    return;
                 }
+                
+                vec3 position = aPositionHigh + aPositionLow;
+                cameraPosition = eyePositionHigh + eyePositionLow;
+                
+                vec3 look = cameraPosition - position;
+                float lookLength = length(look);
+
+                useLighting = 1.0;                
+                if(lookLength > 2000000.0){
+                     useLighting = 0.0;
+                }
+
             
-                vUseTexture = uUseTexture;
                 vColor = aColor;
                 vTexCoords = aTexCoord;
               
@@ -86,8 +96,6 @@ export const geo_object = () => new Program("geo_object", {
                     vec3(0.0, -sin_pitch, cos_pitch) 
                );
 
-                vec3 position = aPositionHigh + aPositionLow;
-                cameraPosition = eyePositionHigh + eyePositionLow;
                 vec3 r = cross(normalize(-position), aDirection);
                 mat3 modelMatrix = mat3(r, normalize(position), -aDirection) * rotX * rotZ;
 
@@ -97,8 +105,6 @@ export const geo_object = () => new Program("geo_object", {
                 vec3 highDiff = aPositionHigh - eyePositionHigh;
                 vec3 lowDiff = aPositionLow - eyePositionLow;
              
-                vec3 look = cameraPosition - position;
-                float lookLength = length(look);
                 vNormal = modelMatrix * aVertexNormal;
                                
                 // if(lookLength > uScaleByDistance[1])
@@ -127,28 +133,34 @@ export const geo_object = () => new Program("geo_object", {
                 
                 uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
                 uniform vec3 lightsParamsv[MAX_POINT_LIGHTS * 3];
-                uniform float lightsParamsf[MAX_POINT_LIGHTS];                
+                uniform float lightsParamsf[MAX_POINT_LIGHTS];
                 uniform sampler2D uTexture;
-                
+                uniform float uUseTexture;
+                            
                 varying vec3 cameraPosition;
                 varying vec3 v_vertex;                
                 varying vec4 vColor;
                 varying vec3 vNormal;
                 varying vec2 vTexCoords;
-                varying float vUseTexture;
+                varying float useLighting;
                 
-                void main(void) {                
-                    vec3 normal = normalize(vNormal);
+                void main(void) {        
+                                        
+                    vec3 lightWeighting = vec3(1.0);
                 
-                    vec3 lightDir = normalize(lightsPositions[0]);
-                    vec3 viewDir = normalize(cameraPosition - v_vertex);                
-                    vec3 reflectionDirection = reflect(-lightDir, normal);
-                    float reflection = max( dot(reflectionDirection, viewDir), 0.0);
-                    float specularLightWeighting = pow( reflection, lightsParamsf[0]);                                        
-                    float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);
-                    vec3 lightWeighting = lightsParamsv[0] + lightsParamsv[1] * diffuseLightWeighting + lightsParamsv[2] * specularLightWeighting;
-                    vec4 tColor = texture2D(uTexture, vTexCoords);
-                    if(vUseTexture > 0.0){
+                    if(useLighting != 0.0){
+                        vec3 normal = normalize(vNormal);
+                        vec3 lightDir = normalize(lightsPositions[0]);
+                        vec3 viewDir = normalize(cameraPosition - v_vertex);                
+                        vec3 reflectionDirection = reflect(-lightDir, normal);
+                        float reflection = max( dot(reflectionDirection, viewDir), 0.0);
+                        float specularLightWeighting = pow( reflection, lightsParamsf[0]);                                        
+                        float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);
+                        lightWeighting = lightsParamsv[0] + lightsParamsv[1] * diffuseLightWeighting + lightsParamsv[2] * specularLightWeighting;
+                    }
+                                       
+                    if(uUseTexture > 0.0) {
+                        vec4 tColor = texture2D(uTexture, vTexCoords);
                         gl_FragColor = vec4(tColor.rgb * lightWeighting, tColor.a);
                     } else {
                         gl_FragColor = vec4(vColor.rgb * lightWeighting, vColor.a);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openglobus/og",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "description": "[openglobus](https://www.openglobus.org/) is a javascript/typescript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers, and 3D objects. It uses the WebGL technology, open source, and completely free.",
   "directories": {
     "example": "./sandbox"