@openglobus/og 0.17.1 → 0.18.0

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

@@ -1,50 +1,58 @@
-"use strict";
-
-import { EPSG3857 } from "../proj/EPSG3857.js";
+import {EPSG3857} from "../proj/EPSG3857";
+import {Layer} from "../layer/Layer";
+import {Node} from "../quadTree/Node";
+import {Planet} from "../scene/Planet";
+import {Proj} from "../proj/Proj";
 
 export class QuadTreeStrategy {
-    constructor(options = {}) {
-        this.name = "";
-        this._planet = options.planet;
-        this.projection = EPSG3857;
-
-        /**
-         * grid tree list.
-         * @protected
-         * @type {quadTree.Node[]}
-         */
+    public name: string;
+    public projection: Proj;
+    protected _planet: Planet;
+
+    /**
+     * grid tree list.
+     * @protected
+     * @type {Node[]}
+     */
+    protected _quadTreeList: Node[];
+
+    constructor(planet: Planet, name: string = "", proj: Proj = EPSG3857) {
+        this.name = name;
+        this.projection = proj;
+        this._planet = planet;
         this._quadTreeList = [];
     }
 
-    destroyBranches() {
+    public destroyBranches() {
         for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
             this._quadTreeList[i].destroyBranches();
         }
     }
 
-    clearLayerMaterial(layer) {
-        let lid = layer._id;
+    public clearLayerMaterial(layer: Layer) {
+        let lid = layer.__id;
         for (let i = 0, len = this._quadTreeList.length; i < len; i++) {
-            this._quadTreeList[i].traverseTree(function (node) {
+            this._quadTreeList[i].traverseTree(function (node: Node) {
                 let mats = node.segment.materials;
                 if (mats[lid]) {
                     mats[lid].clear();
+                    //@ts-ignore
                     mats[lid] = null;
-                    delete mats[lid];
+                    //delete mats[lid];
                 }
             });
         }
     }
 
-    get planet() {
+    public get planet() {
         return this._planet;
     }
 
-    init() {
+    public init() {
 
     }
 
-    preRender() {
+    public preRender() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
 
             let quadTree = this._quadTreeList[i];
@@ -55,40 +63,38 @@ export class QuadTreeStrategy {
                 quadTree.nodes[j].segment.createPlainSegment();
             }
         }
-
     }
 
-    preLoad() {
+    public preLoad() {
 
         for (let i = 0; i < this._quadTreeList.length; i++) {
 
             let quadTree = this._quadTreeList[i];
             quadTree.segment.passReady = true;
-            quadTree.renderNode(true);
+            quadTree.renderNode(1);
             this._planet.normalMapCreator.drawSingle(quadTree.segment);
 
             for (let j = 0; j < quadTree.nodes.length; j++) {
                 quadTree.nodes[j].segment.passReady = true;
-                quadTree.nodes[j].renderNode(true);
+                quadTree.nodes[j].renderNode(1);
                 this._planet._normalMapCreator.drawSingle(quadTree.nodes[j].segment);
             }
         }
     }
 
-    collectRenderNodes() {
+    public collectRenderNodes() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
             this._quadTreeList[i].renderTree(this._planet.camera, 0, null);
         }
     }
 
-    clear() {
+    public clear() {
         for (let i = 0; i < this._quadTreeList.length; i++) {
             this._quadTreeList[i].clearTree();
         }
     }
 
-    get quadTreeList() {
+    public get quadTreeList(): Node[] {
         return this._quadTreeList;
     }
-
 }

package/src/quadTree/Wgs84QuadTreeStrategy.ts

@@ -0,0 +1,22 @@
+import * as quadTree from "../quadTree/quadTree";
+import {Extent} from "../Extent";
+import {EPSG4326} from "../proj/EPSG4326";
+import {Node} from "../quadTree/Node";
+import {Planet} from "../scene/Planet";
+import {SegmentLonLatWgs84} from "../segment/SegmentLonLatWgs84";
+import {QuadTreeStrategy} from "./QuadTreeStrategy";
+
+export class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet: Planet) {
+        super(planet, "wgs84", EPSG4326);
+    }
+
+    public override init() {
+
+        let wgs84QuadTree = new Node(SegmentLonLatWgs84, this.planet, quadTree.NW, null, 0, 0,
+            Extent.createFromArray([-180, -90, 180, 90])
+        );
+
+        this._quadTreeList.push(wgs84QuadTree);
+    }
+}

package/src/quadTree/index.ts

@@ -0,0 +1,14 @@
+import {EarthQuadTreeStrategy} from "./EarthQuadTreeStrategy";
+import {MarsQuadTreeStrategy} from "./MarsQuadTreeStrategy";
+import {EPSG4326QuadTreeStrategy} from "./EPSG4326QuadTreeStrategy";
+import {QuadTreeStrategy} from "./QuadTreeStrategy";
+import {Wgs84QuadTreeStrategy} from "./Wgs84QuadTreeStrategy";
+
+const quadTreeStrategyType = {
+    epsg4326: EPSG4326QuadTreeStrategy,
+    earth: EarthQuadTreeStrategy,
+    mars: MarsQuadTreeStrategy,
+    wgs84: Wgs84QuadTreeStrategy
+}
+
+export {quadTreeStrategyType, QuadTreeStrategy, Wgs84QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy};

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

@@ -1,77 +1,75 @@
-"use strict";
-
-export const VISIBLE_DISTANCE = 3570.0;
-export const MAX_RENDERED_NODES = 1000;
-
-export const NW = 0;
-export const NE = 1;
-export const SW = 2;
-export const SE = 3;
-
-export const N = 0;
-export const E = 1;
-export const S = 2;
-export const W = 3;
-
-export const NOTRENDERING = 0;
-export const RENDERING = 1;
-export const WALKTHROUGH = 2;
-
-/**
- * World opposite side table.
- */
-export const OPSIDE = [S, W, N, E];
-
-/**
- * First index is {N,E,S,W} and second is {NW,NE,SW,SE}
- */
-export const NEIGHBOUR = [
-    [-1, -1, NW, NE],
-    [NE, -1, SE, -1],
-    [SW, SE, -1, -1],
-    [-1, NW, -1, SW]
-];
-
-/**
- * Neighbor's oposite part. For example oposite side
- * on the east neighbor side is: [S][SE] = NE
- */
-export const OPPART = [
-    [SW, SE, NW, NE],
-    [NE, NW, SE, SW],
-    [SW, SE, NW, NE],
-    [NE, NW, SE, SW]
-];
-
-/**
- * Neighbos's opside array order. For example NW node
- * by E side array index is 0, SE node by S side is 1.
- */
-export const NOPSORD = [
-    [0, 1, 0, 1],
-    [0, 0, 1, 1],
-    [0, 1, 0, 1],
-    [0, 0, 1, 1]
-];
-
-/**
- * First index is {NW,NE,SW,SE}, another one is {N,E,S,W}
- */
-export const COMSIDE = [
-    [true, false, false, true],
-    [true, true, false, false],
-    [false, false, true, true],
-    [false, true, true, false]
-];
-
-/**
- * Gets segment part left to right or up to downo ffset against neighbour side.
- * Where 0 - no offset 1 - half segment size offset.
- */
-export const PARTOFFSET = [
-    /*     N  E  S  W */
-    /*NW*/ [0, 1, 0, 0],
-    /*NE*/ [1, 0, 0, 0],
-    /*SW*/ [0, 1, 0, 1],
-    /*SE*/ [1, 1, 1, 1]
-];
+export const VISIBLE_DISTANCE = 3570.0;
+export const MAX_RENDERED_NODES = 1000;
+
+export const NW = 0;
+export const NE = 1;
+export const SW = 2;
+export const SE = 3;
+
+export const N = 0;
+export const E = 1;
+export const S = 2;
+export const W = 3;
+
+export const NOTRENDERING = 0;
+export const RENDERING = 1;
+export const WALKTHROUGH = 2;
+
+/**
+ * World opposite side table.
+ */
+export const OPSIDE = [S, W, N, E];
+
+/**
+ * First index is {N,E,S,W} and second is {NW,NE,SW,SE}
+ */
+export const NEIGHBOUR = [
+    [-1, -1, NW, NE],
+    [NE, -1, SE, -1],
+    [SW, SE, -1, -1],
+    [-1, NW, -1, SW]
+];
+
+/**
+ * Neighbor's oposite part. For example oposite side
+ * on the east neighbor side is: [S][SE] = NE
+ */
+export const OPPART = [
+    [SW, SE, NW, NE],
+    [NE, NW, SE, SW],
+    [SW, SE, NW, NE],
+    [NE, NW, SE, SW]
+];
+
+/**
+ * Neighbos's opside array order. For example NW node
+ * by E side array index is 0, SE node by S side is 1.
+ */
+export const NOPSORD = [
+    [0, 1, 0, 1],
+    [0, 0, 1, 1],
+    [0, 1, 0, 1],
+    [0, 0, 1, 1]
+];
+
+/**
+ * First index is {NW,NE,SW,SE}, another one is {N,E,S,W}
+ */
+export const COMSIDE = [
+    [true, false, false, true],
+    [true, true, false, false],
+    [false, false, true, true],
+    [false, true, true, false]
+];
+
+/**
+ * Gets segment part left to right or up to downo ffset against neighbour side.
+ * Where 0 - no offset 1 - half segment size offset.
+ */
+export const PARTOFFSET = [
+    /*     N  E  S  W */
+    /*NW*/ [0, 1, 0, 0],
+    /*NE*/ [1, 0, 0, 0],
+    /*SW*/ [0, 1, 0, 1],
+    /*SE*/ [1, 1, 1, 1]
+];