@openglobus/og 0.19.3 → 0.20.0

package/lib/js/quadTree/Node.js

@@ -19,6 +19,7 @@ let BOUNDS = {
     xmin: 0.0, ymin: 0.0, zmin: 0.0,
     xmax: 0.0, ymax: 0.0, zmax: 0.0
 };
+let __staticCounter = 0;
 /**
  * Quad tree planet segment node.
  * @constructor
@@ -31,13 +32,14 @@ let BOUNDS = {
  * @param {Extent} extent - Planet segment extent.
  */
 class Node {
-    constructor(SegmentPrototype, planet, partId, parent, id, tileZoom, extent) {
+    constructor(SegmentPrototype, planet, partId, parent, tileZoom, extent) {
         planet._createdNodesCount++;
+        this.__id = __staticCounter++;
         this.SegmentPrototype = SegmentPrototype;
         this.planet = planet;
         this.parentNode = parent;
         this.partId = partId;
-        this.nodeId = partId + id;
+        this.nodeId = partId + (parent ? parent.nodeId * 4 + 1 : 0);
         this.state = null;
         this.prevState = null;
         this.appliedTerrainNodeId = -1;
@@ -63,13 +65,12 @@ class Node {
         const size_y = ext.getHeight() * 0.5;
         const ne = ext.northEast;
         const sw = ext.southWest;
-        const id = this.nodeId * 4 + 1;
         const c = new LonLat(sw.lon + size_x, sw.lat + size_y);
         const nd = this.nodes;
-        nd[NW] = new Node(this.SegmentPrototype, p, NW, this, id, z, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)));
-        nd[NE] = new Node(this.SegmentPrototype, p, NE, this, id, z, new Extent(c, new LonLat(ne.lon, ne.lat)));
-        nd[SW] = new Node(this.SegmentPrototype, p, SW, this, id, z, new Extent(new LonLat(sw.lon, sw.lat), c));
-        nd[SE] = new Node(this.SegmentPrototype, p, SE, this, id, z, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)));
+        nd[NW] = new Node(this.SegmentPrototype, p, NW, this, z, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)));
+        nd[NE] = new Node(this.SegmentPrototype, p, NE, this, z, new Extent(c, new LonLat(ne.lon, ne.lat)));
+        nd[SW] = new Node(this.SegmentPrototype, p, SW, this, z, new Extent(new LonLat(sw.lon, sw.lat), c));
+        nd[SE] = new Node(this.SegmentPrototype, p, SE, this, z, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)));
     }
     createBounds() {
         let seg = this.segment;
@@ -155,9 +156,6 @@ class Node {
         }
         this.state = WALKTHROUGH;
         this.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.
@@ -207,7 +205,7 @@ class Node {
             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);
+                (seg.tileZoom < 6 && !seg.terrainReady);
             altVis = altVis ||
                 cam.eye.distance2(seg._sw) < horizonDist ||
                 cam.eye.distance2(seg._nw) < horizonDist ||
@@ -316,7 +314,7 @@ class Node {
                         pn = pn.parentNode;
                     }
                     // not sure it's necessary here
-                    //this.parentNode.whileTerrainLoading();
+                    this.parentNode.whileTerrainLoading();
                     this._fadingNodes.push(this.parentNode);
                     this.parentNode.segment._transitionOpacity = 2.0;
                     this.parentNode.segment._transitionTimestamp = timestamp;
@@ -327,7 +325,7 @@ class Node {
                         for (let i = 0; i < this.nodes.length; i++) {
                             let ni = this.nodes[i];
                             // not sure it's necessary here
-                            //ni.whileTerrainLoading();
+                            ni.whileTerrainLoading();
                             this._fadingNodes.push(ni);
                             ni.segment._transitionOpacity = 2.0;
                             ni.segment._transitionTimestamp = timestamp;
@@ -341,12 +339,14 @@ class Node {
     }
     clearNeighbors() {
         //this.sideSizeLog2[0] = this.sideSizeLog2[1] = this.sideSizeLog2[2] = this.sideSizeLog2[3] = Math.log2(this.segment.gridSize);
-        // @ts-ignore
-        this.neighbors[0] = this.neighbors[1] = this.neighbors[2] = this.neighbors[3] = null;
-        this.neighbors[0] = [];
-        this.neighbors[1] = [];
-        this.neighbors[2] = [];
-        this.neighbors[3] = [];
+        if (this.neighbors) {
+            // @ts-ignore
+            this.neighbors[0] = this.neighbors[1] = this.neighbors[2] = this.neighbors[3] = null;
+            this.neighbors[0] = [];
+            this.neighbors[1] = [];
+            this.neighbors[2] = [];
+            this.neighbors[3] = [];
+        }
     }
     _refreshTransitionOpacity() {
         if (this._fadingNodes.length === 0) {
@@ -358,6 +358,13 @@ class Node {
                 this._fadingNodes = [];
             }
             else {
+                // Looks like a bug fix for suddenly empty spaces
+                for (let i = 0; i < this._fadingNodes.length; i++) {
+                    if (this.segment._transitionOpacity < 1.0 && this._fadingNodes[i].segment._transitionOpacity === 0) {
+                        this._fadingNodes[i].segment._transitionOpacity = 0;
+                        this.segment._transitionOpacity = 1.0;
+                    }
+                }
                 this.segment.increaseTransitionOpacity();
             }
         }
@@ -457,23 +464,25 @@ class Node {
                 else if (a_sw_lat === b_ne_lat && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
                     return S;
                 }
-                else if (bs.tileX === 0 && as.tileX === Math.pow(2, as.tileZoom) - 1 && ((a_ne_lat <= b_ne_lat && a_sw_lat >= b_sw_lat) || (a_ne_lat >= b_ne_lat && a_sw_lat <= b_sw_lat))) {
+                // World edge 180 to -180
+                else if (bs.tileX === 0 && b_sw_lon === -a_ne_lon && ((a_ne_lat <= b_ne_lat && a_sw_lat >= b_sw_lat) || (a_ne_lat >= b_ne_lat && a_sw_lat <= b_sw_lat))) {
                     return E;
                 }
-                else if (as.tileX === 0 && bs.tileX === Math.pow(2, bs.tileZoom) - 1 && ((a_ne_lat <= b_ne_lat && a_sw_lat >= b_sw_lat) || (a_ne_lat >= b_ne_lat && a_sw_lat <= b_sw_lat))) {
+                else if (as.tileX === 0 && a_sw_lon === -b_ne_lon && ((a_ne_lat <= b_ne_lat && a_sw_lat >= b_sw_lat) || (a_ne_lat >= b_ne_lat && a_sw_lat <= b_sw_lat))) {
                     return W;
                 }
             }
-            if (as._tileGroup === TILEGROUP_COMMON && bs._tileGroup === TILEGROUP_NORTH && as.tileY === 0 && bs.tileY === Math.pow(2, bs.tileZoom) - 1 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
+            // @todo: replace to the default strategy
+            if (as._tileGroup === TILEGROUP_COMMON && bs._tileGroup === TILEGROUP_NORTH && as.tileY === 0 && bs.tileY === bs.powTileZoom /*Math.pow(2, bs.tileZoom)*/ - 1 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
                 return N;
             }
-            else if (as._tileGroup === TILEGROUP_SOUTH && bs._tileGroup === TILEGROUP_COMMON && as.tileY === 0 && bs.tileY === Math.pow(2, bs.tileZoom) - 1 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
-                return N;
-            }
-            else if (bs._tileGroup === TILEGROUP_NORTH && as._tileGroup === TILEGROUP_COMMON && as.tileY === Math.pow(2, as.tileZoom) - 1 && bs.tileY === 0 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
+            else if (as._tileGroup === TILEGROUP_COMMON && bs._tileGroup === TILEGROUP_SOUTH && as.tileY === as.powTileZoom /*Math.pow(2, as.tileZoom)*/ - 1 && bs.tileY === 0 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
                 return S;
             }
-            else if (as._tileGroup === TILEGROUP_NORTH && bs._tileGroup === TILEGROUP_COMMON && as.tileY === Math.pow(2, as.tileZoom) - 1 && bs.tileY === 0 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
+            else if (as._tileGroup === TILEGROUP_SOUTH && bs._tileGroup === TILEGROUP_COMMON && as.tileY === 0 && bs.tileY === bs.powTileZoom /*Math.pow(2, bs.tileZoom)*/ - 1 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
+                return N;
+            }
+            else if (as._tileGroup === TILEGROUP_NORTH && bs._tileGroup === TILEGROUP_COMMON && as.tileY === as.powTileZoom /*Math.pow(2, as.tileZoom)*/ - 1 && bs.tileY === 0 && ((a_sw_lon >= b_sw_lon && a_ne_lon <= b_ne_lon) || (a_sw_lon <= b_sw_lon && a_ne_lon >= b_ne_lon))) {
                 return S;
             }
         }
@@ -506,7 +515,8 @@ class Node {
             }
         }
         if (pn.segment.terrainReady && this.appliedTerrainNodeId !== pn.nodeId) {
-            let dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1), offsetX = seg.tileX - pn.segment.tileX * dZ2, offsetY = seg.tileY - pn.segment.tileY * dZ2;
+            let dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1), // 2 * Math.pow(2, dZ-1)
+            offsetX = seg.tileX - pn.segment.tileX * dZ2, offsetY = seg.tileY - pn.segment.tileY * dZ2;
             const pseg = pn.segment;
             let tempVertices, tempVerticesHigh, tempVerticesLow, noDataVertices;
             this.appliedTerrainNodeId = pn.nodeId;

package/lib/js/quadTree/QuadTreeStrategy.d.ts

@@ -2,6 +2,7 @@ import { Layer } from "../layer/Layer";
 import { Node } from "../quadTree/Node";
 import { Planet } from "../scene/Planet";
 import { Proj } from "../proj/Proj";
+import { LonLat } from "../LonLat";
 export declare class QuadTreeStrategy {
     name: string;
     projection: Proj;
@@ -22,4 +23,6 @@ export declare class QuadTreeStrategy {
     collectRenderNodes(): void;
     clear(): void;
     get quadTreeList(): Node[];
+    getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
+    getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
 }

package/lib/js/quadTree/QuadTreeStrategy.js

@@ -1,4 +1,6 @@
 import { EPSG3857 } from "../proj/EPSG3857";
+import { getTileCellExtent, getTileCellIndex, TILEGROUP_COMMON } from "../segment/Segment";
+import { Extent } from "../Extent";
 export class QuadTreeStrategy {
     constructor(planet, name = "", proj = EPSG3857) {
         this.name = name;
@@ -66,4 +68,19 @@ export class QuadTreeStrategy {
     get quadTreeList() {
         return this._quadTreeList;
     }
+    getTileXY(lonLat, zoom) {
+        let z = zoom, x = -1, y = -1, pz = (1 << z);
+        x = getTileCellIndex(lonLat.lon, 360 / pz, -180);
+        y = getTileCellIndex(lonLat.lat, 180 / pz, 90);
+        return [x, y, z, TILEGROUP_COMMON];
+    }
+    getLonLatTileOffset(lonLat, x, y, z, gridSize) {
+        let coords = lonLat;
+        let extent = new Extent();
+        let worldExtent = Extent.createFromArray([-180, -90, 180, 90]);
+        extent = getTileCellExtent(x, y, z, worldExtent);
+        let sizeImgW = extent.getWidth() / (gridSize - 1), sizeImgH = extent.getHeight() / (gridSize - 1);
+        let i = gridSize - Math.ceil((coords.lat - extent.southWest.lat) / sizeImgH) - 1, j = Math.floor((coords.lon - extent.southWest.lon) / sizeImgW);
+        return [i, j];
+    }
 }

package/lib/js/quadTree/Wgs84QuadTreeStrategy.js

@@ -1,4 +1,3 @@
-import * as quadTree from "../quadTree/quadTree";
 import { Extent } from "../Extent";
 import { EPSG4326 } from "../proj/EPSG4326";
 import { Node } from "../quadTree/Node";
@@ -9,7 +8,8 @@ export class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
         super(planet, "wgs84", EPSG4326);
     }
     init() {
-        let wgs84QuadTree = new Node(SegmentLonLatWgs84, this.planet, quadTree.NW, null, 0, 0, Extent.createFromArray([-180, -90, 180, 90]));
-        this._quadTreeList.push(wgs84QuadTree);
+        this._quadTreeList = [
+            new Node(SegmentLonLatWgs84, this.planet, 0, null, 0, Extent.createFromArray([-180, -90, 180, 90]))
+        ];
     }
 }

package/lib/js/renderer/Renderer.js

@@ -954,6 +954,7 @@ class Renderer {
         //this.geoObjectsTextureAtlas.clear()
         //this.fontAtlas.clear();
         this._entityCollections = [];
+        this.handler.ONCANVASRESIZE = null;
         this.handler.destroy();
         // @ts-ignore
         this.handler = null;

package/lib/js/scene/Axes.js

@@ -43,13 +43,13 @@ class Axes extends RenderNode {
     }
     createAxesBuffer(gridSize) {
         const vertices = [
-            0.0, 0.0, 0.0, gridSize - 1, 0.0, 0.0,
-            0.0, 0.0, 0.0, 0.0, gridSize - 1, 0.0,
+            0.0, 0.0, 0.0, gridSize - 1, 0.0, 0.0, // x - R
+            0.0, 0.0, 0.0, 0.0, gridSize - 1, 0.0, // y - B  
             0.0, 0.0, 0.0, 0.0, 0.0, gridSize - 1 // z - G
         ];
         const colors = [
-            1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0,
-            0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0,
+            1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, // x - R
+            0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, // y - B
             0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0 // z - G
         ];
         this.axesBuffer = this.renderer.handler.createArrayBuffer(new Float32Array(vertices), 3, 6);

package/lib/js/scene/Planet.js

@@ -63,8 +63,8 @@ export class Planet extends RenderNode {
             let isEq = this.terrain.equalizeVertices;
             for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) {
                 let f = currentNode._fadingNodes[j].segment;
-                if (this._fadingNodes.has(currentNode._fadingNodes[0].nodeId) && !nodes.has(f.node.nodeId)) {
-                    nodes.set(f.node.nodeId, true);
+                if (this._fadingNodes.has(currentNode._fadingNodes[0].__id) && !nodes.has(f.node.__id)) {
+                    nodes.set(f.node.__id, true);
                     if (f._transitionOpacity < 1.0) {
                         outTransparentSegments.push(f);
                     }
@@ -88,8 +88,8 @@ export class Planet extends RenderNode {
             gl.disable(gl.DEPTH_TEST);
             for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) {
                 let f = currentNode._fadingNodes[j].segment;
-                if (this._fadingNodes.has(currentNode._fadingNodes[0].nodeId) && !nodes.has(f.node.nodeId)) {
-                    nodes.set(f.node.nodeId, true);
+                if (this._fadingNodes.has(currentNode._fadingNodes[0].__id) && !nodes.has(f.node.__id)) {
+                    nodes.set(f.node.__id, true);
                     if (isFirstPass) {
                         isEq && f.equalize();
                         f.readyToEngage && f.engage();
@@ -803,6 +803,7 @@ export class Planet extends RenderNode {
                 ri._collectFadingNodes();
                 ri._refreshTransitionOpacity();
                 if (ri.segment._transitionOpacity >= 1.0) {
+                    ri.clearNeighbors();
                     ri.getRenderedNodesNeighbors(opaqueNodes);
                     opaqueNodes.push(ri);
                 }
@@ -810,6 +811,7 @@ export class Planet extends RenderNode {
                     for (let j = 0; j < ri._fadingNodes.length; j++) {
                         let rij = ri._fadingNodes[j];
                         if (rij.segment && rij.segment._transitionOpacity >= 1.0) {
+                            rij.clearNeighbors();
                             rij.getRenderedNodesNeighbors(opaqueNodes);
                             opaqueNodes.push(rij);
                         }

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

@@ -16,9 +16,12 @@ import { NumberArray6, Sphere } from "../bv/Sphere";
 import { Slice } from "./Slice";
 import { Vec3 } from "../math/Vec3";
 import { IPlainSegmentWorkerData } from "../utils/PlainSegmentWorker";
+export declare function getTileCellIndex(coordinate: number, tileSize: number, worldEdge: number): number;
+export declare function getTileCellExtent(x: number, y: number, z: number, worldExtent: Extent): Extent;
 export declare const TILEGROUP_COMMON = 0;
-export declare const TILEGROUP_NORTH = 1;
-export declare const TILEGROUP_SOUTH = 2;
+export declare const TILEGROUP_NORTH = 20;
+export declare const TILEGROUP_SOUTH = 300;
+export declare function getTileGroupByLat(lat: number, maxLat?: number): number;
 /**
  * Planet segment Web Mercator tile class that stored and rendered with a quad-tree.
  * @class
@@ -32,6 +35,7 @@ declare class Segment {
     isPole: boolean;
     _tileGroup: number;
     _projection: Proj;
+    elevationData: TypedArray | null;
     /**
      * Quad tree node of the segment.
      * @type {Node}
@@ -81,6 +85,11 @@ declare class Segment {
      * @type {number}
      */
     tileZoom: number;
+    /**
+     * Equals to pow(2, tileZoom).
+     * @type {number}
+     */
+    powTileZoom: number;
     /**
      * Horizontal tile index.
      * @type {number}
@@ -243,6 +252,7 @@ declare class Segment {
     createPlainSegmentAsync(): void;
     _plainSegmentWorkerCallback(data: IPlainSegmentWorkerData): void;
     createPlainSegment(): void;
+    protected _projToDeg(lon: number, lat: number): LonLat;
     protected _createPlainVertices(): void;
     /**
      * Gets specific layer material.
@@ -267,19 +277,12 @@ declare class Segment {
     colorPickingRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;
     depthRendering(sh: Program, layerSlice: Layer[]): void;
     protected _getIndexBuffer(): WebGLBufferExt;
-    /**
-     * @todo: replace to the strategy
-     */
     _collectVisibleNodes(): void;
     layerOverlap(layer: Layer): boolean;
     getDefaultTexture(): WebGLTextureExt | null;
     getExtentLonLat(): Extent;
     getExtentMerc(): Extent;
     getExtent(): Extent;
-    /**
-     * @todo replace to the strategy
-     */
-    getNodeState(): number;
     getNeighborSide(b: Segment): 0 | 1 | 2 | 3 | -1;
 }
 export { Segment };

package/lib/js/segment/Segment.js

@@ -3,7 +3,7 @@ import * as segmentHelper from "../segment/segmentHelper";
 import { Box } from "../bv/Box";
 import { Extent } from "../Extent";
 import { EPSG3857 } from "../proj/EPSG3857";
-import { E, N, NOTRENDERING, OPSIDE, S, W } from "../quadTree/quadTree";
+import { E, N, OPSIDE, S, W } from "../quadTree/quadTree";
 import { getMatrixSubArray64 } from "../utils/shared";
 import { Layer } from "../layer/Layer";
 import { LonLat } from "../LonLat";
@@ -11,9 +11,30 @@ import { Sphere } from "../bv/Sphere";
 import { Slice } from "./Slice";
 import { Ray } from "../math/Ray";
 import { Vec3 } from "../math/Vec3";
+import { MAX_LAT } from "../mercator";
+//Math.round(Math.abs(-pole - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
+export function getTileCellIndex(coordinate, tileSize, worldEdge) {
+    return Math.floor(Math.abs(worldEdge - coordinate) / tileSize);
+}
+export function getTileCellExtent(x, y, z, worldExtent) {
+    let pz = 1.0 / (1 << z);
+    let worldWidth = worldExtent.getWidth(), worldHeight = worldExtent.getHeight();
+    let w = worldWidth * pz, h = worldHeight * pz;
+    let sw_lon = worldExtent.southWest.lon + x * w, ne_lat = worldExtent.northEast.lat - y * h;
+    return new Extent(new LonLat(sw_lon, ne_lat - h), new LonLat(sw_lon + w, ne_lat));
+}
 export const TILEGROUP_COMMON = 0;
-export const TILEGROUP_NORTH = 1;
-export const TILEGROUP_SOUTH = 2;
+export const TILEGROUP_NORTH = 20;
+export const TILEGROUP_SOUTH = 300;
+export function getTileGroupByLat(lat, maxLat = MAX_LAT) {
+    if (lat > maxLat) {
+        return TILEGROUP_NORTH;
+    }
+    else if (lat < -maxLat) {
+        return TILEGROUP_SOUTH;
+    }
+    return TILEGROUP_COMMON;
+}
 let _tempHigh = new Vec3();
 let _tempLow = new Vec3();
 let _v0 = new Vec3(), _v1 = new Vec3(), _v2 = new Vec3(), _v3 = new Vec3();
@@ -57,6 +78,7 @@ class Segment {
         this.gridSize = planet.terrain.gridSizeByZoom[tileZoom];
         this.fileGridSize = 0;
         this.tileZoom = tileZoom;
+        this.powTileZoom = 1 << tileZoom; //Math.pow(2, tileZoom);
         this.tileX = 0;
         this.tileXE = 0;
         this.tileXW = 0;
@@ -64,6 +86,7 @@ class Segment {
         this.tileYS = 0;
         this.tileY = 0;
         this.tileIndex = "";
+        this.elevationData = null;
         this._assignTileIndexes();
         /**
          * @toso: Check it should be Map<number, Material> instead of array
@@ -221,6 +244,8 @@ class Segment {
         if (this.plainReady && this.terrainIsLoading) {
             let _elevations = new Float32Array(elevations.length);
             _elevations.set(elevations);
+            this.elevationData = new Float32Array(elevations.length);
+            this.elevationData.set(elevations);
             this.planet._terrainWorker.make({ segment: this, elevations: _elevations });
             this.plainVerticesHigh = null;
             this.plainVerticesLow = null;
@@ -284,7 +309,7 @@ class Segment {
     }
     equalize() {
         // Equalization doesnt work correctly for gridSize equals 2
-        if (this.gridSize < 2) {
+        if (this.tileZoom < 2 || this.gridSize < 2) {
             return;
         }
         this.readyToEngage = true;
@@ -772,14 +797,16 @@ class Segment {
         const tileZoom = this.tileZoom;
         const extent = this._extent;
         const pole = mercator.POLE;
-        this.tileX = Math.round(Math.abs(-pole - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
-        this.tileY = Math.round(Math.abs(pole - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
-        const p2 = Math.pow(2, tileZoom);
+        // this.tileX = Math.round(Math.abs(-pole - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
+        // this.tileY = Math.round(Math.abs(pole - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
+        this.tileX = getTileCellIndex(extent.getCenter().lon, extent.getWidth(), -pole);
+        this.tileY = getTileCellIndex(extent.getCenter().lat, extent.getHeight(), pole);
+        const p2 = this.powTileZoom; //Math.pow(2, tileZoom);
         this.tileXE = (this.tileX + 1) % p2;
         this.tileXW = (p2 + this.tileX - 1) % p2;
         this.tileYN = this.tileY - 1;
         this.tileYS = this.tileY + 1;
-        this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, tileZoom);
+        this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, tileZoom, this._tileGroup);
     }
     initialize() {
         const p = this.planet;
@@ -836,16 +863,22 @@ class Segment {
         this._createPlainVertices();
         this.readyToEngage = true;
     }
+    _projToDeg(lon, lat) {
+        return LonLat.inverseMercator(lon, lat);
+    }
     _createPlainVertices() {
         const gridSize = this.planet.terrain.gridSizeByZoom[this.tileZoom];
-        const e = this._extent;
         const fgs = this.planet.terrain.plainGridSize;
+        const currGridSize = Math.max(fgs, gridSize);
+        const e = this._extent;
         const lonSize = e.getWidth();
-        const llStep = lonSize / Math.max(fgs, gridSize);
+        const latSize = e.getHeight();
+        const llStep = lonSize / currGridSize;
+        const ltStep = latSize / currGridSize;
         const esw_lon = e.southWest.lon;
         const ene_lat = e.northEast.lat;
         const dg = Math.max(fgs / gridSize, 1);
-        const gs = Math.max(fgs, gridSize) + 1;
+        const gs = currGridSize + 1;
         const r2 = this.planet.ellipsoid._invRadii2;
         const gsgs = gs * gs;
         const gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;
@@ -861,7 +894,7 @@ class Segment {
         let verts = this.plainVertices, vertsHigh = this.plainVerticesHigh, vertsLow = this.plainVerticesLow, norms = this.plainNormals, nmVerts = this.normalMapVertices, nmVertsHigh = this.normalMapVerticesHigh, nmVertsLow = this.normalMapVerticesLow, nmNorms = this.normalMapNormals;
         for (let k = 0; k < gsgs; k++) {
             let j = k % gs, i = ~~(k / gs);
-            let v = this.planet.ellipsoid.lonLatToCartesian(LonLat.inverseMercator(esw_lon + j * llStep, ene_lat - i * llStep));
+            let v = this.planet.ellipsoid.lonLatToCartesian(this._projToDeg(esw_lon + j * llStep, ene_lat - i * ltStep));
             let nx = v.x * r2.x, ny = v.y * r2.y, nz = v.z * r2.z;
             let l = 1.0 / Math.sqrt(nx * nx + ny * ny + nz * nz);
             let nxl = nx * l, nyl = ny * l, nzl = nz * l;
@@ -1040,8 +1073,8 @@ class Segment {
         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);
+                if (n.segment._transitionOpacity > 0 && !this.planet._fadingNodes.has(n.__id)) {
+                    this.planet._fadingNodes.set(n.__id, n);
                     n.segment._transitionOpacity = 2.0 - this._transitionOpacity;
                     if (n.segment._transitionOpacity === 0) {
                         this.node._fadingNodes.splice(i, 1);
@@ -1141,9 +1174,6 @@ class Segment {
         }
         return cache.buffer;
     }
-    /**
-     * @todo: replace to the strategy
-     */
     _collectVisibleNodes() {
         this.planet._visibleNodes[this.node.nodeId] = this.node;
     }
@@ -1162,13 +1192,6 @@ class Segment {
     getExtent() {
         return this._extent;
     }
-    /**
-     * @todo replace to the strategy
-     */
-    getNodeState() {
-        let vn = this.planet._visibleNodes[this.node.nodeId];
-        return (vn && vn.state) || NOTRENDERING;
-    }
     getNeighborSide(b) {
         if (this.tileY === b.tileY) {
             if (this.tileX === b.tileXE) {

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

@@ -23,7 +23,7 @@ declare class SegmentLonLat extends Segment {
     protected _assignTileIndexes(): void;
     protected _assignTileXIndexes(extent: Extent): void;
     protected _assignTileYIndexes(extent: Extent): void;
-    protected _createPlainVertices(): void;
+    protected _projToDeg(lon: number, lat: number): LonLat;
     protected _assignGlobalTextureCoordinates(): void;
     /**
      * @todo: replace to the strategy
@@ -40,9 +40,5 @@ declare class SegmentLonLat extends Segment {
     layerOverlap(layer: Layer): boolean;
     getDefaultTexture(): WebGLTextureExt | null;
     getExtentLonLat(): Extent;
-    /**
-     * @todo: replace to the strategy
-     */
-    getNodeState(): number;
 }
 export { SegmentLonLat };