@openglobus/og 0.17.1 → 0.18.0

package/src/{og/quadTree/Node.js → quadTree/Node.ts}

@@ -1,13 +1,15 @@
-"use strict";
-
-import { Extent } from "../Extent.js";
-import { LonLat } from "../LonLat.js";
-import { MAX, MIN } from "../math.js";
-import { Vec3 } from "../math/Vec3.js";
-import { MAX_LAT } from "../mercator.js";
-import { EPSG3857 } from "../proj/EPSG3857.js";
-import { EPSG4326 } from "../proj/EPSG4326.js";
-import { getMatrixSubArray, getMatrixSubArrayBoundsExt } from "../utils/shared.js";
+import {Extent} from "../Extent";
+import {EPSG3857} from "../proj/EPSG3857";
+import {EPSG4326} from "../proj/EPSG4326";
+import {getMatrixSubArray32, getMatrixSubArray64, getMatrixSubArrayBoundsExt} from "../utils/shared";
+import {LonLat} from "../LonLat";
+import {MAX, MIN} from "../math";
+import {MAX_LAT} from "../mercator";
+import {Planet} from "../scene/Planet";
+import {Segment} from "../segment/Segment";
+
+import {Vec2} from "../math/Vec2";
+import {Vec3} from "../math/Vec3";
 import {
     COMSIDE,
     E,
@@ -27,35 +29,76 @@ import {
     VISIBLE_DISTANCE,
     W,
     WALKTHROUGH
-} from "./quadTree.js";
+} from "./quadTree";
 
-import { TILEGROUP_COMMON, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "../segment/Segment.js";
+import {
+    TILEGROUP_COMMON,
+    TILEGROUP_NORTH,
+    TILEGROUP_SOUTH
+} from "../segment/Segment";
+
+import {PlanetCamera} from "../camera/PlanetCamera";
 
-let _tempHigh = new Vec3(), _tempLow = new Vec3();
+let _tempHigh = new Vec3(),
+    _tempLow = new Vec3();
+
+const _vertOrder: Vec2[] = [
+    new Vec2(0, 0), new Vec2(1, 0),
+    new Vec2(0, 1), new Vec2(1, 1)
+];
 
-const _vertOrder = [{ x: 0, y: 0 }, { x: 1, y: 0 }, { x: 0, y: 1 }, { x: 1, y: 1 }];
 const _neGridSize = Math.sqrt(_vertOrder.length) - 1;
 
-let BOUNDS = {
-    xmin: 0.0, ymin: 0.0, zmin: 0.0, xmax: 0.0, ymax: 0.0, zmax: 0.0
+type BoundsType = {
+    xmin: number; ymin: number; zmin: number;
+    xmax: number; ymax: number; zmax: number
+};
+
+let BOUNDS: BoundsType = {
+    xmin: 0.0, ymin: 0.0, zmin: 0.0,
+    xmax: 0.0, ymax: 0.0, zmax: 0.0
 };
 
 /**
  * Quad tree planet segment node.
  * @constructor
- * @param {Segment|og.planetSegment.SegmentLonLat} segmentPrototype - Planet segment node constructor.
- * @param {RenderNode} planet - Planet render node.
+ * @param {Segment} segmentPrototype - Planet segment node constructor.
+ * @param {Planet} planet - Planet scene instance.
  * @param {number} partId - NorthEast, SouthWest etc.
- * @param {quadTree.Node} parent - Parent of this node.
+ * @param {Node} parent - Parent of this node.
  * @param {number} id - Tree node identifier (id * 4 + 1);
  * @param {number} tileZoom - Deep index of the quad tree.
  * @param {Extent} extent - Planet segment extent.
  */
 class Node {
+    public SegmentPrototype: typeof Segment;
+    public planet: Planet;
+    public parentNode: Node | null;
+    public partId: number;
+    public nodeId: number;
+    public state: number | null;
+    public appliedTerrainNodeId: number;
+    public sideSizeLog2: [number, number, number, number];
+    public ready: boolean;
+    public neighbors: [Node[], Node[], Node[], Node[]];
+    public equalizedSideWithNodeId: number[];
+    public nodes: [Node, Node, Node, Node] | [];
+    public segment: Segment;
+    public _cameraInside: boolean;
+    public inFrustum: number;
+
+    constructor(
+        SegmentPrototype: typeof Segment,
+        planet: Planet,
+        partId: number,
+        parent: Node | null,
+        id: number,
+        tileZoom: number,
+        extent: Extent
+    ) {
+        planet._createdNodesCount++;
 
-    constructor(SegmentPrototype, planet, partId, parent, id, tileZoom, extent) {
         this.SegmentPrototype = SegmentPrototype;
-        planet._createdNodesCount++;
         this.planet = planet;
         this.parentNode = parent;
         this.partId = partId;
@@ -66,16 +109,15 @@ class Node {
         this.ready = false;
         this.neighbors = [[], [], [], []];
         this.equalizedSideWithNodeId = [this.nodeId, this.nodeId, this.nodeId, this.nodeId];
-        this.nodes = [null, null, null, null];
+        this.nodes = [];
         this.segment = new SegmentPrototype(this, planet, tileZoom, extent);
         this._cameraInside = false;
         this.inFrustum = 0;
         this.createBounds();
     }
 
-    createChildrenNodes() {
+    public createChildrenNodes() {
         this.ready = true;
-
         const p = this.planet;
         const ps = this.segment;
         const ext = ps._extent;
@@ -94,18 +136,23 @@ class Node {
         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)));
     }
 
-    createBounds() {
+    public createBounds() {
+
         let seg = this.segment;
+
         seg._setExtentLonLat();
+
         if (seg.tileZoom === 0) {
-            seg.setBoundingSphere(0.0, 0.0, 0.0, new Vec3(0.0, 0.0, seg.planet.ellipsoid._a));
-        } else if (seg.tileZoom < seg.planet.terrain.minZoom) {
+            seg.setBoundingSphere(0.0, 0.0, 0.0, new Vec3(0.0, 0.0, seg.planet.ellipsoid.equatorialSize));
+        } else if (seg.tileZoom < seg.planet.terrain!.minZoom) {
             seg.createBoundsByExtent();
         } else {
             seg.createBoundsByParent();
         }
 
-        let x = seg.bsphere.center.x, y = seg.bsphere.center.y, z = seg.bsphere.center.z;
+        let x = seg.bsphere.center.x,
+            y = seg.bsphere.center.y,
+            z = seg.bsphere.center.z;
 
         let length = 1.0 / Math.sqrt(x * x + y * y + z * z);
         seg.centerNormal.x = x * length;
@@ -113,11 +160,11 @@ class Node {
         seg.centerNormal.z = z * length;
     }
 
-    getState() {
+    public getState(): number | null {
         if (this.state === -1) {
             return this.state;
         }
-        var pn = this.parentNode;
+        let pn = this.parentNode;
         while (pn) {
             if (pn.state !== WALKTHROUGH) {
                 return NOTRENDERING;
@@ -130,22 +177,23 @@ class Node {
     /**
      * Returns the same deep existent neighbour node.
      * @public
-     * @param {Number} side - Neighbour side index e.g. og.quadTree.N, og.quadTree.W etc.
-     * @returns {quadTree.Node} -
+     * @param {number} side - Neighbour side index e.g. og.quadTree.N, og.quadTree.W etc.
+     * @returns {Node} -
      */
-    getEqualNeighbor(side) {
-        var pn = this;
-        var part = NEIGHBOUR[side][pn.partId];
+    public getEqualNeighbor(side: number): Node | undefined {
+        let pn: Node = this;
+        let part = NEIGHBOUR[side][pn.partId];
         if (part !== -1) {
-            return pn.parentNode.nodes[part];
+            // (!) it means that we would never ask to get head node neighbors
+            return pn.parentNode!.nodes[part];
         } else {
-            var pathId = [];
+            let pathId = [];
             while (pn.parentNode) {
                 pathId.push(pn.partId);
                 part = NEIGHBOUR[side][pn.partId];
                 pn = pn.parentNode;
                 if (part !== -1) {
-                    var i = pathId.length;
+                    let i = pathId.length;
                     side = OPSIDE[side];
                     while (pn && i--) {
                         part = OPPART[side][pathId[i]];
@@ -157,20 +205,24 @@ class Node {
         }
     }
 
-    isBrother(node) {
-        return !(this.parentNode || node.parentNode) || this.parentNode.id === node.parentNode.id;
-    }
+    // public isBrother(node: Node): boolean {
+    //     return !(this.parentNode || node.parentNode) || (this.parentNode!.nodeId === node.parentNode!.nodeId);
+    // }
 
-    renderTree(cam, maxZoom, terrainReadySegment, stopLoading) {
+    public renderTree(cam: PlanetCamera, maxZoom?: number | null, terrainReadySegment?: Segment | null, stopLoading?: boolean) {
         if (this.planet._renderedNodes.length >= MAX_RENDERED_NODES) {
             return;
         }
 
         this.state = WALKTHROUGH;
 
+        // @ts-ignore
         this.neighbors[0] = null;
+        // @ts-ignore
         this.neighbors[1] = null;
+        // @ts-ignore
         this.neighbors[2] = null;
+        // @ts-ignore
         this.neighbors[3] = null;
 
         this.neighbors[0] = [];
@@ -229,7 +281,7 @@ class Node {
             let h = Math.abs(cam._lonLat.height);
 
             let eye = cam.eye;
-            let horizonDist = eye.length2() - this.planet.ellipsoid._b2;
+            let horizonDist = eye.length2() - this.planet.ellipsoid.polarSizeSqr;
 
             let altVis = seg.tileZoom > 19 || (seg.tileZoom < 5 && !seg.terrainReady) || seg.tileZoom < 2;
 
@@ -240,12 +292,13 @@ class Node {
             }
 
             if ((this.inFrustum && (altVis || h > 10000.0)) || this._cameraInside) {
+                //@todo: replace to the strategy
                 seg._collectVisibleNodes();
             }
 
             if (seg.tileZoom < 2) {
                 this.traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading);
-            } 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;
@@ -267,20 +320,20 @@ class Node {
         }
     }
 
-    traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading) {
+    public traverseNodes(cam: PlanetCamera, maxZoom?: number | null, terrainReadySegment?: Segment | null, stopLoading?: boolean) {
         if (!this.ready) {
             this.createChildrenNodes();
         }
 
         let n = this.nodes;
 
-        n[0].renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
-        n[1].renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
-        n[2].renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
-        n[3].renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
+        n[0]!.renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
+        n[1]!.renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
+        n[2]!.renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
+        n[3]!.renderTree(cam, maxZoom, terrainReadySegment, stopLoading);
     }
 
-    renderNode(inFrustum, onlyTerrain, terrainReadySegment, stopLoading) {
+    public renderNode(inFrustum: number, onlyTerrain?: boolean, terrainReadySegment?: Segment | null, stopLoading?: boolean) {
         let seg = this.segment;
 
         // Create and load terrain data
@@ -289,7 +342,7 @@ class Node {
                 seg.initialize();
             }
 
-            this.whileTerrainLoading(terrainReadySegment, stopLoading);
+            this.whileTerrainLoading(terrainReadySegment);
 
             if (!seg.plainProcessing) {
                 seg.createPlainSegmentAsync();
@@ -326,26 +379,25 @@ class Node {
     }
 
     /**
-     * Seraching for neighbours and pickup current node to render processing.
+     * Searching for neighbours and picking up current node to render processing.
      * @public
      */
-    addToRender(inFrustum) {
+    public addToRender(inFrustum: number) {
         this.state = RENDERING;
 
-        var nodes = this.planet._renderedNodes;
+        let nodes = this.planet._renderedNodes;
 
         for (let i = nodes.length - 1; i >= 0; --i) {
-            var ni = nodes[i];
-
-            var cs = this.getCommonSide(ni);
+            const ni = nodes[i];
+            const cs = this.getCommonSide(ni);
 
             if (cs !== -1) {
-                var opcs = OPSIDE[cs];
+                const opcs = OPSIDE[cs];
 
                 if (this.neighbors[cs].length === 0 || ni.neighbors[opcs].length === 0) {
-                    var ap = this.segment;
-                    var bp = ni.segment;
-                    var ld = ap.gridSize / (bp.gridSize * Math.pow(2, bp.tileZoom - ap.tileZoom));
+                    const ap = this.segment;
+                    const bp = ni.segment;
+                    const ld = ap.gridSize / (bp.gridSize * Math.pow(2, bp.tileZoom - ap.tileZoom));
 
                     let cs_size = ap.gridSize,
                         opcs_size = bp.gridSize;
@@ -374,7 +426,8 @@ class Node {
             this.planet._terrainCompleted = false;
         }
 
-        let k = 0, rf = this.planet._renderedNodesInFrustum;
+        let k = 0,
+            rf = this.planet._renderedNodesInFrustum;
         while (inFrustum) {
             if (inFrustum & 1) {
                 rf[k].push(this);
@@ -384,17 +437,19 @@ class Node {
         }
     }
 
-    getCommonSide(node) {
-        var as = this.segment, bs = node.segment;
+    public getCommonSide(node: Node): number {
+        const as = this.segment;
+        const bs = node.segment;
 
         if (as.tileZoom === bs.tileZoom && as._tileGroup === bs._tileGroup) {
             return as.getNeighborSide(bs);
         } else {
-            var a = as._extentLonLat, b = bs._extentLonLat;
+            const a = as._extentLonLat;
+            const b = bs._extentLonLat;
 
-            var a_ne = a.northEast, a_sw = a.southWest, b_ne = b.northEast, b_sw = b.southWest;
+            let a_ne = a.northEast, a_sw = a.southWest, b_ne = b.northEast, b_sw = b.southWest;
 
-            var a_ne_lon = a_ne.lon, a_ne_lat = a_ne.lat, a_sw_lon = a_sw.lon, a_sw_lat = a_sw.lat, b_ne_lon = b_ne.lon,
+            let a_ne_lon = a_ne.lon, a_ne_lat = a_ne.lat, a_sw_lon = a_sw.lon, a_sw_lat = a_sw.lat, b_ne_lon = b_ne.lon,
                 b_ne_lat = b_ne.lat, b_sw_lon = b_sw.lon, b_sw_lat = b_sw.lat;
 
             if (as._tileGroup === bs._tileGroup) {
@@ -427,75 +482,75 @@ class Node {
         return -1;
     }
 
-    // TODO: test test test
-    ___getCommonSide___(b) {
-        var 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 = 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;
+    // // 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;
+    // }
+
+    public whileNormalMapCreating() {
 
-                while (i--) {
-                    _n = _n && COMSIDE[p.partId][side];
-                }
-
-                if (_n) {
-                    return OPSIDE[side];
-                }
-            }
-        }
-
-        return -1;
-    }
-
-    whileNormalMapCreating() {
-
-        let seg = this.segment;
+        const seg = this.segment;
 
-        if (/*seg.tileZoom <= seg.planet.terrain.maxNativeZoom && */!seg.terrainIsLoading && seg.terrainExists && !seg._inTheQueue) {
+        if (!seg.terrainIsLoading && seg.terrainExists && !seg._inTheQueue) {
             seg.planet._normalMapCreator.queue(seg);
         }
 
-        let pn = this;
+        let pn: Node = this;
         while (pn.parentNode && !pn.segment.normalMapReady) {
             pn = pn.parentNode;
         }
 
-        let dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1);
+        const dZ2 = 2 << (seg.tileZoom - pn.segment.tileZoom - 1);
 
         seg.normalMapTexture = pn.segment.normalMapTexture;
         seg.normalMapTextureBias[0] = seg.tileX - pn.segment.tileX * dZ2;
@@ -503,10 +558,11 @@ class Node {
         seg.normalMapTextureBias[2] = 1.0 / dZ2;
     }
 
-    whileTerrainLoading(terrainReadySegment, stopLoading) {
+    public whileTerrainLoading(terrainReadySegment?: Segment | null) {
+
         const seg = this.segment;
 
-        let pn = this;
+        let pn: Node = this;
 
         if (terrainReadySegment && terrainReadySegment.terrainReady) {
             pn = terrainReadySegment.node;
@@ -517,21 +573,21 @@ 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 pseg = pn.segment;
+            const pseg = pn.segment;
 
-            let tempVertices,
-                tempVerticesHigh,
-                tempVerticesLow,
-                noDataVertices;
+            let tempVertices: Float64Array,
+                tempVerticesHigh: Float32Array,
+                tempVerticesLow: Float32Array,
+                noDataVertices: Uint8Array;
 
             this.appliedTerrainNodeId = pn.nodeId;
             this.equalizedSideWithNodeId[N] = this.equalizedSideWithNodeId[E] = this.equalizedSideWithNodeId[S] = this.equalizedSideWithNodeId[W] = this.appliedTerrainNodeId;
 
-
             let gridSize = pn.segment.gridSize / dZ2,
                 gridSizeExt = pn.segment.fileGridSize / dZ2;
 
@@ -554,8 +610,24 @@ class Node {
                     noDataVertices = new Uint8Array(len / 3);
                 }
 
-                getMatrixSubArrayBoundsExt(pseg.terrainVertices, pseg.terrainVerticesHigh, pseg.terrainVerticesLow, pseg.noDataVertices, pseg.gridSize, gridSize * offsetY, gridSize * offsetX, gridSize, tempVertices, tempVerticesHigh, tempVerticesLow, BOUNDS, noDataVertices);
+                getMatrixSubArrayBoundsExt(
+                    pseg.terrainVertices!,
+                    pseg.terrainVerticesHigh!,
+                    pseg.terrainVerticesLow!,
+                    pseg.noDataVertices!,
+                    pseg.gridSize,
+                    gridSize * offsetY,
+                    gridSize * offsetX,
+                    gridSize,
+                    tempVertices,
+                    tempVerticesHigh,
+                    tempVerticesLow,
+                    BOUNDS,
+                    noDataVertices!
+                );
+
             } else if (gridSizeExt >= 1 && pn.segment.terrainExists) {
+
                 seg.gridSize = gridSizeExt;
 
                 let len = (gridSizeExt + 1) * (gridSizeExt + 1) * 3;
@@ -567,17 +639,34 @@ class Node {
                     noDataVertices = new Uint8Array(len / 3);
                 }
 
-                getMatrixSubArrayBoundsExt(pseg.normalMapVertices, pseg.normalMapVerticesHigh, pseg.normalMapVerticesLow, pseg.noDataVertices, pn.segment.fileGridSize, gridSizeExt * offsetY, gridSizeExt * offsetX, gridSizeExt, tempVertices, tempVerticesHigh, tempVerticesLow, BOUNDS, noDataVertices);
+                getMatrixSubArrayBoundsExt(
+                    pseg.normalMapVertices!,
+                    pseg.normalMapVerticesHigh!,
+                    pseg.normalMapVerticesLow!,
+                    pseg.noDataVertices!,
+                    pn.segment.fileGridSize,
+                    gridSizeExt * offsetY,
+                    gridSizeExt * offsetX,
+                    gridSizeExt,
+                    tempVertices,
+                    tempVerticesHigh,
+                    tempVerticesLow,
+                    BOUNDS,
+                    noDataVertices!
+                );
+
             } else {
+
                 seg.gridSize = _neGridSize;
 
-                let i0 = Math.floor(gridSize * offsetY), j0 = Math.floor(gridSize * offsetX);
+                let i0 = Math.floor(gridSize * offsetY),
+                    j0 = Math.floor(gridSize * offsetX);
 
                 let bigOne;
                 if (pseg.gridSize === 1) {
-                    bigOne = pseg.terrainVertices;
+                    bigOne = pseg.terrainVertices!;
                 } else {
-                    bigOne = getMatrixSubArray(pseg.terrainVertices, pseg.gridSize, i0, j0, 1);
+                    bigOne = getMatrixSubArray64(pseg.terrainVertices!, pseg.gridSize, i0, j0, 1);
                 }
 
                 let insideSize = 1.0 / gridSize;
@@ -606,10 +695,7 @@ class Node {
                     if (vi_y + vi_x < insideSize) {
                         coords = vn.scaleTo(vi_x_is).addA(vw.scaleTo(vi_y_is)).addA(v_lt);
                     } else {
-                        coords = vs
-                            .scaleTo(1 - vi_x_is)
-                            .addA(ve.scaleTo(1 - vi_y_is))
-                            .addA(v_rb);
+                        coords = vs.scaleTo(1 - vi_x_is).addA(ve.scaleTo(1 - vi_y_is)).addA(v_rb);
                     }
 
                     Vec3.doubleToTwoFloats(coords, _tempHigh, _tempLow);
@@ -647,12 +733,12 @@ class Node {
             seg.tempVerticesHigh = tempVerticesHigh;
             seg.tempVerticesLow = tempVerticesLow;
 
-            seg.noDataVertices = noDataVertices;
+            seg.noDataVertices = noDataVertices!;
 
             seg.setBoundingVolume(BOUNDS.xmin, BOUNDS.ymin, BOUNDS.zmin, BOUNDS.xmax, BOUNDS.ymax, BOUNDS.zmax);
 
-            if (seg.tileZoom > seg.planet.terrain.maxZoom) {
-                if (pn.segment.tileZoom >= seg.planet.terrain.maxZoom) {
+            if (seg.tileZoom > seg.planet.terrain!.maxZoom) {
+                if (pn.segment.tileZoom >= seg.planet.terrain!.maxZoom) {
 
                     seg._plainRadius = pn.segment._plainRadius / dZ2;
 
@@ -672,57 +758,57 @@ class Node {
                         seg.normalMapVertices = tempVertices;
                         seg.fileGridSize = Math.sqrt(tempVertices.length / 3) - 1;
 
-                        let fgs = Math.sqrt(pseg.normalMapNormals.length / 3) - 1, fgsZ = fgs / dZ2;
+                        let fgs = Math.sqrt(pseg.normalMapNormals!.length / 3) - 1, fgsZ = fgs / dZ2;
 
                         if (fgs > 1) {
-                            seg.normalMapNormals = getMatrixSubArray(pseg.normalMapNormals, fgs, fgsZ * offsetY, fgsZ * offsetX, fgsZ);
+                            seg.normalMapNormals = getMatrixSubArray32(pseg.normalMapNormals!, fgs, fgsZ * offsetY, fgsZ * offsetX, fgsZ);
                         } else {
                             // TODO: interpolation
                             seg.normalMapNormals = pseg.normalMapNormals;
                         }
                     }
                 }
-                // else {
-                //     pn = this;
-                //     while (pn.parentNode && pn.segment.tileZoom !== seg.planet.terrain.maxZoom) {
-                //         pn = pn.parentNode;
-                //     }
-                //
-                //     let pns = pn.segment;
-                //
-                //     if (!pns.initialized) {
-                //         pns.initialize();
-                //     }
-                //
-                //     if (!pns.plainProcessing) {
-                //         pn.segment.createPlainSegmentAsync();
-                //     }
-                //
-                //     if (pns.plainReady && !stopLoading) {
-                //         pns.loadTerrain(true);
-                //     }
-                // }
             }
         }
     }
 
-    destroy() {
+    public destroy() {
+
         this.state = NOTRENDERING;
         this.segment.destroySegment();
-        var n = this.neighbors;
-        n[N] && n[N].neighbors && (n[N].neighbors[S] = []);
-        n[E] && n[E].neighbors && (n[E].neighbors[W] = []);
-        n[S] && n[S].neighbors && (n[S].neighbors[N] = []);
-        n[W] && n[W].neighbors && (n[W].neighbors[E] = []);
+
+        let n = this.neighbors;
+        for (let i = 0; i < n.length; i++) {
+            let ni = n[i];
+            if (ni) {
+                for (let j = 0; j < ni.length; j++) {
+                    let nij = ni[j];
+                    if (nij && nij.neighbors) {
+                        // @ts-ignore
+                        nij.neighbors[N] = null;
+                        // @ts-ignore
+                        nij.neighbors[E] = null;
+                        // @ts-ignore
+                        nij.neighbors[S] = null;
+                        // @ts-ignore
+                        nij.neighbors[W] = null;
+                    }
+                }
+            }
+        }
+
+        // @ts-ignore
         this.neighbors = null;
+        // @ts-ignore
         this.parentNode = null;
+        // @ts-ignore
         this.sideSizeLog2 = null;
+        // @ts-ignore
         this.segment = null;
     }
 
-    clearTree() {
-        var state = this.getState();
-
+    public clearTree() {
+        const state = this.getState();
         if (state === NOTRENDERING || state === RENDERING) {
             this.destroyBranches();
         } else {
@@ -732,54 +818,60 @@ class Node {
         }
     }
 
-    clearBranches() {
+    public clearBranches() {
         for (let i = 0; i < this.nodes.length; i++) {
-            this.nodes[i].clearBranches();
-            this.nodes[i].segment.deleteMaterials();
+            this.nodes[i]!.clearBranches();
+            this.nodes[i]!.segment.deleteMaterials();
         }
     }
 
-    destroyBranches() {
+    public destroyBranches() {
         if (this.ready) {
-            var nodesToRemove = [], i;
+            let nodesToRemove: Node[] = [],
+                i;
 
             for (i = 0; i < this.nodes.length; i++) {
-                nodesToRemove[i] = this.nodes[i];
+                nodesToRemove[i] = this.nodes[i]!;
             }
 
             this.ready = false;
-            this.nodes.length = 0;
+            this.nodes = [];
 
             for (i = 0; i < nodesToRemove.length; i++) {
                 nodesToRemove[i].destroyBranches();
                 nodesToRemove[i].destroy();
+                //@ts-ignore
                 nodesToRemove[i] = null;
             }
 
             nodesToRemove.length = 0;
+
+            // @ts-ignore
             nodesToRemove = null;
         }
     }
 
-    traverseTree(callback) {
+    public traverseTree(callback: Function) {
         callback(this);
         if (this.ready) {
             for (let i = 0; i < this.nodes.length; i++) {
-                this.nodes[i].traverseTree(callback);
+                this.nodes[i]!.traverseTree(callback);
             }
         }
     }
 
-    getOffsetOppositeNeighbourSide(neighbourNode, side) {
-        let pNode = this, neighbourZoom = neighbourNode.segment.tileZoom, offset = 0;
+    public getOffsetOppositeNeighbourSide(neighbourNode: Node, side: number): number {
+        let pNode: Node = this,
+            neighbourZoom = neighbourNode.segment.tileZoom,
+            offset = 0;
 
         while (pNode.segment.tileZoom > neighbourZoom) {
             offset += PARTOFFSET[pNode.partId][side] / (1 << (pNode.segment.tileZoom - neighbourZoom));
-            pNode = pNode.parentNode;
+            pNode = pNode.parentNode!;
         }
 
         return offset;
     }
 }
 
-export { Node };
+export {Node};