@openglobus/og 0.22.2 → 0.24.0

package/lib/js/entity/Polyline.js

@@ -1,7 +1,7 @@
 import { Extent } from "../Extent";
 import { LonLat } from "../LonLat";
 import { Vec3 } from "../math/Vec3";
-import { cloneArray, htmlColorToFloat32Array, htmlColorToRgba, makeArray, makeArrayTyped } from "../utils/shared";
+import { cloneArray, createVector3, htmlColorToFloat32Array, htmlColorToRgba, makeArray, makeArrayTyped } from "../utils/shared";
 const VERTICES_BUFFER = 0;
 const INDEX_BUFFER = 1;
 const COLORS_BUFFER = 2;
@@ -27,6 +27,7 @@ const A = 3;
 class Polyline {
     constructor(options = {}) {
         this.__id = Polyline.__counter__++;
+        this.__doubleToTwoFloats = Vec3.doubleToTwoFloats;
         this.altitude = options.altitude || 0.0;
         this.thickness = options.thickness || 1.5;
         this._opacity = options.opacity != undefined ? options.opacity : 1.0;
@@ -59,6 +60,9 @@ class Polyline {
         this._buffersUpdateCallbacks[INDEX_BUFFER] = this._createIndexBuffer;
         this._buffersUpdateCallbacks[COLORS_BUFFER] = this._createColorsBuffer;
         this._changedBuffers = new Array(this._buffersUpdateCallbacks.length);
+        let c = createVector3(options.visibleSpherePosition).toArray();
+        let r = options.visibleSphereRadius || 0;
+        this._visibleSphere = new Float32Array([...c, r]);
         // create path
         if (options.pathLonLat) {
             this.setPathLonLat(options.pathLonLat);
@@ -70,9 +74,8 @@ class Polyline {
     }
     /**
      * Appends to the line array new cartesian coordinates line data.
-     * @static
      */
-    static appendLineData3v(path3v, pathColors, defaultColor, isClosed, outVerticesHigh, outVerticesLow, outOrders, outIndexes, ellipsoid, outTransformedPathLonLat, outPath3v, outTransformedPathMerc, outExtent, outColors) {
+    __appendLineData3v(path3v, pathColors, defaultColor, isClosed, outVerticesHigh, outVerticesLow, outOrders, outIndexes, ellipsoid, outTransformedPathLonLat, outPath3v, outTransformedPathMerc, outExtent, outColors) {
         var index = 0;
         var v_high = new Vec3(), v_low = new Vec3();
         if (outExtent) {
@@ -118,7 +121,7 @@ class Polyline {
             if (pathColors_j && pathColors_j[0]) {
                 color = pathColors_j[0];
             }
-            Vec3.doubleToTwoFloats(last, v_high, v_low);
+            this.__doubleToTwoFloats(last, v_high, v_low);
             outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
             outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
             let r = color[R], g = color[G], b = color[B], a = color[A] != undefined ? color[A] : 1.0;
@@ -156,7 +159,7 @@ class Polyline {
                 g = color[G];
                 b = color[B];
                 a = color[A] != undefined ? color[A] : 1.0;
-                Vec3.doubleToTwoFloats(cur, v_high, v_low);
+                this.__doubleToTwoFloats(cur, v_high, v_low);
                 outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
                 outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
                 outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
@@ -195,7 +198,7 @@ class Polyline {
             g = color[G];
             b = color[B];
             a = color[A] != undefined ? color[A] : 1.0;
-            Vec3.doubleToTwoFloats(first, v_high, v_low);
+            this.__doubleToTwoFloats(first, v_high, v_low);
             outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
             outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
             outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
@@ -208,9 +211,8 @@ class Polyline {
     }
     /**
      * Appends to the line new cartesian coordinates point data.
-     * @static
      */
-    static appendPoint3v(path3v, point3v, pathColors, color, isClosed, outVerticesHigh, outVerticesLow, outColors, outOrders, outIndexes, ellipsoid, outTransformedPathLonLat, outTransformedPathMerc, outExtent) {
+    __appendPoint3v(path3v, point3v, pathColors, color, isClosed, outVerticesHigh, outVerticesLow, outColors, outOrders, outIndexes, ellipsoid, outTransformedPathLonLat, outTransformedPathMerc, outExtent) {
         var v_high = new Vec3(), v_low = new Vec3();
         var ii = outIndexes.length - 4, index = outIndexes[ii - 1] + 1;
         if (path3v.length === 0) {
@@ -258,7 +260,7 @@ class Polyline {
                 }
                 last = new Vec3(p0.x + p0.x - p1.x, p0.y + p0.y - p1.y, p0.z + p0.z - p1.z);
             }
-            Vec3.doubleToTwoFloats(last, v_high, v_low);
+            this.__doubleToTwoFloats(last, v_high, v_low);
             let vi = outVerticesHigh.length - 3 * 12;
             outVerticesHigh[vi] = v_high.x;
             outVerticesHigh[vi + 1] = v_high.y;
@@ -310,7 +312,7 @@ class Polyline {
                 outExtent.northEast.lat = lonLat.lat;
             }
         }
-        Vec3.doubleToTwoFloats(point3v, v_high, v_low);
+        this.__doubleToTwoFloats(point3v, v_high, v_low);
         let vi = outVerticesHigh.length - 12;
         outVerticesHigh[vi] = v_high.x;
         outVerticesHigh[vi + 1] = v_high.y;
@@ -370,7 +372,7 @@ class Polyline {
             first = new Vec3(p0.x + p0.x - p1.x, p0.y + p0.y - p1.y, p0.z + p0.z - p1.z);
             outIndexes.push(index - 1, index - 1, index - 1, index - 1);
         }
-        Vec3.doubleToTwoFloats(first, v_high, v_low);
+        this.__doubleToTwoFloats(first, v_high, v_low);
         outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
         outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
         outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
@@ -418,7 +420,7 @@ class Polyline {
      * Appends to the line array new geodetic coordinates line data.
      * @static
      */
-    static appendLineDataLonLat(pathLonLat, pathColors, defaultColor, isClosed, outVerticesHigh, outVerticesLow, outOrders, outIndexes, ellipsoid, outTransformedPathCartesian, outPathLonLat, outTransformedPathMerc, outExtent, outColors) {
+    __appendLineDataLonLat(pathLonLat, pathColors, defaultColor, isClosed, outVerticesHigh, outVerticesLow, outOrders, outIndexes, ellipsoid, outTransformedPathCartesian, outPathLonLat, outTransformedPathMerc, outExtent, outColors) {
         var index = 0;
         var v_high = new Vec3(), v_low = new Vec3();
         if (outExtent) {
@@ -476,7 +478,7 @@ class Polyline {
             if (pathColors_j && pathColors_j[0]) {
                 color = pathColors_j[0];
             }
-            Vec3.doubleToTwoFloats(last, v_high, v_low);
+            this.__doubleToTwoFloats(last, v_high, v_low);
             outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
             outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
             let r = color[R], g = color[G], b = color[B], a = color[A] != undefined ? color[A] : 1.0;
@@ -500,7 +502,7 @@ class Polyline {
                 outTransformedPathCartesian[j].push(cartesian);
                 outPathLonLat[j].push(cur);
                 outTransformedPathMerc[j].push(cur.forwardMercator());
-                Vec3.doubleToTwoFloats(cartesian, v_high, v_low);
+                this.__doubleToTwoFloats(cartesian, v_high, v_low);
                 outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
                 outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
                 outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
@@ -559,7 +561,7 @@ class Polyline {
             g = color[G];
             b = color[B];
             a = color[A] != undefined ? color[A] : 1.0;
-            Vec3.doubleToTwoFloats(first, v_high, v_low);
+            this.__doubleToTwoFloats(first, v_high, v_low);
             outVerticesHigh.push(v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z, v_high.x, v_high.y, v_high.z);
             outVerticesLow.push(v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z, v_low.x, v_low.y, v_low.z);
             outColors.push(r, g, b, a, r, g, b, a, r, g, b, a, r, g, b, a);
@@ -591,7 +593,7 @@ class Polyline {
             else {
                 last = new Vec3(path[0].x + path[0].x - path[1].x, path[0].y + path[0].y - path[1].y, path[0].z + path[0].z - path[1].z);
             }
-            Vec3.doubleToTwoFloats(last, v_high, v_low);
+            this.__doubleToTwoFloats(last, v_high, v_low);
             vh[k] = v_high.x;
             vl[k++] = v_low.x;
             vh[k] = v_high.y;
@@ -639,7 +641,7 @@ class Polyline {
                         extent.northEast.lat = lonLat.lat;
                     }
                 }
-                Vec3.doubleToTwoFloats(cur, v_high, v_low);
+                this.__doubleToTwoFloats(cur, v_high, v_low);
                 vh[k] = v_high.x;
                 vl[k++] = v_low.x;
                 vh[k] = v_high.y;
@@ -673,7 +675,7 @@ class Polyline {
                 var l1 = path.length - 1;
                 first = new Vec3(path[l1].x + path[l1].x - path[l1 - 1].x, path[l1].y + path[l1].y - path[l1 - 1].y, path[l1].z + path[l1].z - path[l1 - 1].z);
             }
-            Vec3.doubleToTwoFloats(first, v_high, v_low);
+            this.__doubleToTwoFloats(first, v_high, v_low);
             vh[k] = v_high.x;
             vl[k++] = v_low.x;
             vh[k] = v_high.y;
@@ -722,7 +724,7 @@ class Polyline {
                 let p0 = ellipsoid.lonLatToCartesian(path[0]), p1 = ellipsoid.lonLatToCartesian(path[1]);
                 last = new Vec3(p0.x + p0.x - p1.x, p0.y + p0.y - p1.y, p0.z + p0.z - p1.z);
             }
-            Vec3.doubleToTwoFloats(last, v_high, v_low);
+            this.__doubleToTwoFloats(last, v_high, v_low);
             vh[k] = v_high.x;
             vl[k++] = v_low.x;
             vh[k] = v_high.y;
@@ -753,7 +755,7 @@ class Polyline {
                 c[j][i] = cartesian;
                 m[j][i] = cur.forwardMercator();
                 l[j][i] = cur;
-                Vec3.doubleToTwoFloats(cartesian, v_high, v_low);
+                this.__doubleToTwoFloats(cartesian, v_high, v_low);
                 vh[k] = v_high.x;
                 vl[k++] = v_low.x;
                 vh[k] = v_high.y;
@@ -799,7 +801,7 @@ class Polyline {
                 let p0 = ellipsoid.lonLatToCartesian(path[path.length - 1]), p1 = ellipsoid.lonLatToCartesian(path[path.length - 2]);
                 first = new Vec3(p0.x + p0.x - p1.x, p0.y + p0.y - p1.y, p0.z + p0.z - p1.z);
             }
-            Vec3.doubleToTwoFloats(first, v_high, v_low);
+            this.__doubleToTwoFloats(first, v_high, v_low);
             vh[k] = v_high.x;
             vl[k++] = v_low.x;
             vh[k] = v_high.y;
@@ -893,7 +895,7 @@ class Polyline {
                     last = new Vec3(path[0].x + path[0].x - path[1].x, path[0].y + path[0].y - path[1].y, path[0].z + path[0].z - path[1].z);
                 }
                 k = kk;
-                Vec3.doubleToTwoFloats(last, v_high, v_low);
+                this.__doubleToTwoFloats(last, v_high, v_low);
                 vh[k] = v_high.x;
                 vh[k + 1] = v_high.y;
                 vh[k + 2] = v_high.z;
@@ -949,7 +951,7 @@ class Polyline {
                 }
             }
             k = kk + index * 12 + 12;
-            Vec3.doubleToTwoFloats(coordinates, v_high, v_low);
+            this.__doubleToTwoFloats(coordinates, v_high, v_low);
             vh[k] = v_high.x;
             vh[k + 1] = v_high.y;
             vh[k + 2] = v_high.z;
@@ -984,7 +986,7 @@ class Polyline {
                     first = new Vec3(path[l1].x + path[l1].x - path[l1 - 1].x, path[l1].y + path[l1].y - path[l1 - 1].y, path[l1].z + path[l1].z - path[l1 - 1].z);
                 }
                 k = kk + path.length * 12 + 12;
-                Vec3.doubleToTwoFloats(first, v_high, v_low);
+                this.__doubleToTwoFloats(first, v_high, v_low);
                 vh[k] = v_high.x;
                 vh[k + 1] = v_high.y;
                 vh[k + 2] = v_high.z;
@@ -1091,7 +1093,7 @@ class Polyline {
             this._colors = makeArray(this._colors);
             this._orders = makeArray(this._orders);
             this._indexes = makeArray(this._indexes);
-            Polyline.appendPoint3v(this._path3v, point3v, this._pathColors, color || this._defaultColor, this._closedLine, this._verticesHigh, this._verticesLow, this._colors, this._orders, this._indexes, !skipEllipsoid ? this._renderNode.ellipsoid : null, this._pathLonLat, this._pathLonLatMerc, this._extent);
+            this.__appendPoint3v(this._path3v, point3v, this._pathColors, color || this._defaultColor, this._closedLine, this._verticesHigh, this._verticesLow, this._colors, this._orders, this._indexes, !skipEllipsoid ? this._renderNode.ellipsoid : null, this._pathLonLat, this._pathLonLatMerc, this._extent);
             this._pathLengths[this._path3v.length] += 1;
             this._changedBuffers[VERTICES_BUFFER] = true;
             this._changedBuffers[COLORS_BUFFER] = true;
@@ -1188,6 +1190,14 @@ class Polyline {
     setOpacity(opacity) {
         this._opacity = opacity;
     }
+    /**
+     * Gets polyline opacity.
+     * @public
+     * @param {number} opacity - Opacity.
+     */
+    getOpacity() {
+        return this._opacity;
+    }
     /**
      * Sets Polyline thickness in screen pixels.
      * @public
@@ -1273,12 +1283,12 @@ class Polyline {
     }
     _createData3v(path3v) {
         this._clearData();
-        Polyline.appendLineData3v(path3v, this._pathColors, this._defaultColor, this._closedLine, this._verticesHigh, this._verticesLow, this._orders, this._indexes, this._renderNode.ellipsoid, this._pathLonLat, this._path3v, this._pathLonLatMerc, this._extent, this._colors);
+        this.__appendLineData3v(path3v, this._pathColors, this._defaultColor, this._closedLine, this._verticesHigh, this._verticesLow, this._orders, this._indexes, this._renderNode.ellipsoid, this._pathLonLat, this._path3v, this._pathLonLatMerc, this._extent, this._colors);
         this._resizePathLengths(0);
     }
     _createDataLonLat(pathLonlat) {
         this._clearData();
-        Polyline.appendLineDataLonLat(pathLonlat, this._pathColors, this._defaultColor, this._closedLine, this._verticesHigh, this._verticesLow, this._orders, this._indexes, this._renderNode.ellipsoid, this._path3v, this._pathLonLat, this._pathLonLatMerc, this._extent, this._colors);
+        this.__appendLineDataLonLat(pathLonlat, this._pathColors, this._defaultColor, this._closedLine, this._verticesHigh, this._verticesLow, this._orders, this._indexes, this._renderNode.ellipsoid, this._path3v, this._pathLonLat, this._pathLonLatMerc, this._extent, this._colors);
         this._resizePathLengths(0);
     }
     /**
@@ -1375,13 +1385,22 @@ class Polyline {
         }
         this._changedBuffers[COLORS_BUFFER] = true;
     }
+    setPathLonLatFast(pathLonLat, pathColors) {
+        this.setPathLonLat(pathLonLat, pathColors, true);
+    }
+    setPath3vFast(path3v, pathColors) {
+        this.setPath3v(path3v, pathColors, true);
+    }
     /**
      * Sets polyline geodetic coordinates.
      * @public
      * @param {SegmentPathLonLat[]} pathLonLat - Polyline path cartesian coordinates.
      * @param {Boolean} [forceEqual=false] - OPTIMIZATION FLAG: Makes assigning faster for size equal coordinates array.
      */
-    setPathLonLat(pathLonLat, forceEqual = false) {
+    setPathLonLat(pathLonLat, pathColors, forceEqual = false) {
+        if (pathColors) {
+            this._pathColors = [].concat(pathColors);
+        }
         if (this._renderNode && this._renderNode.ellipsoid) {
             if (forceEqual) {
                 this._setEqualPathLonLat(pathLonLat);
@@ -1399,6 +1418,9 @@ class Polyline {
             this._pathLonLat = [].concat(pathLonLat);
         }
     }
+    getSize(index = 0) {
+        return this._path3v[index].length;
+    }
     /**
      * Sets Polyline cartesian coordinates.
      * @public
@@ -1442,8 +1464,9 @@ class Polyline {
             gl.uniformMatrix4fv(shu.proj, false, r.activeCamera.getProjectionMatrix());
             gl.uniformMatrix4fv(shu.view, false, r.activeCamera.getViewMatrix());
             // gl.uniform4fv(shu.color, [this.color.x, this.color.y, this.color.z, this.color.w * this._handler._entityCollection._fadingOpacity]);
-            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera.eyeHigh);
-            gl.uniform3fv(shu.eyePositionLow, r.activeCamera.eyeLow);
+            gl.uniform3fv(shu.rtcEyePositionHigh, this._handler._rtcEyePositionHigh);
+            gl.uniform3fv(shu.rtcEyePositionLow, this._handler._rtcEyePositionLow);
+            gl.uniform4fv(shu.visibleSphere, this._visibleSphere);
             //gl.uniform2fv(shu.uFloatParams, [(rn as Planet)._planetRadius2 || 0.0, r.activeCamera!._tanViewAngle_hradOneByHeight]);
             gl.uniform2fv(shu.viewport, [r.handler.canvas.width, r.handler.canvas.height]);
             gl.uniform1f(shu.thickness, this.thickness * 0.5);
@@ -1474,9 +1497,10 @@ class Polyline {
             let sh = r.handler.programs.polyline_picking;
             let p = sh._program;
             let gl = r.handler.gl, sha = p.attributes, shu = p.uniforms;
+            let ec = this._handler._entityCollection;
             sh.activate();
             gl.disable(gl.CULL_FACE);
-            gl.uniform1f(shu.depthOffset, this._handler._entityCollection.polygonOffsetUnits);
+            gl.uniform1f(shu.depthOffset, ec.polygonOffsetUnits);
             gl.uniformMatrix4fv(shu.proj, false, r.activeCamera.getProjectionMatrix());
             gl.uniformMatrix4fv(shu.view, false, r.activeCamera.getViewMatrix());
             gl.uniform4fv(shu.color, [
@@ -1485,12 +1509,11 @@ class Polyline {
                 this._pickingColor[2],
                 1.0
             ]);
-            gl.uniform3fv(shu.eyePositionHigh, r.activeCamera.eyeHigh);
-            gl.uniform3fv(shu.eyePositionLow, r.activeCamera.eyeLow);
-            gl.uniform2fv(shu.uFloatParams, [rn._planetRadius2 || 0.0, r.activeCamera._tanViewAngle_hradOneByHeight]);
-            //@todo: replace to the handler property
+            gl.uniform3fv(shu.rtcEyePositionHigh, this._handler._rtcEyePositionHigh);
+            gl.uniform3fv(shu.rtcEyePositionLow, this._handler._rtcEyePositionLow);
+            gl.uniform4fv(shu.visibleSphere, this._visibleSphere);
             gl.uniform2fv(shu.viewport, [r.handler.canvas.width, r.handler.canvas.height]);
-            gl.uniform1f(shu.thickness, this.thickness * 0.5);
+            gl.uniform1f(shu.thickness, this.thickness * 0.5 * ec.pickingScale[0]);
             let v = this._verticesHighBuffer;
             gl.bindBuffer(gl.ARRAY_BUFFER, v);
             gl.vertexAttribPointer(sha.prevHigh, v.itemSize, gl.FLOAT, false, 12, 0);
@@ -1589,6 +1612,23 @@ class Polyline {
         this._colors = makeArrayTyped(this._colors);
         this._colorsBuffer = h.createArrayBuffer(new Float32Array(this._colors), 4, this._colors.length / 4);
     }
+    setVisibleSphere(p, r) {
+        if (this._handler) {
+            this._visibleSphere[0] = p.x - this._handler._relativeCenter.x;
+            this._visibleSphere[1] = p.y - this._handler._relativeCenter.y;
+            this._visibleSphere[2] = p.z - this._handler._relativeCenter.z;
+        }
+        this._visibleSphere[3] = r;
+    }
+    updateRTCPosition() {
+        if (this._handler && this._renderNode) {
+            this._visibleSphere[0] = this._visibleSphere[0] - this._handler._relativeCenter.x;
+            this._visibleSphere[1] = this._visibleSphere[1] - this._handler._relativeCenter.y;
+            this._visibleSphere[2] = this._visibleSphere[2] - this._handler._relativeCenter.z;
+            this._setEqualPath3v(this._path3v);
+        }
+        this._changedBuffers[VERTICES_BUFFER] = true;
+    }
 }
 Polyline.__counter__ = 0;
 export { Polyline };

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

@@ -2,6 +2,7 @@ import { EntityCollection } from "./EntityCollection";
 import { Polyline } from "./Polyline";
 import { Renderer } from "../renderer/Renderer";
 import { RenderNode } from "../scene/RenderNode";
+import { Vec3 } from "../math/Vec3";
 declare class PolylineHandler {
     static __counter__: number;
     protected __id: number;
@@ -9,6 +10,9 @@ declare class PolylineHandler {
     pickingEnabled: boolean;
     protected _renderer: Renderer | null;
     protected _polylines: Polyline[];
+    _relativeCenter: Vec3;
+    _rtcEyePositionHigh: Float32Array;
+    _rtcEyePositionLow: Float32Array;
     constructor(entityCollection: EntityCollection);
     protected _initProgram(): void;
     setRenderNode(renderNode: RenderNode): void;
@@ -18,5 +22,8 @@ declare class PolylineHandler {
     draw(): void;
     drawPicking(): void;
     clear(): void;
+    getRTCPosition(pos: Vec3, rtcPositionHigh: Vec3, rtcPositionLow: Vec3): void;
+    setRelativeCenter(c: Vec3): void;
+    protected _updateRTCEyePosition(): void;
 }
 export { PolylineHandler };

package/lib/js/entity/PolylineHandler.js

@@ -1,4 +1,5 @@
 import * as shaders from '../shaders/polyline';
+import { Vec3 } from "../math/Vec3";
 class PolylineHandler {
     constructor(entityCollection) {
         this.__id = PolylineHandler.__counter__++;
@@ -6,6 +7,9 @@ class PolylineHandler {
         this._renderer = null;
         this._polylines = [];
         this.pickingEnabled = true;
+        this._relativeCenter = new Vec3();
+        this._rtcEyePositionHigh = new Float32Array([0, 0, 0]);
+        this._rtcEyePositionLow = new Float32Array([0, 0, 0]);
     }
     _initProgram() {
         if (this._renderer && this._renderer.handler) {
@@ -28,9 +32,12 @@ class PolylineHandler {
         if (polyline._handlerIndex === -1) {
             polyline._handler = this;
             polyline._handlerIndex = this._polylines.length;
+            polyline.__doubleToTwoFloats = this.getRTCPosition.bind(this);
             this._polylines.push(polyline);
-            this._entityCollection && this._entityCollection.renderNode &&
+            if (this._entityCollection && this._entityCollection.renderNode) {
                 polyline.setRenderNode(this._entityCollection.renderNode);
+                polyline.updateRTCPosition();
+            }
         }
     }
     remove(polyline) {
@@ -50,6 +57,7 @@ class PolylineHandler {
         }
     }
     draw() {
+        this._updateRTCEyePosition();
         let i = this._polylines.length;
         while (i--) {
             this._polylines[i].draw();
@@ -73,6 +81,23 @@ class PolylineHandler {
         this._polylines.length = 0;
         this._polylines = [];
     }
+    getRTCPosition(pos, rtcPositionHigh, rtcPositionLow) {
+        let rtcPosition = pos.sub(this._relativeCenter);
+        Vec3.doubleToTwoFloats(rtcPosition, rtcPositionHigh, rtcPositionLow);
+    }
+    setRelativeCenter(c) {
+        this._relativeCenter.copy(c);
+        for (let i = 0; i < this._polylines.length; i++) {
+            this._polylines[i].updateRTCPosition();
+        }
+    }
+    _updateRTCEyePosition() {
+        let r = this._renderer;
+        if (r.activeCamera.isFirstPass) {
+            let rtcEyePosition = r.activeCamera.eye.sub(this._relativeCenter);
+            Vec3.doubleToTwoFloat32Array(rtcEyePosition, this._rtcEyePositionHigh, this._rtcEyePositionLow);
+        }
+    }
 }
 PolylineHandler.__counter__ = 0;
 export { PolylineHandler };

package/lib/js/index.d.ts

@@ -30,4 +30,5 @@ import { Control } from './control/Control';
 export * from './entity/index';
 export * from './layer/index';
 import { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain } from './terrain/index';
-export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, moon, mars, terrain, layer, webgl, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, LightSource, Program, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d };
+import { MoveAxisEntity } from "./control/geoObjectEditor/MoveAxisEntity";
+export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, moon, mars, terrain, layer, webgl, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, LightSource, Program, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d, MoveAxisEntity, };

package/lib/js/index.js

@@ -30,4 +30,5 @@ import { Control } from './control/Control';
 export * from './entity/index';
 export * from './layer/index';
 import { EmptyTerrain, GlobusTerrain, RgbTerrain, BilTerrain, GlobusRgbTerrain } from './terrain/index';
-export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, moon, mars, terrain, layer, webgl, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, LightSource, Program, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d };
+import { MoveAxisEntity } from "./control/geoObjectEditor/MoveAxisEntity";
+export { bv, jd, math, mercator, utils, input, control, scene, quadTreeStrategyType, wgs84, moon, mars, terrain, layer, webgl, Framebuffer, EmptyTerrain, GlobusTerrain, RgbTerrain, GlobusRgbTerrain, BilTerrain, Control, Camera, Ellipsoid, Planet, PlanetCamera, LightSource, Program, Handler, Multisample, Renderer, Clock, Events, Extent, LonLat, RenderNode, Line2, Line3, Mat3, Mat4, Plane, Quat, Ray, Vec2, Vec3, Vec4, Geoid, Popup, QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy, Wgs84QuadTreeStrategy, Object3d, MoveAxisEntity, };

package/lib/js/input/MouseHandler.d.ts

@@ -1,6 +1,7 @@
 export type MouseEventExt = MouseEvent & {
     wheelDelta?: number;
     deltaY?: number;
+    isTouchPad?: boolean;
 };
 export interface MouseHandlerEvent {
     button?: number;

package/lib/js/input/MouseHandler.js

@@ -1,3 +1,13 @@
+function _checkTouchPad(e) {
+    //@ts-ignore
+    if (e.deltaMode !== 0) {
+        return false;
+    }
+    //@ts-ignore
+    return Math.abs(e.deltaY) < 50;
+    //@ts-ignore
+    //return e.wheelDeltaY ? e.wheelDeltaY === -3 * e.deltaY : e.deltaMode === 0
+}
 class MouseHandler {
     constructor(htmlObject) {
         this._htmlObject = htmlObject;
@@ -13,11 +23,12 @@ class MouseHandler {
                 //     callback.call(sender, event);
                 //     event.preventDefault();
                 // }, false);
-                this._htmlObject.addEventListener('wheel', function (event) {
+                this._htmlObject.addEventListener('wheel', (event) => {
                     let delta = event.deltaY || event.detail || event.wheelDelta || 0;
                     if (event.wheelDelta == undefined) {
                         event.wheelDelta = delta * (-120);
                     }
+                    event.isTouchPad = _checkTouchPad(event);
                     callback.call(sender, event);
                     event.preventDefault();
                 }, false);

package/lib/js/layer/Bing.js

@@ -31,8 +31,8 @@ export class Bing extends XYZ {
                 });
             },
             specular: [0.00063, 0.00055, 0.00032],
-            ambient: "rgb(90,90,90)",
-            diffuse: "rgb(350,350,350)",
+            ambient: [0.35, 0.35, 0.35],
+            diffuse: [1.5, 1.5, 1.5],
             shininess: 20,
             nightTextureCoefficient: 2.7,
             ...options

package/lib/js/layer/Vector.d.ts

@@ -19,6 +19,7 @@ export interface IVectorParams extends ILayerParams {
     scaleByDistance?: NumberArray3;
     labelMaxLetters?: number;
     useLighting?: boolean;
+    depthOrder?: number;
 }
 type VectorEventsList = [
     "draw",
@@ -61,6 +62,7 @@ export type VectorEventsType = EventsHandler<VectorEventsList> & EventsHandler<L
  */
 declare class Vector extends Layer {
     events: VectorEventsType;
+    protected _depthOrder: number;
     /**
      * Entities collection.
      * @protected
@@ -113,6 +115,8 @@ declare class Vector extends Layer {
     protected _labelMaxLetters: number;
     protected _useLighting: boolean;
     constructor(name?: string | null, options?: IVectorParams);
+    get depthOrder(): number;
+    set depthOrder(d: number);
     get useLighting(): boolean;
     set useLighting(f: boolean);
     get labelMaxLetters(): number;

package/lib/js/layer/Vector.js

@@ -103,6 +103,16 @@ class Vector extends Layer {
         this.setEntities(this._entities);
         this.polygonOffsetUnits = options.polygonOffsetUnits != undefined ? options.polygonOffsetUnits : 0.0;
         this.pickingEnabled = this._pickingEnabled;
+        this._depthOrder = options.depthOrder || 0;
+    }
+    get depthOrder() {
+        return this._depthOrder;
+    }
+    set depthOrder(d) {
+        if (d !== this._depthOrder) {
+            this._depthOrder = d;
+            this._planet && this._planet.updateVisibleLayers();
+        }
     }
     get useLighting() {
         return this._useLighting;
@@ -135,6 +145,9 @@ class Vector extends Layer {
             this._polylineEntityCollection.addTo(planet, true);
             this._stripEntityCollection.addTo(planet, true);
             this._geoObjectEntityCollection.addTo(planet, true);
+            this._polylineEntityCollection._layer = this;
+            this._stripEntityCollection._layer = this;
+            this._geoObjectEntityCollection._layer = this;
             this.setEntities(this._entities);
         }
     }
@@ -143,6 +156,9 @@ class Vector extends Layer {
         this._polylineEntityCollection.remove();
         this._stripEntityCollection.remove();
         this._geoObjectEntityCollection.remove();
+        this._polylineEntityCollection._layer = undefined;
+        this._stripEntityCollection._layer = undefined;
+        this._geoObjectEntityCollection._layer = undefined;
         return this;
     }
     /**