@openglobus/og 0.19.2 → 0.19.4

package/lib/js/Object3d.d.ts

@@ -1,5 +1,5 @@
 import { TypedArray } from './utils/shared';
-import { NumberArray3 } from './math/Vec3';
+import { NumberArray3, Vec3 } from './math/Vec3';
 interface IObject3dParams {
     name?: string;
     vertices?: number[];
@@ -41,6 +41,14 @@ declare class Object3d {
     static getNormals(vertices: number[]): number[];
     static createSphere(lonBands?: number, latBands?: number, radius?: number, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
     static createDisc(radius?: number, height?: number, radialSegments?: number, isTop?: boolean, startIndex?: number, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
+    /**
+     * Returns scale parameters for a frustum geoObject created with only Object3d.createFrustum();
+     * @param length
+     * @param horizontalAngle
+     * @param verticalAngle
+     */
+    static getFrustumScaleByCameraParams(length: number, horizontalAngle: number, verticalAngle: number): Vec3;
+    static createFrustum(length?: number, width?: number, height?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createCylinder(radiusTop?: number, radiusBottom?: number, height?: number, radialSegments?: number, heightSegments?: number, isTop?: boolean, isBottom?: boolean, offsetX?: number, offsetY?: number, offsetZ?: number): Object3d;
     static createCube(length?: number, height?: number, depth?: number, xOffset?: number, yOffset?: number, zOffset?: number): Object3d;
     static createArrow(back?: number, height?: number, front?: number): Object3d;

package/lib/js/Object3d.js

@@ -1,6 +1,6 @@
 import { htmlColorToFloat32Array } from './utils/shared';
 import { Vec3 } from './math/Vec3';
-import { MAX, MIN } from './math';
+import { MAX, MIN, RADIANS_HALF } from './math';
 import { transformLeftToRightCoordinateSystem, objParser } from "./utils/objParser";
 function getColor(color) {
     if (color instanceof Array) {
@@ -219,6 +219,61 @@ class Object3d {
             'vertices': vertices, 'normals': normals, 'indices': indices
         });
     }
+    /**
+     * Returns scale parameters for a frustum geoObject created with only Object3d.createFrustum();
+     * @param length
+     * @param horizontalAngle
+     * @param verticalAngle
+     */
+    static getFrustumScaleByCameraParams(length, horizontalAngle, verticalAngle) {
+        return new Vec3(2.0 * length * Math.tan(RADIANS_HALF * horizontalAngle), 2.0 * length * Math.tan(RADIANS_HALF * verticalAngle), length);
+    }
+    static createFrustum(length = 1, width = 1, height = 1, xOffset = 0, yOffset = 0, zOffset = 0) {
+        width *= 0.5;
+        height *= 0.5;
+        return new Object3d({
+            vertices: [
+                //
+                //inside
+                //
+                //top
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                -1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                //bottop
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                -1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                //right
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                //left
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                -1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                -1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                //
+                // outside
+                //
+                //top
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                -1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                //bottop
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                -1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                //right
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset,
+                1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                //left
+                0 + xOffset, 0 + yOffset, 0 + zOffset,
+                -1 * width + xOffset, 1 * height + yOffset, -1 * length + zOffset,
+                -1 * width + xOffset, -1 * height + yOffset, -1 * length + zOffset
+            ]
+        });
+    }
     static createCylinder(radiusTop = 1.0, radiusBottom = 1.0, height = 1.0, radialSegments = 32, heightSegments = 1.0, isTop = true, isBottom = true, offsetX = 0, offsetY = 0, offsetZ = 0) {
         let vertices = [], indices = [], normals = [];
         let thetaStart = 0.0, thetaLength = Math.PI * 2;

package/lib/js/astro/jd.js

@@ -385,32 +385,32 @@ function __ls(jd, leapSeconds) {
     };
 }
 const leapSecondsTable = [
-    __ls(2441317.5, 10.0),
-    __ls(2441499.5, 11.0),
-    __ls(2441683.5, 12.0),
-    __ls(2442048.5, 13.0),
-    __ls(2442413.5, 14.0),
-    __ls(2442778.5, 15.0),
-    __ls(2443144.5, 16.0),
-    __ls(2443509.5, 17.0),
-    __ls(2443874.5, 18.0),
-    __ls(2444239.5, 19.0),
-    __ls(2444786.5, 20.0),
-    __ls(2445151.5, 21.0),
-    __ls(2445516.5, 22.0),
-    __ls(2446247.5, 23.0),
-    __ls(2447161.5, 24.0),
-    __ls(2447892.5, 25.0),
-    __ls(2448257.5, 26.0),
-    __ls(2448804.5, 27.0),
-    __ls(2449169.5, 28.0),
-    __ls(2449534.5, 29.0),
-    __ls(2450083.5, 30.0),
-    __ls(2450630.5, 31.0),
-    __ls(2451179.5, 32.0),
-    __ls(2453736.5, 33.0),
-    __ls(2454832.5, 34.0),
-    __ls(2456109.5, 35.0),
+    __ls(2441317.5, 10.0), // 1972-01-01T00:00:00.000Z
+    __ls(2441499.5, 11.0), // 1972-07-01T00:00:00.000Z
+    __ls(2441683.5, 12.0), // 1973-01-01T00:00:00.000Z
+    __ls(2442048.5, 13.0), // 1974-01-01T00:00:00.000Z
+    __ls(2442413.5, 14.0), // 1975-01-01T00:00:00.000Z
+    __ls(2442778.5, 15.0), // 1976-01-01T00:00:00.000Z
+    __ls(2443144.5, 16.0), // 1977-01-01T00:00:00.000Z
+    __ls(2443509.5, 17.0), // 1978-01-01T00:00:00.000Z
+    __ls(2443874.5, 18.0), // 1979-01-01T00:00:00.000Z
+    __ls(2444239.5, 19.0), // 1980-01-01T00:00:00.000Z
+    __ls(2444786.5, 20.0), // 1981-07-01T00:00:00.000Z
+    __ls(2445151.5, 21.0), // 1982-07-01T00:00:00.000Z
+    __ls(2445516.5, 22.0), // 1983-01-01T00:00:00.000Z
+    __ls(2446247.5, 23.0), // 1985-07-01T00:00:00.000Z
+    __ls(2447161.5, 24.0), // 1988-01-01T00:00:00.000Z
+    __ls(2447892.5, 25.0), // 1990-01-01T00:00:00.000Z
+    __ls(2448257.5, 26.0), // 1991-01-01T00:00:00.000Z
+    __ls(2448804.5, 27.0), // 1992-07-01T00:00:00.000Z
+    __ls(2449169.5, 28.0), // 1993-07-01T00:00:00.000Z
+    __ls(2449534.5, 29.0), // 1994-07-01T00:00:00.000Z
+    __ls(2450083.5, 30.0), // 1996-01-01T00:00:00.000Z
+    __ls(2450630.5, 31.0), // 1997-07-01T00:00:00.000Z
+    __ls(2451179.5, 32.0), // 1999-01-01T00:00:00.000Z
+    __ls(2453736.5, 33.0), // 2006-01-01T00:00:00.000Z
+    __ls(2454832.5, 34.0), // 2009-01-01T00:00:00.000Z
+    __ls(2456109.5, 35.0), // 2012-07-01T00:00:00.000Z
     __ls(2457204.5, 36.0) // 2015-07-01T00:00:00.000Z
 ];
 export const J2000TAI = UTCtoTAI(J2000);

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/control/timeline/timelineUtils.js

@@ -55,38 +55,38 @@ export const SCALES = [
     [10.0, 10],
     [15.0, 15],
     [30.0, 6],
-    [60.0, 12],
-    [120.0, 12],
-    [300.0, 5],
-    [600.0, 10],
-    [900.0, 15],
-    [1800.0, 6],
-    [3600.0, 12],
-    [7200.0, 10],
-    [14400.0, 4],
-    [21600.0, 6],
-    [43200.0, 12],
-    [86400.0, 24],
-    [172800.0, 2],
-    [345600.0, 4],
-    [604800.0, 7],
-    [1296000.0, 15],
-    [2592000.0, 5],
-    [5184000.0, 6],
-    [7776000.0, 9],
-    [15552000.0, 18],
-    [31536000.0, 12],
-    [63072000.0, 2],
-    [126144000.0, 4],
-    [157680000.0, 5],
-    [315360000.0, 10],
-    [630720000.0, 2],
-    [1261440000.0, 4],
-    [1576800000.0, 5],
-    [3153600000.0, 10],
-    [6307200000.0, 2],
-    [12614400000.0, 4],
-    [15768000000.0, 5],
+    [60.0, 12], // 1min
+    [120.0, 12], // 2min
+    [300.0, 5], // 5min
+    [600.0, 10], // 10min
+    [900.0, 15], // 15min
+    [1800.0, 6], // 30min
+    [3600.0, 12], // 1hr
+    [7200.0, 10], // 2hr
+    [14400.0, 4], // 4hr
+    [21600.0, 6], // 6hr
+    [43200.0, 12], // 12hr
+    [86400.0, 24], // 24hr
+    [172800.0, 2], // 2days
+    [345600.0, 4], // 4days
+    [604800.0, 7], // 7days
+    [1296000.0, 15], // 15days
+    [2592000.0, 5], // 30days
+    [5184000.0, 6], // 60days
+    [7776000.0, 9], // 90days
+    [15552000.0, 18], // 180days
+    [31536000.0, 12], // 365days
+    [63072000.0, 2], // 2years
+    [126144000.0, 4], // 4years
+    [157680000.0, 5], // 5years
+    [315360000.0, 10], // 10years
+    [630720000.0, 2], // 20years
+    [1261440000.0, 4], // 40years
+    [1576800000.0, 5], // 50years
+    [3153600000.0, 10], // 100years
+    [6307200000.0, 2], // 200years
+    [12614400000.0, 4], // 400years
+    [15768000000.0, 5], // 500years
     [31536000000.0, 10], // 1000years
 ];
 export function getScale(seconds) {

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/entity/GeoObject.d.ts

@@ -12,7 +12,7 @@ export interface IGeoObjectParams {
     pitch?: number;
     yaw?: number;
     roll?: number;
-    scale?: number;
+    scale?: number | Vec3;
     color?: Vec4 | NumberArray4 | string;
 }
 /**
@@ -43,7 +43,7 @@ declare class GeoObject {
     protected _pitch: number;
     protected _yaw: number;
     protected _roll: number;
-    protected _scale: number;
+    protected _scale: Vec3;
     /**
      * RGBA color.
      * @public
@@ -118,10 +118,15 @@ declare class GeoObject {
      */
     setPosition3v(position: Vec3): void;
     setYaw(yaw: number): void;
+    /**
+     *
+     * @param {number} pitch - Pitch in radians
+     */
     setPitch(pitch: number): void;
     setRoll(roll: number): void;
     setScale(scale: number): void;
-    getScale(): number;
+    setScale3v(scale: Vec3): void;
+    getScale(): Vec3;
     /**
      * Removes geo object from handler.
      * @public

package/lib/js/entity/GeoObject.js

@@ -21,7 +21,7 @@ class GeoObject {
         this._pitch = options.pitch || 0.0;
         this._yaw = options.yaw || 0.0;
         this._roll = options.roll || 0.0;
-        this._scale = options.scale || 1.0;
+        this._scale = utils.createVector3(options.scale, new Vec3(1, 1, 1));
         this._color = utils.createColorRGBA(options.color);
         this._direction = new Vec3(0, 1, 0);
         this._handler = null;
@@ -151,6 +151,10 @@ class GeoObject {
         this._yaw = yaw;
         this.updateDirection();
     }
+    /**
+     *
+     * @param {number} pitch - Pitch in radians
+     */
     setPitch(pitch) {
         this._pitch = pitch;
         this._handler && this._handler.setPitchRollArr(this._tagData, this._tagDataIndex, pitch, this._roll);
@@ -160,7 +164,11 @@ class GeoObject {
         this._handler && this._handler.setPitchRollArr(this._tagData, this._tagDataIndex, this._pitch, roll);
     }
     setScale(scale) {
-        this._scale = scale;
+        this._scale.x = this._scale.y = this._scale.z = scale;
+        this._handler && this._handler.setScaleArr(this._tagData, this._tagDataIndex, this._scale);
+    }
+    setScale3v(scale) {
+        this._scale.copy(scale);
         this._handler && this._handler.setScaleArr(this._tagData, this._tagDataIndex, scale);
     }
     getScale() {

package/lib/js/entity/GeoObjectHandler.d.ts

@@ -85,7 +85,7 @@ declare class GeoObjectHandler {
     setRgbaArr(tagData: InstanceData, tagDataIndex: number, rgba: Vec4): void;
     setPickingColorArr(tagData: InstanceData, tagDataIndex: number, color: Vec3): void;
     setPitchRollArr(tagData: InstanceData, tagDataIndex: number, pitch: number, roll: number): void;
-    setScaleArr(tagData: InstanceData, tagDataIndex: number, scale: number): void;
+    setScaleArr(tagData: InstanceData, tagDataIndex: number, scale: Vec3): void;
     protected _updateTag(dataTag: InstanceData): void;
     update(): void;
     _removeAll(): void;

package/lib/js/entity/GeoObjectHandler.js

@@ -151,10 +151,10 @@ class InstanceData {
         h.setStreamArrayBuffer(this._visibleBuffer, this._visibleArr);
     }
     createSizeBuffer() {
-        let h = this._geoObjectHandler._planet.renderer.handler, numItems = this._sizeArr.length;
+        let h = this._geoObjectHandler._planet.renderer.handler, numItems = this._sizeArr.length / 3;
         if (!this._sizeBuffer || this._sizeBuffer.numItems !== numItems) {
             h.gl.deleteBuffer(this._sizeBuffer);
-            this._sizeBuffer = h.createStreamArrayBuffer(1, numItems);
+            this._sizeBuffer = h.createStreamArrayBuffer(3, numItems);
         }
         this._sizeArr = makeArrayTyped(this._sizeArr);
         h.setStreamArrayBuffer(this._sizeBuffer, this._sizeArr);
@@ -312,12 +312,17 @@ class GeoObjectHandler {
         x = geoObject.getPitch();
         y = geoObject.getRoll();
         tagData._pitchRollArr = concatArrays(tagData._pitchRollArr, setParametersToArray([], 0, itemSize, itemSize, x, y));
-        itemSize = 1;
-        tagData._sizeArr = concatArrays(tagData._sizeArr, setParametersToArray([], 0, itemSize, itemSize, geoObject.getScale()));
+        itemSize = 3;
+        let scale = geoObject.getScale();
+        x = scale.x;
+        y = scale.y;
+        z = scale.z;
+        tagData._sizeArr = concatArrays(tagData._sizeArr, setParametersToArray([], 0, itemSize, itemSize, x, y, z));
     }
     _displayPASS() {
         let r = this._planet.renderer, sh = r.handler.programs.geo_object, p = sh._program, u = p.uniforms, a = p.attributes, gl = r.handler.gl, ec = this._entityCollection;
         sh.activate();
+        //gl.disable(gl.CULL_FACE);
         //
         // Could be in VAO
         //
@@ -451,7 +456,7 @@ class GeoObjectHandler {
         this._updateTag(tagData);
     }
     setScaleArr(tagData, tagDataIndex, scale) {
-        setParametersToArray(tagData._sizeArr, tagDataIndex, 1, 1, scale);
+        setParametersToArray(tagData._sizeArr, tagDataIndex, 3, 3, scale.x, scale.y, scale.z);
         tagData._changedBuffers[SIZE_BUFFER] = true;
         this._updateTag(tagData);
     }
@@ -541,8 +546,8 @@ class GeoObjectHandler {
         tagData._positionLowArr = spliceArray(tagData._positionLowArr, tdi * 3, 3);
         tagData._directionArr = spliceArray(tagData._directionArr, tdi * 3, 3);
         tagData._pickingColorArr = spliceArray(tagData._pickingColorArr, tdi * 3, 3);
+        tagData._sizeArr = spliceArray(tagData._sizeArr, tdi * 3, 3);
         tagData._pitchRollArr = spliceArray(tagData._pitchRollArr, tdi * 2, 2);
-        tagData._sizeArr = spliceArray(tagData._sizeArr, tdi, 1);
         tagData._visibleArr = spliceArray(tagData._visibleArr, tdi, 1);
         geoObject._handlerIndex = -1;
         geoObject._handler = null;

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);