@openglobus/og 0.19.2 → 0.19.3

package/lib/js/control/KeyboardNavigation.js

@@ -54,19 +54,19 @@ export class KeyboardNavigation extends Control {
     }
     onCameraMoveForward() {
         let cam = this.planet.camera;
-        cam.slide(0, 0, -cam._lonLat.height / this.step);
+        cam.slide(0, 0, -cam.getAltitude() / this.step);
     }
     onCameraMoveBackward() {
         let cam = this.planet.camera;
-        cam.slide(0, 0, cam._lonLat.height / this.step);
+        cam.slide(0, 0, cam.getAltitude() / this.step);
     }
     onCameraStrifeLeft() {
         let cam = this.planet.camera;
-        cam.slide(-cam._lonLat.height / this.step, 0, 0);
+        cam.slide(-cam.getAltitude() / this.step, 0, 0);
     }
     onCameraStrifeRight() {
         let cam = this.planet.camera;
-        cam.slide(cam._lonLat.height / this.step, 0, 0);
+        cam.slide(cam.getAltitude() / this.step, 0, 0);
     }
     onCameraLookUp() {
         let cam = this.planet.camera;
@@ -74,7 +74,7 @@ export class KeyboardNavigation extends Control {
             cam.pitch(15 / this.renderer.handler.deltaTime);
         }
         else {
-            cam.rotateVertical((cam._lonLat.height / 3000000) * math.RADIANS, Vec3.ZERO);
+            cam.rotateVertical((cam.getAltitude() / 3000000) * math.RADIANS, Vec3.ZERO);
         }
     }
     onCameraLookDown() {
@@ -83,7 +83,7 @@ export class KeyboardNavigation extends Control {
             cam.pitch(-15 / this.renderer.handler.deltaTime);
         }
         else {
-            cam.rotateVertical((-cam._lonLat.height / 3000000) * math.RADIANS, Vec3.ZERO);
+            cam.rotateVertical((-cam.getAltitude() / 3000000) * math.RADIANS, Vec3.ZERO);
         }
     }
     onCameraLookLeft() {
@@ -92,7 +92,7 @@ export class KeyboardNavigation extends Control {
             cam.roll(15 / this.renderer.handler.deltaTime);
         }
         else {
-            cam.rotateHorizontal((cam._lonLat.height / 3000000) * math.RADIANS);
+            cam.rotateHorizontal((cam.getAltitude() / 3000000) * math.RADIANS);
         }
     }
     onCameraLookRight() {
@@ -101,7 +101,7 @@ export class KeyboardNavigation extends Control {
             cam.roll(-15 / this.renderer.handler.deltaTime);
         }
         else {
-            cam.rotateHorizontal((-cam._lonLat.height / 3000000) * math.RADIANS);
+            cam.rotateHorizontal((-cam.getAltitude() / 3000000) * math.RADIANS);
         }
     }
     onCameraTurnLeft() {
@@ -110,7 +110,7 @@ export class KeyboardNavigation extends Control {
             cam.yaw(15 / this.renderer.handler.deltaTime);
         }
         else {
-            cam.rotateHorizontal((cam._lonLat.height / 3000000) * math.RADIANS);
+            cam.rotateHorizontal((cam.getAltitude() / 3000000) * math.RADIANS);
         }
     }
     onCameraTurnRight() {
@@ -119,7 +119,7 @@ export class KeyboardNavigation extends Control {
             cam.yaw(-15 / this.renderer.handler.deltaTime);
         }
         else {
-            cam.rotateHorizontal((-cam._lonLat.height / 3000000) * math.RADIANS, false, Vec3.ZERO);
+            cam.rotateHorizontal((-cam.getAltitude() / 3000000) * math.RADIANS, false, Vec3.ZERO);
         }
     }
     // from CompassButton._onClick()

package/lib/js/control/MouseNavigation.js

@@ -275,10 +275,13 @@ export class MouseNavigation extends Control {
         const cam = this.planet.camera;
         if (this.pointOnEarth && e.moving) {
             this.renderer.controlsBag.scaleRot = 1.0;
-            let l = (0.5 / cam.eye.distance(this.pointOnEarth)) * (cam._lonLat.height < 5.0 ? 5.0 : cam._lonLat.height) * math.RADIANS;
+            let l = (0.5 / cam.eye.distance(this.pointOnEarth)) * cam._lonLat.height * math.RADIANS;
             if (l > 0.007) {
                 l = 0.007;
             }
+            else if (l < 0.003) {
+                l = 0.003;
+            }
             cam.rotateHorizontal(l * (e.x - e.prev_x), false, this.pointOnEarth, this.earthUp);
             cam.rotateVertical(l * (e.y - e.prev_y), this.pointOnEarth, this.minSlope);
         }
@@ -303,13 +306,6 @@ export class MouseNavigation extends Control {
             if (this.stepIndex) {
                 r.controlsBag.scaleRot = 1.0;
                 const sf = this.stepsForward[this.stepsCount - this.stepIndex--];
-                let maxAlt = cam.maxAltitude + this.planet.ellipsoid.polarSize;
-                let minAlt = cam.minAltitude + this.planet.ellipsoid.polarSize;
-                const camAlt = sf.eye.length();
-                if (camAlt > maxAlt || camAlt < minAlt && this._wheelDirection > 0) {
-                    this._wheelDirection = +1;
-                    return;
-                }
                 cam.eye = sf.eye;
                 cam._u = sf.v;
                 cam._r = sf.u;

package/lib/js/ellipsoid/Ellipsoid.d.ts

@@ -145,6 +145,12 @@ declare class Ellipsoid {
      * @returns {LonLat} - Destination point coordinates
      */
     getGreatCircleDestination(lonLat: LonLat, azimuth: number, dist: number): LonLat;
+    /**
+     * Returns inverse Geodesic solution for two points
+     * @param {LonLat} lonLat1 - start coordinates point
+     * @param {LonLat} lonLat2 - end coordinates point
+     * @returns {IInverseResult} - Contains distance, initialAzimuth, and finalAzimuth values
+     */
     inverse(lonLat1: LonLat, lonLat2: LonLat): IInverseResult;
     /**
      * Calculates the destination point given start point lat / lon, azimuth(deg) and distance (m).
@@ -153,7 +159,7 @@ declare class Ellipsoid {
      * @param {LonLat} lonLat - Origin coordinates
      * @param {number} azimuth - View azimuth in degrees
      * @param {number} dist - Distance to the destination point coordinates in meters
-     * @returns {LonLat} - Destination point coordinates
+     * @returns {{ destination: LonLat; finalAzimuth: number }} - Destination point coordinates
      */
     direct(lonLat: LonLat, azimuth: number, dist: number): IDirectResult;
     /**

package/lib/js/ellipsoid/Ellipsoid.js

@@ -229,6 +229,12 @@ class Ellipsoid {
     getGreatCircleDestination(lonLat, azimuth, dist) {
         return this.direct(lonLat, azimuth, dist).destination;
     }
+    /**
+     * Returns inverse Geodesic solution for two points
+     * @param {LonLat} lonLat1 - start coordinates point
+     * @param {LonLat} lonLat2 - end coordinates point
+     * @returns {IInverseResult} - Contains distance, initialAzimuth, and finalAzimuth values
+     */
     inverse(lonLat1, lonLat2) {
         let a = this._a, b = this._b, f = this._flattening;
         const fi1 = lonLat1.lat * RADIANS, lambda1 = lonLat1.lon * RADIANS;
@@ -282,7 +288,7 @@ class Ellipsoid {
      * @param {LonLat} lonLat - Origin coordinates
      * @param {number} azimuth - View azimuth in degrees
      * @param {number} dist - Distance to the destination point coordinates in meters
-     * @returns {LonLat} - Destination point coordinates
+     * @returns {{ destination: LonLat; finalAzimuth: number }} - Destination point coordinates
      */
     direct(lonLat, azimuth, dist) {
         let lon1 = lonLat.lon, lat1 = lonLat.lat;

package/lib/js/quadTree/Node.js

@@ -7,7 +7,7 @@ import { MAX, MIN } from "../math";
 import { MAX_LAT } from "../mercator";
 import { Vec2 } from "../math/Vec2";
 import { Vec3 } from "../math/Vec3";
-import { E, MAX_RENDERED_NODES, N, NE, NEIGHBOUR, NOTRENDERING, NW, OPPART, OPSIDE, PARTOFFSET, RENDERING, S, SE, SW, VISIBLE_DISTANCE, W, WALKTHROUGH } from "./quadTree";
+import { E, MAX_RENDERED_NODES, N, NE, NEIGHBOUR, NOTRENDERING, NW, OPPART, OPSIDE, PARTOFFSET, RENDERING, S, SE, SW, W, WALKTHROUGH } from "./quadTree";
 import { TILEGROUP_COMMON, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "../segment/Segment";
 let _tempHigh = new Vec3(), _tempLow = new Vec3();
 const _vertOrder = [
@@ -202,15 +202,17 @@ class Node {
         }
         if (this.inFrustum || this._cameraInside || seg.tileZoom < 3) {
             let h = Math.abs(cam._lonLat.height);
-            let eye = cam.eye;
-            let horizonDist = eye.length2() - this.planet.ellipsoid.polarSizeSqr;
-            let altVis = seg.tileZoom > 19 || (seg.tileZoom < 5 && !seg.terrainReady) || seg.tileZoom < 2;
-            if (h > 21000) {
-                altVis = altVis || eye.distance2(seg._sw) < horizonDist || eye.distance2(seg._nw) < horizonDist || eye.distance2(seg._ne) < horizonDist || eye.distance2(seg._se) < horizonDist;
-            }
-            else {
-                altVis = altVis || cam.eye.distance(seg.bsphere.center) - seg.bsphere.radius < VISIBLE_DISTANCE * Math.sqrt(h);
-            }
+            let horizonDist = cam.eye.length2() - this.planet.ellipsoid.polarSizeSqr;
+            horizonDist = horizonDist < 106876472875.63281 * planet._heightFactor ? 106876472875.63281 * planet._heightFactor : horizonDist;
+            let altVis = seg.tileZoom < 2 || seg.tileZoom > 19 ||
+                /* Could be replaced with camera frustum always looking down check,
+                and not to go througn nodes from the oppositeside of the globe*/
+                (seg.tileZoom < 5 && !seg.terrainReady);
+            altVis = altVis ||
+                cam.eye.distance2(seg._sw) < horizonDist ||
+                cam.eye.distance2(seg._nw) < horizonDist ||
+                cam.eye.distance2(seg._ne) < horizonDist ||
+                cam.eye.distance2(seg._se) < horizonDist;
             if ((this.inFrustum && (altVis || h > 10000.0)) || this._cameraInside) {
                 //@todo: replace to the strategy
                 seg._collectVisibleNodes();
@@ -218,7 +220,8 @@ class Node {
             if (seg.tileZoom < 2) {
                 this.traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading, zoomPassNode);
             }
-            else if (seg.terrainReady && (!maxZoom && cam.projectedSize(seg.bsphere.center, seg._plainRadius) < planet.lodSize || maxZoom && ((seg.tileZoom === maxZoom) || !altVis))) {
+            else if (seg.terrainReady && (!maxZoom && cam.projectedSize(seg.bsphere.center, seg._plainRadius) < planet.lodSize
+                || maxZoom && ((seg.tileZoom === maxZoom) || !altVis))) {
                 if (altVis) {
                     seg.passReady = true;
                     this.renderNode(this.inFrustum, !this.inFrustum, terrainReadySegment, stopLoading);
@@ -476,60 +479,6 @@ class Node {
         }
         return -1;
     }
-    // // TODO: test test test
-    // public ___getCommonSide___(b: Node) {
-    //     let a = this, as = a.segment, bs = b.segment;
-    //
-    //     if (as.tileZoom === bs.tileZoom) {
-    //         return as.getNeighborSide(bs);
-    //     } else if (as.tileZoom > bs.tileZoom) {
-    //         let dz = as.tileZoom - bs.tileZoom, i = dz, p: Node = this;
-    //
-    //         while (i--) {
-    //             p = p.parentNode!;
-    //         }
-    //
-    //         let side = p.segment.getNeighborSide(bs);
-    //
-    //         if (side !== -1) {
-    //             i = dz;
-    //             p = this;
-    //             let _n = true;
-    //
-    //             while (i--) {
-    //                 _n = _n && COMSIDE[p.partId][side];
-    //             }
-    //
-    //             if (_n) {
-    //                 return side;
-    //             }
-    //         }
-    //     } else {
-    //         let dz = bs.tileZoom - as.tileZoom, i = dz, p = b;
-    //
-    //         while (i--) {
-    //             p = p.parentNode!;
-    //         }
-    //
-    //         let side = p.segment.getNeighborSide(as);
-    //
-    //         if (side !== -1) {
-    //             i = dz;
-    //             p = b;
-    //             let _n = true;
-    //
-    //             while (i--) {
-    //                 _n = _n && COMSIDE[p.partId][side];
-    //             }
-    //
-    //             if (_n) {
-    //                 return OPSIDE[side];
-    //             }
-    //         }
-    //     }
-    //
-    //     return -1;
-    // }
     whileNormalMapCreating() {
         const seg = this.segment;
         if (!seg.terrainIsLoading && seg.terrainExists && !seg._inTheQueue) {

package/lib/js/renderer/Renderer.js

@@ -720,7 +720,8 @@ class Renderer {
         this.enableBlendDefault();
         e.dispatch(e.draw, this);
         let frustums = this.activeCamera.frustums;
-        let pointerEvent = !(e.mouseState.leftButtonDown || e.mouseState.rightButtonDown || this.activeCamera.isMoving) && (e.pointerEvent() /* || this.activeCamera!.isMoving*/);
+        let pointerEvent = e.pointerEvent();
+        let mouseHold = e.mouseState.leftButtonDown || e.mouseState.rightButtonDown;
         // Rendering scene nodes and entityCollections
         let rn = this._renderNodesArr;
         let k = frustums.length;
@@ -740,21 +741,21 @@ class Renderer {
             this._drawTransparentEntityCollections();
             this._clearEntityCollectionQueue();
             e.dispatch(e.drawtransparent, this);
-            if (pointerEvent) {
+            if (pointerEvent && !mouseHold) {
                 this._drawPickingBuffer();
-                this.__useDistanceFramebuffer__ && this._drawDistanceBuffer();
             }
+            this.__useDistanceFramebuffer__ && this._drawDistanceBuffer();
         }
         sceneFramebuffer.deactivate();
         this.blitFramebuffer && sceneFramebuffer.blitTo(this.blitFramebuffer, 0);
         if (pointerEvent) {
-            // It works ONLY for 0 (closest) frustum
             if (h.isWebGl2()) {
+                // It works ONLY for 0 (closest) frustum
                 this._drawDepthBuffer();
             }
             this._readPickingBuffer();
-            this.__useDistanceFramebuffer__ && this._readDistanceBuffer();
         }
+        this.__useDistanceFramebuffer__ && this._readDistanceBuffer();
         // Tone mapping followed by rendering on the screen
         this._fnScreenFrame();
         e.dispatch(e.postdraw, this);

package/lib/js/segment/Segment.d.ts

@@ -228,6 +228,7 @@ declare class Segment {
      * @todo: looks like it could be simplified in Segment contructor
      */
     _setExtentLonLat(): void;
+    protected _createExtentNormals(): void;
     createBoundsByExtent(): void;
     createBoundsByParent(): void;
     setBoundingSphere(x: number, y: number, z: number, v: Vec3): void;

package/lib/js/segment/Segment.js

@@ -283,7 +283,8 @@ class Segment {
             this.node.equalizedSideWithNodeId[neighborSide] !== neigborNode.equalizedSideWithNodeId[OPSIDE[neighborSide]];
     }
     equalize() {
-        if (this.tileZoom < 8 || this.gridSize < 2) {
+        // Equalization doesnt work correctly for gridSize equals 2
+        if (this.gridSize < 2) {
             return;
         }
         this.readyToEngage = true;
@@ -621,7 +622,7 @@ class Segment {
     _setExtentLonLat() {
         this._extentLonLat = this._extent.inverseMercator();
     }
-    createBoundsByExtent() {
+    _createExtentNormals() {
         const ellipsoid = this.planet.ellipsoid;
         const extent = this._extentLonLat;
         const coord_sw = ellipsoid.geodeticToCartesian(extent.southWest.lon, extent.southWest.lat);
@@ -632,7 +633,10 @@ class Segment {
         this._nw.copy(coord_nw);
         this._ne.copy(coord_ne);
         this._se.copy(coord_se);
-        this.setBoundingVolume3v(coord_sw, coord_ne);
+    }
+    createBoundsByExtent() {
+        this._createExtentNormals();
+        this.setBoundingVolume3v(this._sw, this._ne);
     }
     createBoundsByParent() {
         let pn = this.node;
@@ -694,6 +698,7 @@ class Segment {
                 else {
                     coords_rb = Vec3.add(vs.scaleTo(1 - vi_x / insideSize), ve.scaleTo(1 - vi_y / insideSize)).addA(v_rb);
                 }
+                this._createExtentNormals();
                 this.setBoundingVolume3v(coords_lt, coords_rb);
             }
         }

package/lib/js/shaders/drawnode.js

@@ -219,10 +219,10 @@ export function drawnode_screen_wl_webgl1NoAtmos() {
                 float maxH = minH * 3.0;
                 float nightCoef = getLerpValue(minH, maxH, camHeight) * nightTextureCoefficient;
                                 
-                if(camHeight > 6000000.0)
-                {
-                    normal = normalize(v_vertex);
-                }
+                // if(camHeight > 6000000.0)
+                // {
+                //     normal = normalize(v_vertex);
+                // }
                                             
                 vec3 lightDir = normalize(sunPos);
                 vec3 viewDir = normalize(cameraPosition - v_vertex);
@@ -406,10 +406,10 @@ export function drawnode_screen_wl_webgl2NoAtmos() {
                 float maxH = minH * 3.0;
                 float nightCoef = getLerpValue(minH, maxH, camHeight) * nightTextureCoefficient;
                                 
-                if(camHeight > 6000000.0)
-                {
-                    normal = normalize(v_vertex);
-                }
+                // if(camHeight > 6000000.0)
+                // {
+                //     normal = normalize(v_vertex);
+                // }
                                             
                 vec3 lightDir = normalize(sunPos);
                 vec3 viewDir = normalize(cameraPosition - v_vertex);
@@ -661,8 +661,12 @@ export function drawnode_screen_wl_webgl2Atmos() {
                 bool hitGround = intersectSphere(camPos, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;                
                 
                 // Fix black dots on the edge of atmosphere                        
-                if(camHeight < 700000.0 || !hitGround)
-                {                          
+                // if(camHeight < 700000.0 || !hitGround)
+                // {                          
+                //     distanceToGround = distance(camPos, v_vertex * SPHERE_TO_ELLIPSOID_SCALE);
+                // }
+                
+                if(length(v_vertex * SPHERE_TO_ELLIPSOID_SCALE) > BOTTOM_RADIUS){
                     distanceToGround = distance(camPos, v_vertex * SPHERE_TO_ELLIPSOID_SCALE);
                 }
                                                                 
@@ -725,10 +729,10 @@ export function drawnode_screen_wl_webgl2Atmos() {
                 float maxH = minH * 3.0;
                 float nightCoef = getLerpValue(minH, maxH, camHeight) * nightTextureCoefficient;
                                 
-                if(camHeight > 6000000.0)
-                {
-                    normal = normalize(v_vertex);
-                }
+                // if(camHeight > 6000000.0)
+                // {
+                //    normal = normalize(v_vertex);
+                // }
                                             
                 vec3 lightDir = normalize(sunPos);
                 vec3 viewDir = normalize(cameraPosition - v_vertex);

package/lib/js/shaders/geoObject.js

@@ -51,7 +51,7 @@ export const geo_object = () => new Program("geo_object", {
             varying vec4 vColor;
             varying float vDispose;
             varying vec2 vTexCoords;
-            varying float useLighting;
+            //varying float useLighting;
             
             const float PI = 3.141592653589793;
             
@@ -69,10 +69,10 @@ export const geo_object = () => new Program("geo_object", {
                 vec3 look = cameraPosition - position;
                 float lookLength = length(look);
 
-                useLighting = 1.0;                
-                if(lookLength > 2000000.0){
-                     useLighting = 0.0;
-                }
+                // useLighting = 1.0;                
+                // if(lookLength > 2000000.0){
+                //      useLighting = 0.0;
+                // }
 
             
                 vColor = aColor;
@@ -142,13 +142,13 @@ export const geo_object = () => new Program("geo_object", {
                 varying vec4 vColor;
                 varying vec3 vNormal;
                 varying vec2 vTexCoords;
-                varying float useLighting;
+                //varying float useLighting;
                 
                 void main(void) {        
                                         
                     vec3 lightWeighting = vec3(1.0);
                 
-                    if(useLighting != 0.0){
+                    //if(useLighting != 0.0){
                         vec3 normal = normalize(vNormal);
                         vec3 lightDir = normalize(lightsPositions[0]);
                         vec3 viewDir = normalize(cameraPosition - v_vertex);                
@@ -157,7 +157,7 @@ export const geo_object = () => new Program("geo_object", {
                         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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openglobus/og",
-  "version": "0.19.2",
+  "version": "0.19.3",
   "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"