@openglobus/og 0.18.0 → 0.18.2

package/{src/quadTree/EntityCollectionNode.ts → lib/js/quadTree/EntityCollectionNode.js}

@@ -1,39 +1,15 @@
 import * as mercator from '../mercator';
-import {NW, NE, SW, SE, RENDERING, VISIBLE_DISTANCE} from './quadTree';
-import {EntityCollection} from '../entity/EntityCollection';
-import {Extent} from '../Extent';
-import {LonLat} from '../LonLat';
-import {Node} from "../quadTree/Node";
-import {Planet} from "../scene/Planet";
-import {Sphere} from '../bv/Sphere';
-import {Segment} from "../segment/Segment";
-import {Vec3} from '../math/Vec3';
-import {Vector} from "../layer/Vector";
-import {Entity} from "../entity/Entity";
-
-type NodesDict = Record<number, Node>;
-
+import { NW, NE, SW, SE, RENDERING, VISIBLE_DISTANCE } from './quadTree';
+import { EntityCollection } from '../entity/EntityCollection';
+import { Extent } from '../Extent';
+import { LonLat } from '../LonLat';
+import { Sphere } from '../bv/Sphere';
+import { Vec3 } from '../math/Vec3';
 /**
  * @todo: remove planet parameter. It's already available in the layer.
  */
 class EntityCollectionNode {
-
-    public layer: Vector;
-    public parentNode: EntityCollectionNode | null;
-    public childrenNodes: EntityCollectionNode[];
-    public partId: number;
-    public nodeId: number;
-    public state: number | null;
-    public extent: Extent;
-    public count: number;
-    public deferredEntities: Entity[];
-    public entityCollection: EntityCollection | null;
-    public zoom: number;
-    public bsphere: Sphere;
-
-    public _inTheQueue: boolean;
-
-    constructor(layer: Vector, partId: number, parent: EntityCollectionNode | null, id: number, extent: Extent, planet: Planet, zoom: number) {
+    constructor(layer, partId, parent, id, extent, planet, zoom) {
         this.layer = layer;
         this.parentNode = parent;
         this.childrenNodes = [];
@@ -46,23 +22,17 @@ class EntityCollectionNode {
         this.entityCollection = null;
         this.zoom = zoom;
         this._inTheQueue = false;
-
         this.bsphere = new Sphere();
-
         planet && this._setExtentBounds();
     }
-
-    public insertEntity(entity: Entity, rightNow: boolean = false) {
+    insertEntity(entity, rightNow = false) {
         this.buildTree([entity], rightNow);
     }
-
-    protected _addEntitiesToCollection(entities: Entity[], rightNow: boolean = false) {
+    _addEntitiesToCollection(entities, rightNow = false) {
         if (entities.length) {
             const l = this.layer;
-            const p = l._planet!;
-
+            const p = l._planet;
             let ec = this.entityCollection;
-
             if (!ec) {
                 ec = new EntityCollection({
                     pickingEnabled: l._pickingEnabled,
@@ -74,90 +44,81 @@ class EntityCollectionNode {
                 l._bindEventsDefault(ec);
                 this.entityCollection = ec;
             }
-
             if (rightNow || !l.async) {
-                this.entityCollection!.addEntities(entities);
-            } else {
+                this.entityCollection.addEntities(entities);
+            }
+            else {
                 this.deferredEntities.push.apply(this.deferredEntities, entities);
             }
         }
     }
-
-    protected _setExtentBounds() {
+    _setExtentBounds() {
         if (!this.nodeId) {
-            this.bsphere.radius = this.layer._planet!.ellipsoid.equatorialSize;
+            this.bsphere.radius = this.layer._planet.ellipsoid.equatorialSize;
             this.bsphere.center = new Vec3();
-        } else {
-            this.bsphere.setFromExtent(this.layer._planet!.ellipsoid, this.extent.inverseMercator());
+        }
+        else {
+            this.bsphere.setFromExtent(this.layer._planet.ellipsoid, this.extent.inverseMercator());
         }
     }
-
-    public __setLonLat__(entity: Entity): LonLat {
-
+    __setLonLat__(entity) {
         if (entity._lonLat.isZero() && !entity._cartesian.isZero()) {
-            entity._lonLat = this.layer._planet!.ellipsoid.cartesianToLonLat(entity._cartesian);
+            entity._lonLat = this.layer._planet.ellipsoid.cartesianToLonLat(entity._cartesian);
         }
-
         if (Math.abs(entity._lonLat.lat) < mercator.MAX_LAT) {
             entity._lonLatMerc = entity._lonLat.forwardMercator();
-        } else {
+        }
+        else {
             entity._lonLatMerc = new LonLat();
         }
         return entity._lonLatMerc;
     }
-
-    public buildTree(entities: Entity[], rightNow: boolean = false) {
-
+    buildTree(entities, rightNow = false) {
         this.count += entities.length;
-
         if (entities.length > this.layer._nodeCapacity) {
             const cn = this.childrenNodes;
             if (!cn.length) {
                 this.createChildrenNodes();
             }
-
-            let en_nw = [],
-                en_ne = [],
-                en_sw = [],
-                en_se = [];
-
+            let en_nw = [], en_ne = [], en_sw = [], en_se = [];
             let i = entities.length;
             while (i--) {
                 const ei = entities[i];
                 if (cn[NW].isInside(ei)) {
                     ei._nodePtr = cn[NW];
                     en_nw.push(ei);
-                } else if (cn[NE].isInside(ei)) {
+                }
+                else if (cn[NE].isInside(ei)) {
                     ei._nodePtr = cn[NE];
                     en_ne.push(ei);
-                } else if (cn[SW].isInside(ei)) {
+                }
+                else if (cn[SW].isInside(ei)) {
                     ei._nodePtr = cn[SW];
                     en_sw.push(ei);
-                } else if (cn[SE].isInside(ei)) {
+                }
+                else if (cn[SE].isInside(ei)) {
                     ei._nodePtr = cn[SE];
                     en_se.push(ei);
                 }
             }
-
             en_nw.length && cn[NW].buildTree(en_nw, rightNow);
             en_ne.length && cn[NE].buildTree(en_ne, rightNow);
             en_sw.length && cn[SW].buildTree(en_sw, rightNow);
             en_se.length && cn[SE].buildTree(en_se, rightNow);
-
-        } else {
+        }
+        else {
             this._addEntitiesToCollection(entities, rightNow);
         }
     }
-
-    public isInside(entity: Entity): boolean {
+    isInside(entity) {
         if (entity._lonLatMerc) {
             return this.extent.isInside(entity._lonLatMerc);
-        } else {
+        }
+        else {
             return false;
         }
     }
-
-    public createChildrenNodes() {
+    createChildrenNodes() {
         const l = this.layer;
         const ext = this.extent;
         const size_x = ext.getWidth() * 0.5;
@@ -167,25 +128,25 @@ class EntityCollectionNode {
         const id = this.nodeId * 4 + 1;
         const c = new LonLat(sw.lon + size_x, sw.lat + size_y);
         const nd = this.childrenNodes;
-        const p = this.layer._planet!;
+        const p = this.layer._planet;
         const z = this.zoom + 1;
-
         nd[NW] = new EntityCollectionNode(l, NW, this, id, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)), p, z);
         nd[NE] = new EntityCollectionNode(l, NE, this, id, new Extent(c, new LonLat(ne.lon, ne.lat)), p, z);
         nd[SW] = new EntityCollectionNode(l, SW, this, id, new Extent(new LonLat(sw.lon, sw.lat), c), p, z);
         nd[SE] = new EntityCollectionNode(l, SE, this, id, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)), p, z);
     }
-
-    public collectRenderCollectionsPASS1(visibleNodes: NodesDict, outArr: EntityCollection[]) {
+    collectRenderCollectionsPASS1(visibleNodes, outArr) {
         const n = visibleNodes[this.nodeId];
         if (n) {
             const cn = this.childrenNodes;
             if (this.entityCollection) {
                 this.renderCollection(outArr, visibleNodes);
-            } else if (cn.length) {
+            }
+            else if (cn.length) {
                 if (n.state === RENDERING) {
                     this.layer._secondPASS.push(this);
-                } else {
+                }
+                else {
                     cn[NW].collectRenderCollectionsPASS1(visibleNodes, outArr);
                     cn[NE].collectRenderCollectionsPASS1(visibleNodes, outArr);
                     cn[SW].collectRenderCollectionsPASS1(visibleNodes, outArr);
@@ -194,21 +155,17 @@ class EntityCollectionNode {
             }
         }
     }
-
-    public collectRenderCollectionsPASS2(visibleNodes: NodesDict, outArr: EntityCollection[], renderingNodeId: number) {
-        const p = this.layer._planet!;
+    collectRenderCollectionsPASS2(visibleNodes, outArr, renderingNodeId) {
+        const p = this.layer._planet;
         const cam = p.camera;
-
         const altVis = (cam.eye.distance(this.bsphere.center) - this.bsphere.radius <
             VISIBLE_DISTANCE * Math.sqrt(cam._lonLat.height)) || cam._lonLat.height > 10000;
-
         if (this.count > 0 && altVis && cam.frustum.containsSphere(this.bsphere)) {
-
             const cn = this.childrenNodes;
-
             if (this.entityCollection) {
                 this.renderCollection(outArr, visibleNodes, renderingNodeId);
-            } else if (cn.length) {
+            }
+            else if (cn.length) {
                 cn[NW].collectRenderCollectionsPASS2(visibleNodes, outArr, renderingNodeId);
                 cn[NE].collectRenderCollectionsPASS2(visibleNodes, outArr, renderingNodeId);
                 cn[SW].collectRenderCollectionsPASS2(visibleNodes, outArr, renderingNodeId);
@@ -216,67 +173,58 @@ class EntityCollectionNode {
             }
         }
     }
-
-    public applyCollection() {
-        this.entityCollection!.addEntities(this.deferredEntities);
+    applyCollection() {
+        this.entityCollection.addEntities(this.deferredEntities);
         this.deferredEntities.length = 0;
         this.deferredEntities = [];
         this._inTheQueue = false;
     }
-
-    public traverseTree(callback: Function) {
-
+    traverseTree(callback) {
         const cn = this.childrenNodes;
-
         if (this.entityCollection) {
             callback(this);
-        } else if (cn.length) {
+        }
+        else if (cn.length) {
             cn[NW].traverseTree(callback);
             cn[NE].traverseTree(callback);
             cn[SW].traverseTree(callback);
             cn[SE].traverseTree(callback);
         }
     }
-
-    public renderCollection(outArr: EntityCollection[], visibleNodes: NodesDict, renderingNodeId?: number) {
-
+    renderCollection(outArr, visibleNodes, renderingNodeId) {
         const l = this.layer;
-
         l._renderingNodes[this.nodeId] = true;
-
         if (this.deferredEntities.length && !this._inTheQueue) {
             if (l.async) {
                 l._queueDeferredNode(this);
-            } else {
+            }
+            else {
                 this.applyCollection();
             }
         }
-
-        const ec = this.entityCollection!;
-
+        const ec = this.entityCollection;
         ec._fadingOpacity = l._fadingOpacity;
         ec.scaleByDistance = l.scaleByDistance;
         ec.pickingScale = l.pickingScale;
         ec.polygonOffsetUnits = l.polygonOffsetUnits;
-
         outArr.push(ec);
-
         if (l.clampToGround || l.relativeToGround) {
             const e = ec._entities;
             let i = e.length;
-
             if (visibleNodes[this.nodeId] && visibleNodes[this.nodeId].state === RENDERING) {
                 while (i--) {
                     let ei = e[i];
                     this.alignEntityToTheGround(ei, visibleNodes[this.nodeId].segment);
                 }
-            } else if (renderingNodeId) {
+            }
+            else if (renderingNodeId) {
                 while (i--) {
                     let ei = e[i];
                     this.alignEntityToTheGround(ei, visibleNodes[renderingNodeId].segment);
                 }
-            } else {
-                const n = l._planet!._renderedNodes;
+            }
+            else {
+                const n = l._planet._renderedNodes;
                 while (i--) {
                     let ei = e[i];
                     let j = n.length;
@@ -290,37 +238,31 @@ class EntityCollectionNode {
             }
         }
     }
-
-    public alignEntityToTheGround(entity: Entity, segment: Segment) {
+    alignEntityToTheGround(entity, segment) {
         let res = new Vec3();
         segment.getEntityTerrainPoint(entity, res);
         let alt = (Number(this.layer.relativeToGround) && entity._altitude) || 0.0;
         if (alt) {
-            let n = this.layer._planet!.ellipsoid.getSurfaceNormal3v(res);
+            let n = this.layer._planet.ellipsoid.getSurfaceNormal3v(res);
             entity._setCartesian3vSilent(res.addA(n.scale(alt)));
-        } else {
+        }
+        else {
             entity._setCartesian3vSilent(res);
         }
     }
-
-    public isVisible(): boolean {
+    isVisible() {
         if (this.layer._renderingNodes[this.nodeId]) {
             return true;
         }
         return false;
     }
 }
-
 class EntityCollectionNodeWGS84 extends EntityCollectionNode {
-
-    public isNorth: boolean;
-
-    constructor(layer: Vector, partId: number, parent: EntityCollectionNodeWGS84 | null, id: number, extent: Extent, planet: Planet, zoom: number) {
+    constructor(layer, partId, parent, id, extent, planet, zoom) {
         super(layer, partId, parent, id, extent, planet, zoom);
         this.isNorth = false;
     }
-
-    public override createChildrenNodes() {
+    createChildrenNodes() {
         const l = this.layer;
         const ext = this.extent;
         const size_x = ext.getWidth() * 0.5;
@@ -330,66 +272,57 @@ class EntityCollectionNodeWGS84 extends EntityCollectionNode {
         const id = this.nodeId * 4 + 1;
         const c = new LonLat(sw.lon + size_x, sw.lat + size_y);
         const nd = this.childrenNodes;
-        const p = this.layer._planet!;
+        const p = this.layer._planet;
         const z = this.zoom + 1;
-
         nd[NW] = new EntityCollectionNodeWGS84(l, NW, this, id, new Extent(new LonLat(sw.lon, sw.lat + size_y), new LonLat(sw.lon + size_x, ne.lat)), p, z);
         nd[NE] = new EntityCollectionNodeWGS84(l, NE, this, id, new Extent(c, new LonLat(ne.lon, ne.lat)), p, z);
         nd[SW] = new EntityCollectionNodeWGS84(l, SW, this, id, new Extent(new LonLat(sw.lon, sw.lat), c), p, z);
         nd[SE] = new EntityCollectionNodeWGS84(l, SE, this, id, new Extent(new LonLat(sw.lon + size_x, sw.lat), new LonLat(ne.lon, sw.lat + size_y)), p, z);
     }
-
-    protected override _setExtentBounds() {
+    _setExtentBounds() {
         if (this.extent.northEast.lat > 0) {
             this.isNorth = true;
         }
-        this.bsphere.setFromExtent(this.layer._planet!.ellipsoid, this.extent);
+        this.bsphere.setFromExtent(this.layer._planet.ellipsoid, this.extent);
     }
-
-    public override __setLonLat__(entity: Entity): LonLat {
+    __setLonLat__(entity) {
         if (entity._lonLat.isZero()) {
-            entity._lonLat = this.layer._planet!.ellipsoid.cartesianToLonLat(entity._cartesian);
+            entity._lonLat = this.layer._planet.ellipsoid.cartesianToLonLat(entity._cartesian);
         }
         return entity._lonLat;
     }
-
-    public override isVisible(): boolean {
+    isVisible() {
         if (this.isNorth && this.layer._renderingNodesNorth[this.nodeId]) {
             return true;
-        } else if (this.layer._renderingNodesSouth[this.nodeId]) {
+        }
+        else if (this.layer._renderingNodesSouth[this.nodeId]) {
             return true;
         }
         return false;
     }
-
-    public override isInside(entity: Entity): boolean {
+    isInside(entity) {
         return this.extent.isInside(entity._lonLat);
     }
-
-    public override renderCollection(outArr: EntityCollection[], visibleNodes: NodesDict, renderingNode: number) {
-
+    renderCollection(outArr, visibleNodes, renderingNode) {
         if (this.isNorth) {
             this.layer._renderingNodesNorth[this.nodeId] = true;
-        } else {
+        }
+        else {
             this.layer._renderingNodesSouth[this.nodeId] = true;
         }
-
         if (this.deferredEntities.length && !this._inTheQueue) {
             if (this.layer.async) {
                 this.layer._queueDeferredNode(this);
-            } else {
+            }
+            else {
                 this.applyCollection();
             }
         }
-
-        const ec = this.entityCollection!;
-
+        const ec = this.entityCollection;
         ec._fadingOpacity = this.layer._fadingOpacity;
         ec.scaleByDistance = this.layer.scaleByDistance;
         ec.pickingScale = this.layer.pickingScale;
-
         outArr.push(ec);
     }
 }
-
-export {EntityCollectionNode, EntityCollectionNodeWGS84};
+export { EntityCollectionNode, EntityCollectionNodeWGS84 };

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

@@ -0,0 +1,6 @@
+import { Planet } from "../scene/Planet";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+export declare class MarsQuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet: Planet);
+    init(): void;
+}

package/lib/js/quadTree/MarsQuadTreeStrategy.js

@@ -0,0 +1,17 @@
+import * as quadTree from "../quadTree/quadTree";
+import { Extent } from "../Extent";
+import { EPSG4326 } from "../proj/EPSG4326";
+import { Node } from "../quadTree/Node";
+import { SegmentLonLatWgs84 } from "../segment/SegmentLonLatWgs84";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
+export class MarsQuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet) {
+        super(planet, "Mars", EPSG4326);
+    }
+    init() {
+        let earthQuadTreeSouth = new Node(SegmentLonLatWgs84, this.planet, quadTree.NW, null, 0, 0, Extent.createFromArray([-180, -90, 0, 90]));
+        let earthQuadTreeWest = new Node(SegmentLonLatWgs84, this.planet, quadTree.NW, null, 0, 0, Extent.createFromArray([0, -90, 180, 90]));
+        this._quadTreeList.push(earthQuadTreeSouth);
+        this._quadTreeList.push(earthQuadTreeWest);
+    }
+}

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

@@ -0,0 +1,61 @@
+import { Extent } from "../Extent";
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+import { PlanetCamera } from "../camera/PlanetCamera";
+/**
+ * Quad tree planet segment node.
+ * @constructor
+ * @param {Segment} segmentPrototype - Planet segment node constructor.
+ * @param {Planet} planet - Planet scene instance.
+ * @param {number} partId - NorthEast, SouthWest etc.
+ * @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.
+ */
+declare class Node {
+    SegmentPrototype: typeof Segment;
+    planet: Planet;
+    parentNode: Node | null;
+    partId: number;
+    nodeId: number;
+    state: number | null;
+    appliedTerrainNodeId: number;
+    sideSizeLog2: [number, number, number, number];
+    ready: boolean;
+    neighbors: [Node[], Node[], Node[], Node[]];
+    equalizedSideWithNodeId: number[];
+    nodes: [Node, Node, Node, Node] | [];
+    segment: Segment;
+    _cameraInside: boolean;
+    inFrustum: number;
+    constructor(SegmentPrototype: typeof Segment, planet: Planet, partId: number, parent: Node | null, id: number, tileZoom: number, extent: Extent);
+    createChildrenNodes(): void;
+    createBounds(): void;
+    getState(): number | null;
+    /**
+     * Returns the same deep existent neighbour node.
+     * @public
+     * @param {number} side - Neighbour side index e.g. og.quadTree.N, og.quadTree.W etc.
+     * @returns {Node} -
+     */
+    getEqualNeighbor(side: number): Node | undefined;
+    renderTree(cam: PlanetCamera, maxZoom?: number | null, terrainReadySegment?: Segment | null, stopLoading?: boolean): void;
+    traverseNodes(cam: PlanetCamera, maxZoom?: number | null, terrainReadySegment?: Segment | null, stopLoading?: boolean): void;
+    renderNode(inFrustum: number, onlyTerrain?: boolean, terrainReadySegment?: Segment | null, stopLoading?: boolean): void;
+    /**
+     * Searching for neighbours and picking up current node to render processing.
+     * @public
+     */
+    addToRender(inFrustum: number): void;
+    getCommonSide(node: Node): number;
+    whileNormalMapCreating(): void;
+    whileTerrainLoading(terrainReadySegment?: Segment | null): void;
+    destroy(): void;
+    clearTree(): void;
+    clearBranches(): void;
+    destroyBranches(): void;
+    traverseTree(callback: Function): void;
+    getOffsetOppositeNeighbourSide(neighbourNode: Node, side: number): number;
+}
+export { Node };