@openglobus/og 0.21.0 → 0.22.1

package/lib/js/quadTree/EntityCollectionsTreeStrategy.js

@@ -0,0 +1,49 @@
+import { QueueArray } from "../QueueArray";
+export class EntityCollectionsTreeStrategy {
+    constructor(layer, nodeCapacity) {
+        this._layer = layer;
+        this._nodeCapacity = nodeCapacity;
+        this._secondPASS = [];
+        this._counter = 0;
+        this._deferredEntitiesPendingQueue = new QueueArray();
+        this._renderingNodes = {};
+    }
+    insertEntity(entity, rightNow = false) {
+    }
+    setPickingEnabled(pickingEnabled) {
+    }
+    dispose() {
+    }
+    insertEntities(entitiesForTree) {
+    }
+    collectVisibleEntityCollections(outArr) {
+    }
+    _queueDeferredNode(node) {
+        if (this._layer.getVisibility()) {
+            node._inTheQueue = true;
+            if (this._counter >= 1) {
+                this._deferredEntitiesPendingQueue.push(node);
+            }
+            else {
+                this._execDeferredNode(node);
+            }
+        }
+    }
+    _execDeferredNode(node) {
+        this._counter++;
+        requestAnimationFrame(() => {
+            node.applyCollection();
+            this._counter--;
+            if (this._deferredEntitiesPendingQueue.length && this._counter < 1) {
+                while (this._deferredEntitiesPendingQueue.length) {
+                    let n = this._deferredEntitiesPendingQueue.pop();
+                    n._inTheQueue = false;
+                    if (n.isVisible()) {
+                        this._execDeferredNode(n);
+                        return;
+                    }
+                }
+            }
+        });
+    }
+}

package/lib/js/quadTree/Node.js

@@ -1,10 +1,8 @@
 import { Extent } from "../Extent";
 import { EPSG3857 } from "../proj/EPSG3857";
-import { EPSG4326 } from "../proj/EPSG4326";
 import { binaryInsert, getMatrixSubArray32, getMatrixSubArray64, getMatrixSubArrayBoundsExt } from "../utils/shared";
 import { LonLat } from "../LonLat";
 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, W, WALKTHROUGH } from "./quadTree";
@@ -161,10 +159,10 @@ class Node {
         // Search a node which the camera is flying over.
         if (!this.parentNode || this.parentNode._cameraInside) {
             let inside;
-            if (Math.abs(cam._lonLat.lat) <= MAX_LAT && seg._projection.id === EPSG3857.id) {
+            if ( /*Math.abs(cam._lonLat.lat) <= MAX_LAT && */seg._projection.id === EPSG3857.id) {
                 inside = seg._extent.isInside(cam._lonLatMerc);
             }
-            else if (seg._projection.id === EPSG4326.id) {
+            else /*if (seg._projection.id === EPSG4326.id)*/ {
                 inside = seg._extent.isInside(cam._lonLat);
             }
             if (inside) {
@@ -182,17 +180,14 @@ class Node {
             }
         }
         else {
-            let commonFrustumFlag = 1 << (numFrustums - 1 - 1);
-            for (let i = 0; commonFrustumFlag && i < numFrustums; i++) {
+            for (let i = 0; i < numFrustums; i++) {
                 if (seg.terrainReady) {
                     if (frustums[i].containsBox(seg.bbox)) {
-                        commonFrustumFlag >>= 1;
                         this.inFrustum |= 1 << i;
                     }
                 }
                 else {
                     if (frustums[i].containsSphere(seg.bsphere)) {
-                        commonFrustumFlag >>= 1;
                         this.inFrustum |= 1 << i;
                     }
                 }
@@ -200,11 +195,11 @@ class Node {
         }
         if (this.inFrustum || this._cameraInside || seg.tileZoom < 3) {
             let h = Math.abs(cam._lonLat.height);
-            let horizonDist = cam.eye.length2() - this.planet.ellipsoid.polarSizeSqr;
+            let horizonDist = cam.eye.length2() - 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*/
+                and not to go through nodes from the opposite of the globe*/
                 (seg.tileZoom < 6 && !seg.terrainReady);
             altVis = altVis ||
                 cam.eye.distance2(seg._sw) < horizonDist ||
@@ -212,8 +207,7 @@ class Node {
                 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();
+                planet.quadTreeStrategy.collectVisibleNode(this);
             }
             if (seg.tileZoom < 2) {
                 this.traverseNodes(cam, maxZoom, terrainReadySegment, stopLoading, zoomPassNode);

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

@@ -1,8 +1,10 @@
 import { Layer } from "../layer/Layer";
+import { Vector } from "../layer/Vector";
 import { Node } from "../quadTree/Node";
 import { Planet } from "../scene/Planet";
 import { Proj } from "../proj/Proj";
 import { LonLat } from "../LonLat";
+import { EntityCollectionsTreeStrategy } from "./EntityCollectionsTreeStrategy";
 export declare class QuadTreeStrategy {
     name: string;
     projection: Proj;
@@ -13,16 +15,25 @@ export declare class QuadTreeStrategy {
      * @type {Node[]}
      */
     protected _quadTreeList: Node[];
+    /**
+     * Current visible mercator segments tree nodes array.
+     * @public
+     * @type {Node}
+     */
+    _visibleNodes: Record<number, Node>;
     constructor(planet: Planet, name?: string, proj?: Proj);
+    createEntitiCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EntityCollectionsTreeStrategy;
     destroyBranches(): void;
     clearLayerMaterial(layer: Layer): void;
     get planet(): Planet;
     init(): void;
     preRender(): void;
     preLoad(): void;
+    protected _clearVisibleNodes(): void;
     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];
+    collectVisibleNode(node: Node): void;
 }

package/lib/js/quadTree/QuadTreeStrategy.js

@@ -1,12 +1,17 @@
 import { EPSG3857 } from "../proj/EPSG3857";
 import { getTileCellExtent, getTileCellIndex, TILEGROUP_COMMON } from "../segment/Segment";
 import { Extent } from "../Extent";
+import { EntityCollectionsTreeStrategy } from "./EntityCollectionsTreeStrategy";
 export class QuadTreeStrategy {
     constructor(planet, name = "", proj = EPSG3857) {
         this.name = name;
         this.projection = proj;
         this._planet = planet;
         this._quadTreeList = [];
+        this._visibleNodes = {};
+    }
+    createEntitiCollectionsTreeStrategy(layer, nodeCapacity) {
+        return new EntityCollectionsTreeStrategy(layer, nodeCapacity);
     }
     destroyBranches() {
         for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
@@ -55,7 +60,11 @@ export class QuadTreeStrategy {
             }
         }
     }
+    _clearVisibleNodes() {
+        this._visibleNodes = {};
+    }
     collectRenderNodes() {
+        this._clearVisibleNodes();
         for (let i = 0; i < this._quadTreeList.length; i++) {
             this._quadTreeList[i].renderTree(this._planet.camera, 0, null);
         }
@@ -83,4 +92,7 @@ export class QuadTreeStrategy {
         let i = gridSize - Math.ceil((coords.lat - extent.southWest.lat) / sizeImgH) - 1, j = Math.floor((coords.lon - extent.southWest.lon) / sizeImgW);
         return [i, j];
     }
+    collectVisibleNode(node) {
+        this._visibleNodes[node.nodeId] = node;
+    }
 }

package/lib/js/quadTree/earth/EarthEntityCollectionNodeLonLat.d.ts

@@ -0,0 +1,18 @@
+import { EarthEntityCollectionsTreeStrategy } from "./EarthEntityCollectionsTreeStrategy";
+import { Extent } from "../../Extent";
+import { Planet } from "../../scene/Planet";
+import { LonLat } from "../../LonLat";
+import { Entity } from "../../entity/Entity";
+import { EntityCollection } from "../../entity/EntityCollection";
+import { EntityCollectionNode, NodesDict } from "../EntityCollectionNode";
+export declare class EarthEntityCollectionNodeLonLat extends EntityCollectionNode {
+    isNorth: boolean;
+    strategy: EarthEntityCollectionsTreeStrategy;
+    constructor(strategy: EarthEntityCollectionsTreeStrategy, partId: number, parent: EarthEntityCollectionNodeLonLat | null, extent: Extent, planet: Planet, zoom: number);
+    createChildrenNodes(): void;
+    protected _setExtentBounds(): void;
+    __setLonLat__(entity: Entity): LonLat;
+    isVisible(): boolean;
+    isInside(entity: Entity): boolean;
+    renderCollection(outArr: EntityCollection[], visibleNodes: NodesDict, renderingNode: number): void;
+}

package/lib/js/quadTree/earth/EarthEntityCollectionNodeLonLat.js

@@ -0,0 +1,74 @@
+import { Extent } from "../../Extent";
+import { LonLat } from "../../LonLat";
+import { NE, NW, SE, SW } from "../quadTree";
+import { EntityCollectionNode } from "../EntityCollectionNode";
+export class EarthEntityCollectionNodeLonLat extends EntityCollectionNode {
+    constructor(strategy, partId, parent, extent, planet, zoom) {
+        super(strategy, partId, parent, extent, planet, zoom);
+        this.strategy = strategy;
+        this.isNorth = false;
+    }
+    createChildrenNodes() {
+        const s = this.strategy;
+        const ext = this.extent;
+        const size_x = ext.getWidth() * 0.5;
+        const size_y = ext.getHeight() * 0.5;
+        const ne = ext.northEast;
+        const sw = ext.southWest;
+        const c = new LonLat(sw.lon + size_x, sw.lat + size_y);
+        const nd = this.childrenNodes;
+        const p = this.layer._planet;
+        const z = this.zoom + 1;
+        nd[NW] = new EarthEntityCollectionNodeLonLat(s, NW, this, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)), p, z);
+        nd[NE] = new EarthEntityCollectionNodeLonLat(s, NE, this, new Extent(c, new LonLat(ne.lon, ne.lat)), p, z);
+        nd[SW] = new EarthEntityCollectionNodeLonLat(s, SW, this, new Extent(new LonLat(sw.lon, sw.lat), c), p, z);
+        nd[SE] = new EarthEntityCollectionNodeLonLat(s, SE, this, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)), p, z);
+    }
+    _setExtentBounds() {
+        if (this.extent.northEast.lat > 0) {
+            this.isNorth = true;
+        }
+        this.bsphere.setFromExtent(this.layer._planet.ellipsoid, this.extent);
+    }
+    __setLonLat__(entity) {
+        if (entity._lonLat.isZero()) {
+            entity._lonLat = this.layer._planet.ellipsoid.cartesianToLonLat(entity._cartesian);
+        }
+        return entity._lonLat;
+    }
+    isVisible() {
+        if (this.isNorth && this.strategy._renderingNodesNorth[this.nodeId]) {
+            return true;
+        }
+        else if (this.strategy._renderingNodesSouth[this.nodeId]) {
+            return true;
+        }
+        return false;
+    }
+    isInside(entity) {
+        return this.extent.isInside(entity._lonLat);
+    }
+    renderCollection(outArr, visibleNodes, renderingNode) {
+        if (this.isNorth) {
+            this.strategy._renderingNodesNorth[this.nodeId] = true;
+        }
+        else {
+            this.strategy._renderingNodesSouth[this.nodeId] = true;
+        }
+        if (this.deferredEntities.length && !this._inTheQueue) {
+            if (this.layer.async) {
+                this.strategy._queueDeferredNode(this);
+            }
+            else {
+                this.applyCollection();
+            }
+        }
+        const ec = this.entityCollection;
+        ec._fadingOpacity = this.layer._fadingOpacity;
+        ec.scaleByDistance = this.layer.scaleByDistance;
+        ec.pickingScale = this.layer.pickingScale;
+        if (!ec.isEmpty()) {
+            outArr.push(ec);
+        }
+    }
+}

package/lib/js/quadTree/earth/EarthEntityCollectionsTreeStrategy.d.ts

@@ -0,0 +1,19 @@
+import { EntityCollectionNode } from "../EntityCollectionNode";
+import { EarthEntityCollectionNodeLonLat } from "./EarthEntityCollectionNodeLonLat";
+import { Vector } from "../../layer/Vector";
+import { Entity } from "../../entity/Entity";
+import { EntityCollection } from "../../entity/EntityCollection";
+import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
+export declare class EarthEntityCollectionsTreeStrategy extends EntityCollectionsTreeStrategy {
+    protected _entityCollectionsTree: EntityCollectionNode;
+    protected _entityCollectionsTreeNorth: EarthEntityCollectionNodeLonLat;
+    protected _entityCollectionsTreeSouth: EarthEntityCollectionNodeLonLat;
+    _renderingNodesNorth: Record<number, boolean>;
+    _renderingNodesSouth: Record<number, boolean>;
+    constructor(layer: Vector, nodeCapacity: number);
+    insertEntity(entity: Entity, rightNow?: boolean): void;
+    setPickingEnabled(pickingEnabled: boolean): void;
+    dispose(): void;
+    insertEntities(entitiesForTree: Entity[]): void;
+    collectVisibleEntityCollections(outArr: EntityCollection[]): void;
+}

package/lib/js/quadTree/earth/EarthEntityCollectionsTreeStrategy.js

@@ -0,0 +1,103 @@
+import { EntityCollectionNode } from "../EntityCollectionNode";
+import { EarthEntityCollectionNodeLonLat } from "./EarthEntityCollectionNodeLonLat";
+import * as quadTree from "../quadTree";
+import { Extent } from "../../Extent";
+import * as mercator from "../../mercator";
+import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
+export class EarthEntityCollectionsTreeStrategy extends EntityCollectionsTreeStrategy {
+    constructor(layer, nodeCapacity) {
+        super(layer, nodeCapacity);
+        let planet = layer._planet;
+        this._entityCollectionsTree = new EntityCollectionNode(this, quadTree.NW, null, Extent.createFromArray([-20037508.34, -20037508.34, 20037508.34, 20037508.34]), planet, 0);
+        this._entityCollectionsTreeNorth = new EarthEntityCollectionNodeLonLat(this, quadTree.NW, null, Extent.createFromArray([-180, mercator.MAX_LAT, 180, 90]), planet, 0);
+        this._entityCollectionsTreeSouth = new EarthEntityCollectionNodeLonLat(this, quadTree.NW, null, Extent.createFromArray([-180, -90, 180, mercator.MIN_LAT]), planet, 0);
+        this._renderingNodes = {};
+        this._renderingNodesNorth = {};
+        this._renderingNodesSouth = {};
+    }
+    insertEntity(entity, rightNow = false) {
+        if (entity._lonLat.lat > mercator.MAX_LAT) {
+            this._entityCollectionsTreeNorth.__setLonLat__(entity);
+            this._entityCollectionsTreeNorth.insertEntity(entity, rightNow);
+        }
+        else if (entity._lonLat.lat < mercator.MIN_LAT) {
+            this._entityCollectionsTreeSouth.__setLonLat__(entity);
+            this._entityCollectionsTreeSouth.insertEntity(entity, rightNow);
+        }
+        else {
+            this._entityCollectionsTree.__setLonLat__(entity);
+            this._entityCollectionsTree.insertEntity(entity, rightNow);
+        }
+    }
+    setPickingEnabled(pickingEnabled) {
+        this._entityCollectionsTree && this._entityCollectionsTree.traverseTree((node) => {
+            node.entityCollection.setPickingEnabled(pickingEnabled);
+        });
+        this._entityCollectionsTreeNorth && this._entityCollectionsTreeNorth.traverseTree((node) => {
+            node.entityCollection.setPickingEnabled(pickingEnabled);
+        });
+        this._entityCollectionsTreeSouth && this._entityCollectionsTreeSouth.traverseTree((node) => {
+            node.entityCollection.setPickingEnabled(pickingEnabled);
+        });
+    }
+    dispose() {
+        //@ts-ignore
+        this._entityCollectionsTree = null;
+        //@ts-ignore
+        this._entityCollectionsTreeNorth = null;
+        //@ts-ignore
+        this._entityCollectionsTreeSouth = null;
+        this._renderingNodes = {};
+        this._renderingNodesNorth = {};
+        this._renderingNodesSouth = {};
+    }
+    insertEntities(entitiesForTree) {
+        let northEntities = [], southEntities = [], mercEntities = [];
+        for (let i = 0, len = entitiesForTree.length; i < len; i++) {
+            let entity = entitiesForTree[i];
+            // north tree
+            if (entity._lonLat.lat > mercator.MAX_LAT) {
+                northEntities.push(entity);
+                this._entityCollectionsTreeNorth.__setLonLat__(entity);
+            }
+            else if (entity._lonLat.lat < mercator.MIN_LAT) {
+                southEntities.push(entity);
+                this._entityCollectionsTreeSouth.__setLonLat__(entity);
+            }
+            else {
+                mercEntities.push(entity);
+                this._entityCollectionsTree.__setLonLat__(entity);
+            }
+        }
+        this._entityCollectionsTree.buildTree(mercEntities);
+        this._entityCollectionsTreeNorth.buildTree(northEntities);
+        this._entityCollectionsTreeSouth.buildTree(southEntities);
+    }
+    collectVisibleEntityCollections(outArr) {
+        this._renderingNodes = {};
+        this._renderingNodesNorth = {};
+        this._renderingNodesSouth = {};
+        let pqs = this._layer._planet.quadTreeStrategy;
+        // Merc nodes
+        this._secondPASS = [];
+        this._entityCollectionsTree.collectRenderCollectionsPASS1(pqs._visibleNodes, outArr);
+        let i = this._secondPASS.length;
+        while (i--) {
+            this._secondPASS[i].collectRenderCollectionsPASS2(pqs._visibleNodes, outArr, this._secondPASS[i].nodeId);
+        }
+        // North nodes
+        this._secondPASS = [];
+        this._entityCollectionsTreeNorth.collectRenderCollectionsPASS1(pqs._visibleNodesNorth, outArr);
+        i = this._secondPASS.length;
+        while (i--) {
+            this._secondPASS[i].collectRenderCollectionsPASS2(pqs._visibleNodesNorth, outArr, this._secondPASS[i].nodeId);
+        }
+        // South nodes
+        this._secondPASS = [];
+        this._entityCollectionsTreeSouth.collectRenderCollectionsPASS1(pqs._visibleNodesSouth, outArr);
+        i = this._secondPASS.length;
+        while (i--) {
+            this._secondPASS[i].collectRenderCollectionsPASS2(pqs._visibleNodesSouth, outArr, this._secondPASS[i].nodeId);
+        }
+    }
+}

package/lib/js/quadTree/earth/EarthQuadTreeStrategy.d.ts

@@ -0,0 +1,29 @@
+import { Node } from "../Node";
+import { Planet } from "../../scene/Planet";
+import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { LonLat } from "../../LonLat";
+import { Vector } from "../../layer/Vector";
+import { EarthEntityCollectionsTreeStrategy } from "./EarthEntityCollectionsTreeStrategy";
+export declare class EarthQuadTreeStrategy extends QuadTreeStrategy {
+    /**
+     * Current visible north pole nodes tree nodes array.
+     * @public
+     * @type {Node}
+     * @todo
+     */
+    _visibleNodesNorth: Record<number, Node>;
+    /**
+     * Current visible south pole nodes tree nodes array.
+     * @public
+     * @type {Node}
+     * @todo
+     */
+    _visibleNodesSouth: Record<number, Node>;
+    constructor(planet: Planet);
+    collectVisibleNode(node: Node): void;
+    protected _clearVisibleNodes(): void;
+    createEntitiCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EarthEntityCollectionsTreeStrategy;
+    init(): void;
+    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/{EarthQuadTreeStrategy.js → earth/EarthQuadTreeStrategy.js}

@@ -1,12 +1,35 @@
-import * as mercator from "../mercator";
-import { Extent } from "../Extent";
-import { Node } from "../quadTree/Node";
-import { QuadTreeStrategy } from "./QuadTreeStrategy";
-import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH, getTileGroupByLat, getTileCellExtent, getTileCellIndex } from "../segment/Segment";
-import { SegmentLonLat } from "../segment/SegmentLonLat";
+import * as mercator from "../../mercator";
+import { Extent } from "../../Extent";
+import { Node } from "../Node";
+import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH, getTileGroupByLat, getTileCellExtent, getTileCellIndex } from "../../segment/Segment";
+import { SegmentLonLat } from "../../segment/SegmentLonLat";
+import { EarthEntityCollectionsTreeStrategy } from "./EarthEntityCollectionsTreeStrategy";
 export class EarthQuadTreeStrategy extends QuadTreeStrategy {
     constructor(planet) {
         super(planet, "Earth");
+        this._visibleNodesNorth = {};
+        this._visibleNodesSouth = {};
+    }
+    collectVisibleNode(node) {
+        let tg = node.segment._tileGroup;
+        if (tg === TILEGROUP_NORTH) {
+            this._visibleNodesNorth[node.nodeId] = node;
+        }
+        else if (tg === TILEGROUP_SOUTH) {
+            this._visibleNodesSouth[node.nodeId] = node;
+        }
+        else {
+            this._visibleNodes[node.nodeId] = node;
+        }
+    }
+    _clearVisibleNodes() {
+        super._clearVisibleNodes();
+        this._visibleNodesNorth = {};
+        this._visibleNodesSouth = {};
+    }
+    createEntitiCollectionsTreeStrategy(layer, nodeCapacity) {
+        return new EarthEntityCollectionsTreeStrategy(layer, nodeCapacity);
     }
     init() {
         this._quadTreeList = [

package/lib/js/quadTree/equi/EquiEntityCollectionNodeLonLat.d.ts

@@ -0,0 +1,17 @@
+import { Extent } from "../../Extent";
+import { Planet } from "../../scene/Planet";
+import { LonLat } from "../../LonLat";
+import { Entity } from "../../entity/Entity";
+import { EntityCollection } from "../../entity/EntityCollection";
+import { EntityCollectionNode, NodesDict } from "../EntityCollectionNode";
+import { EquiEntityCollectionsTreeStrategy } from "./EquiEntityCollectionsTreeStrategy";
+export declare class EquiEntityCollectionNodeLonLat extends EntityCollectionNode {
+    strategy: EquiEntityCollectionsTreeStrategy;
+    constructor(strategy: EquiEntityCollectionsTreeStrategy, partId: number, parent: EquiEntityCollectionNodeLonLat | null, extent: Extent, planet: Planet, zoom: number);
+    createChildrenNodes(): void;
+    protected _setExtentBounds(): void;
+    __setLonLat__(entity: Entity): LonLat;
+    isVisible(): boolean;
+    isInside(entity: Entity): boolean;
+    renderCollection(outArr: EntityCollection[], visibleNodes: NodesDict, renderingNode: number): void;
+}

package/lib/js/quadTree/equi/EquiEntityCollectionNodeLonLat.js

@@ -0,0 +1,70 @@
+import { Extent } from "../../Extent";
+import { LonLat } from "../../LonLat";
+import { NE, NW, SE, SW } from "../quadTree";
+import { EntityCollectionNode } from "../EntityCollectionNode";
+export class EquiEntityCollectionNodeLonLat extends EntityCollectionNode {
+    constructor(strategy, partId, parent, extent, planet, zoom) {
+        super(strategy, partId, parent, extent, planet, zoom);
+        this.strategy = strategy;
+    }
+    createChildrenNodes() {
+        const s = this.strategy;
+        const ext = this.extent;
+        const size_x = ext.getWidth() * 0.5;
+        const size_y = ext.getHeight() * 0.5;
+        const ne = ext.northEast;
+        const sw = ext.southWest;
+        const c = new LonLat(sw.lon + size_x, sw.lat + size_y);
+        const nd = this.childrenNodes;
+        const p = this.layer._planet;
+        const z = this.zoom + 1;
+        nd[NW] = new EquiEntityCollectionNodeLonLat(s, NW, this, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)), p, z);
+        nd[NE] = new EquiEntityCollectionNodeLonLat(s, NE, this, new Extent(c, new LonLat(ne.lon, ne.lat)), p, z);
+        nd[SW] = new EquiEntityCollectionNodeLonLat(s, SW, this, new Extent(new LonLat(sw.lon, sw.lat), c), p, z);
+        nd[SE] = new EquiEntityCollectionNodeLonLat(s, SE, this, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)), p, z);
+    }
+    _setExtentBounds() {
+        this.bsphere.setFromExtent(this.layer._planet.ellipsoid, this.extent);
+    }
+    __setLonLat__(entity) {
+        if (entity._lonLat.isZero()) {
+            entity._lonLat = this.layer._planet.ellipsoid.cartesianToLonLat(entity._cartesian);
+        }
+        return entity._lonLat;
+    }
+    isVisible() {
+        if (this.strategy._renderingNodesWest[this.nodeId]) {
+            return true;
+        }
+        else if (this.strategy._renderingNodesEast[this.nodeId]) {
+            return true;
+        }
+        return false;
+    }
+    isInside(entity) {
+        return this.extent.isInside(entity._lonLat);
+    }
+    renderCollection(outArr, visibleNodes, renderingNode) {
+        if (this.extent.southWest.lon < 0) {
+            this.strategy._renderingNodesWest[this.nodeId] = true;
+        }
+        else {
+            this.strategy._renderingNodesEast[this.nodeId] = true;
+        }
+        if (this.deferredEntities.length && !this._inTheQueue) {
+            if (this.layer.async) {
+                this.strategy._queueDeferredNode(this);
+            }
+            else {
+                this.applyCollection();
+            }
+        }
+        const ec = this.entityCollection;
+        ec._fadingOpacity = this.layer._fadingOpacity;
+        ec.scaleByDistance = this.layer.scaleByDistance;
+        ec.pickingScale = this.layer.pickingScale;
+        if (!ec.isEmpty()) {
+            outArr.push(ec);
+        }
+    }
+}

package/lib/js/quadTree/equi/EquiEntityCollectionsTreeStrategy.d.ts

@@ -0,0 +1,17 @@
+import { Vector } from "../../layer/Vector";
+import { Entity } from "../../entity/Entity";
+import { EntityCollection } from "../../entity/EntityCollection";
+import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
+import { EquiEntityCollectionNodeLonLat } from "./EquiEntityCollectionNodeLonLat";
+export declare class EquiEntityCollectionsTreeStrategy extends EntityCollectionsTreeStrategy {
+    protected _entityCollectionsTreeWest: EquiEntityCollectionNodeLonLat;
+    protected _entityCollectionsTreeEast: EquiEntityCollectionNodeLonLat;
+    _renderingNodesWest: Record<number, boolean>;
+    _renderingNodesEast: Record<number, boolean>;
+    constructor(layer: Vector, nodeCapacity: number);
+    insertEntity(entity: Entity, rightNow?: boolean): void;
+    setPickingEnabled(pickingEnabled: boolean): void;
+    dispose(): void;
+    insertEntities(entitiesForTree: Entity[]): void;
+    collectVisibleEntityCollections(outArr: EntityCollection[]): void;
+}

package/lib/js/quadTree/equi/EquiEntityCollectionsTreeStrategy.js

@@ -0,0 +1,75 @@
+import * as quadTree from "../quadTree";
+import { Extent } from "../../Extent";
+import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
+import { EquiEntityCollectionNodeLonLat } from "./EquiEntityCollectionNodeLonLat";
+export class EquiEntityCollectionsTreeStrategy extends EntityCollectionsTreeStrategy {
+    constructor(layer, nodeCapacity) {
+        super(layer, nodeCapacity);
+        let planet = layer._planet;
+        this._entityCollectionsTreeWest = new EquiEntityCollectionNodeLonLat(this, quadTree.NW, null, Extent.createFromArray([-180, -90, 0, 90]), planet, 0);
+        this._entityCollectionsTreeEast = new EquiEntityCollectionNodeLonLat(this, quadTree.NW, null, Extent.createFromArray([0, -90, 180, 90]), planet, 0);
+        this._renderingNodesWest = {};
+        this._renderingNodesEast = {};
+    }
+    insertEntity(entity, rightNow = false) {
+        if (entity._lonLat.lon < 0) {
+            this._entityCollectionsTreeWest.__setLonLat__(entity);
+            this._entityCollectionsTreeWest.insertEntity(entity, rightNow);
+        }
+        else {
+            this._entityCollectionsTreeEast.__setLonLat__(entity);
+            this._entityCollectionsTreeEast.insertEntity(entity, rightNow);
+        }
+    }
+    setPickingEnabled(pickingEnabled) {
+        this._entityCollectionsTreeWest.traverseTree((node) => {
+            node.entityCollection.setPickingEnabled(pickingEnabled);
+        });
+        this._entityCollectionsTreeEast.traverseTree((node) => {
+            node.entityCollection.setPickingEnabled(pickingEnabled);
+        });
+    }
+    dispose() {
+        //@ts-ignore
+        this._entityCollectionsTreeWest = null;
+        //@ts-ignore
+        this._entityCollectionsTreeEast = null;
+        this._renderingNodesWest = {};
+        this._renderingNodesEast = {};
+    }
+    insertEntities(entitiesForTree) {
+        let westEntities = [], eastEntities = [];
+        for (let i = 0, len = entitiesForTree.length; i < len; i++) {
+            let entity = entitiesForTree[i];
+            if (entity._lonLat.lon < 0) {
+                westEntities.push(entity);
+                this._entityCollectionsTreeWest.__setLonLat__(entity);
+            }
+            else {
+                eastEntities.push(entity);
+                this._entityCollectionsTreeEast.__setLonLat__(entity);
+            }
+        }
+        this._entityCollectionsTreeWest.buildTree(westEntities);
+        this._entityCollectionsTreeEast.buildTree(eastEntities);
+    }
+    collectVisibleEntityCollections(outArr) {
+        this._renderingNodesWest = {};
+        this._renderingNodesEast = {};
+        let pqs = this._layer._planet.quadTreeStrategy;
+        // Wset
+        this._secondPASS = [];
+        this._entityCollectionsTreeWest.collectRenderCollectionsPASS1(pqs._visibleNodesWest, outArr);
+        let i = this._secondPASS.length;
+        while (i--) {
+            this._secondPASS[i].collectRenderCollectionsPASS2(pqs._visibleNodesWest, outArr, this._secondPASS[i].nodeId);
+        }
+        // East
+        this._secondPASS = [];
+        this._entityCollectionsTreeEast.collectRenderCollectionsPASS1(pqs._visibleNodesEast, outArr);
+        i = this._secondPASS.length;
+        while (i--) {
+            this._secondPASS[i].collectRenderCollectionsPASS2(pqs._visibleNodesEast, outArr, this._secondPASS[i].nodeId);
+        }
+    }
+}