@openglobus/og 0.18.0 → 0.18.2

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

@@ -0,0 +1,48 @@
+import { Extent } from "../Extent";
+import { Layer } from "../layer/Layer";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { Segment } from "./Segment";
+import { LonLat } from "../LonLat";
+import { Entity } from "../entity/Entity";
+import { PlanetCamera } from "../camera/PlanetCamera";
+import { WebGLTextureExt } from "../webgl/Handler";
+export declare const POLE_PIECE_SIZE: number;
+/**
+ * Planet segment Web Mercator tile class that stored and rendered with quad tree.
+ * @class
+ * @extends {Segment}
+ */
+declare class SegmentLonLat extends Segment {
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    _setExtentLonLat(): void;
+    projectNative(coords: LonLat): LonLat;
+    getInsideLonLat(obj: Entity | PlanetCamera): LonLat;
+    protected _getMaxZoom(): number;
+    checkZoom(): boolean;
+    protected _assignTileIndexes(): void;
+    protected _assignTileXIndexes(extent: Extent): void;
+    protected _assignTileYIndexes(extent: Extent): void;
+    protected _createPlainVertices(): void;
+    protected _assignGlobalTextureCoordinates(): void;
+    /**
+     * @todo: replace to the strategy
+     */
+    _collectVisibleNodes(): void;
+    /**
+     * @param layer
+     * @protected
+     *
+     * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
+     *
+     */
+    protected _getLayerExtentOffset(layer: Layer): [number, number, number, number];
+    layerOverlap(layer: Layer): boolean;
+    getDefaultTexture(): WebGLTextureExt | null;
+    getExtentLonLat(): Extent;
+    /**
+     * @todo: replace to the strategy
+     */
+    getNodeState(): number;
+}
+export { SegmentLonLat };

package/{src/segment/SegmentLonLat.ts → lib/js/segment/SegmentLonLat.js}

@@ -1,113 +1,82 @@
 import * as mercator from "../mercator";
 import * as quadTree from "../quadTree/quadTree";
-import {EPSG4326} from "../proj/EPSG4326";
-import {Extent} from "../Extent";
-import {Layer} from "../layer/Layer";
-import {Node} from "../quadTree/Node";
-import {Planet} from "../scene/Planet";
-import {Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH} from "./Segment";
-import {LonLat} from "../LonLat";
-import {Vec3} from "../math/Vec3";
-import {Entity} from "../entity/Entity";
-import {PlanetCamera} from "../camera/PlanetCamera";
-import {WebGLTextureExt} from "../webgl/Handler";
-
+import { EPSG4326 } from "../proj/EPSG4326";
+import { Extent } from "../Extent";
+import { Layer } from "../layer/Layer";
+import { Segment, TILEGROUP_NORTH, TILEGROUP_SOUTH } from "./Segment";
+import { LonLat } from "../LonLat";
+import { Vec3 } from "../math/Vec3";
 const MAX_POLE_ZOOM = 7;
 export const POLE_PIECE_SIZE = (90.0 - mercator.MAX_LAT) / Math.pow(2, MAX_POLE_ZOOM);
-
-let _tempHigh = new Vec3(),
-    _tempLow = new Vec3();
-
+let _tempHigh = new Vec3(), _tempLow = new Vec3();
 /**
  * Planet segment Web Mercator tile class that stored and rendered with quad tree.
  * @class
  * @extends {Segment}
  */
 class SegmentLonLat extends Segment {
-    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent) {
+    constructor(node, planet, tileZoom, extent) {
         super(node, planet, tileZoom, extent);
-
         this._projection = EPSG4326;
-
         this._extentLonLat = this._extent;
-
-        this._extentMerc = new Extent(
-            extent.southWest.forwardMercatorEPS01(),
-            extent.northEast.forwardMercatorEPS01()
-        );
-
+        this._extentMerc = new Extent(extent.southWest.forwardMercatorEPS01(), extent.northEast.forwardMercatorEPS01());
         this._isNorth = this._extent.northEast.lat > 0;
-
         this.isPole = true;
     }
-
-    public override _setExtentLonLat() {
+    _setExtentLonLat() {
         this._extentLonLat = this._extent;
     }
-
-    public override projectNative(coords: LonLat): LonLat {
+    projectNative(coords) {
         return coords;
     }
-
-    public override getInsideLonLat(obj: Entity | PlanetCamera): LonLat {
+    getInsideLonLat(obj) {
         return obj._lonLat;
     }
-
-    protected _getMaxZoom() {
+    _getMaxZoom() {
         let maxPoleZoom = 0;
         if (this._isNorth) {
             //north pole limits
             let Yz = Math.floor((90.0 - this._extent.northEast.lat) / POLE_PIECE_SIZE);
             maxPoleZoom = Math.floor(Yz / 16) + 7;
-        } else {
+        }
+        else {
             //south pole limits
             let Yz = Math.floor((mercator.MIN_LAT - this._extent.northEast.lat) / POLE_PIECE_SIZE);
             maxPoleZoom = 12 - Math.floor(Yz / 16);
         }
         return maxPoleZoom;
     }
-
-    public override checkZoom() {
+    checkZoom() {
         return super.checkZoom() && this.tileZoom <= this._getMaxZoom();
     }
-
-    protected override _assignTileIndexes() {
+    _assignTileIndexes() {
         this._assignTileXIndexes(this._extent);
         this._assignTileYIndexes(this._extent);
         this.tileIndex = Layer.getTileIndex(this.tileX, this.tileY, this.tileZoom);
     }
-
-    protected _assignTileXIndexes(extent: Extent) {
-        this.tileX = Math.round(
-            Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon)
-        );
-
+    _assignTileXIndexes(extent) {
+        this.tileX = Math.round(Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
         let p2 = 1 << this.tileZoom;
         this.tileXE = (this.tileX + 1) % p2;
         this.tileXW = (p2 + this.tileX - 1) % p2;
     }
-
-    protected _assignTileYIndexes(extent: Extent) {
+    _assignTileYIndexes(extent) {
         const lat = extent.northEast.lat;
         if (lat > 0) {
             this._tileGroup = TILEGROUP_NORTH;
             this.tileY = Math.round((90.0 - lat) / (extent.northEast.lat - extent.southWest.lat));
-        } else {
+        }
+        else {
             this._tileGroup = TILEGROUP_SOUTH;
-            this.tileY = Math.round(
-                (mercator.MIN_LAT - lat) / (extent.northEast.lat - extent.southWest.lat)
-            );
+            this.tileY = Math.round((mercator.MIN_LAT - lat) / (extent.northEast.lat - extent.southWest.lat));
         }
         this.tileYN = this.tileY - 1;
         this.tileYS = this.tileY + 1;
     }
-
-
-    protected override _createPlainVertices() {
-        const gridSize = this.planet.terrain!.gridSizeByZoom[this.tileZoom];
-
+    _createPlainVertices() {
+        const gridSize = this.planet.terrain.gridSizeByZoom[this.tileZoom];
         const e = this._extent;
-        const fgs = this.planet.terrain!.plainGridSize;
+        const fgs = this.planet.terrain.plainGridSize;
         const lonSize = e.getWidth();
         const latSize = e.getHeight();
         const llStep = lonSize / Math.max(fgs, gridSize);
@@ -117,129 +86,90 @@ class SegmentLonLat extends Segment {
         const dg = Math.max(fgs / gridSize, 1);
         const gs = Math.max(fgs, gridSize) + 1;
         const r2 = this.planet.ellipsoid._invRadii2;
-
-        let ind = 0,
-            nmInd = 0;
-
+        let ind = 0, nmInd = 0;
         const gsgs = gs * gs;
-
         const gridSize3 = (gridSize + 1) * (gridSize + 1) * 3;
-
         this.plainNormals = new Float32Array(gridSize3);
         this.plainVertices = new Float64Array(gridSize3);
         this.plainVerticesHigh = new Float32Array(gridSize3);
         this.plainVerticesLow = new Float32Array(gridSize3);
-
         this.normalMapNormals = new Float32Array(gsgs * 3);
         this.normalMapVertices = new Float64Array(gsgs * 3);
         this.normalMapVerticesHigh = new Float32Array(gsgs * 3);
         this.normalMapVerticesLow = new Float32Array(gsgs * 3);
-
-        let xmin = 549755748352.0,
-            xmax = -549755748352.0,
-            ymin = 549755748352.0,
-            ymax = -549755748352.0,
-            zmin = 549755748352.0,
-            zmax = -549755748352.0;
-
-        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;
-
+        let xmin = 549755748352.0, xmax = -549755748352.0, ymin = 549755748352.0, ymax = -549755748352.0, zmin = 549755748352.0, zmax = -549755748352.0;
+        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);
-
-            const v = this.planet.ellipsoid.lonLatToCartesian(
-                new LonLat(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 j = k % gs, i = ~~(k / gs);
+            const v = this.planet.ellipsoid.lonLatToCartesian(new LonLat(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;
-
+            let nxl = nx * l, nyl = ny * l, nzl = nz * l;
             Vec3.doubleToTwoFloats(v, _tempHigh, _tempLow);
-
             nmVerts[nmInd] = v.x;
             nmVertsHigh[nmInd] = _tempHigh.x;
             nmVertsLow[nmInd] = _tempLow.x;
             nmNorms[nmInd++] = nxl;
-
             nmVerts[nmInd] = v.y;
             nmVertsHigh[nmInd] = _tempHigh.y;
             nmVertsLow[nmInd] = _tempLow.y;
             nmNorms[nmInd++] = nyl;
-
             nmVerts[nmInd] = v.z;
             nmVertsHigh[nmInd] = _tempHigh.z;
             nmVertsLow[nmInd] = _tempLow.z;
             nmNorms[nmInd++] = nzl;
-
             if (i % dg === 0 && j % dg === 0) {
                 verts[ind] = v.x;
                 vertsHigh[ind] = _tempHigh.x;
                 vertsLow[ind] = _tempLow.x;
                 norms[ind++] = nxl;
-
                 verts[ind] = v.y;
                 vertsHigh[ind] = _tempHigh.y;
                 vertsLow[ind] = _tempLow.y;
                 norms[ind++] = nyl;
-
                 verts[ind] = v.z;
                 vertsHigh[ind] = _tempHigh.z;
                 vertsLow[ind] = _tempLow.z;
                 norms[ind++] = nzl;
-
-                if (v.x < xmin) xmin = v.x;
-                if (v.x > xmax) xmax = v.x;
-                if (v.y < ymin) ymin = v.y;
-                if (v.y > ymax) ymax = v.y;
-                if (v.z < zmin) zmin = v.z;
-                if (v.z > zmax) zmax = v.z;
+                if (v.x < xmin)
+                    xmin = v.x;
+                if (v.x > xmax)
+                    xmax = v.x;
+                if (v.y < ymin)
+                    ymin = v.y;
+                if (v.y > ymax)
+                    ymax = v.y;
+                if (v.z < zmin)
+                    zmin = v.z;
+                if (v.z > zmax)
+                    zmax = v.z;
             }
         }
-
         this.terrainVertices = verts;
         this.terrainVerticesHigh = vertsHigh;
         this.terrainVerticesLow = vertsLow;
-
-        let x = (xmax - xmin) * 0.5,
-            y = (ymax - ymin) * 0.5,
-            z = (zmax - zmin) * 0.5;
-
+        let x = (xmax - xmin) * 0.5, y = (ymax - ymin) * 0.5, z = (zmax - zmin) * 0.5;
         this._plainRadius = Math.sqrt(x * x + y * y + z * z);
-
         this.plainReady = true;
     }
-
-    protected override _assignGlobalTextureCoordinates() {
+    _assignGlobalTextureCoordinates() {
         const e = this._extent;
         this._globalTextureCoordinates[0] = (e.southWest.lon + 180.0) / 360.0;
         this._globalTextureCoordinates[1] = (90 - e.northEast.lat) / 180.0;
         this._globalTextureCoordinates[2] = (e.northEast.lon + 180.0) / 360.0;
         this._globalTextureCoordinates[3] = (90 - e.southWest.lat) / 180.0;
     }
-
     /**
      * @todo: replace to the strategy
      */
-    public override _collectVisibleNodes() {
+    _collectVisibleNodes() {
         if (this._isNorth) {
             this.planet._visibleNodesNorth[this.node.nodeId] = this.node;
-        } else {
+        }
+        else {
             this.planet._visibleNodesSouth[this.node.nodeId] = this.node;
         }
     }
-
     /**
      * @param layer
      * @protected
@@ -247,7 +177,7 @@ class SegmentLonLat extends Segment {
      * @todo simplify layer._extentMerc in layer.getNativeExtent(this)
      *
      */
-    protected override _getLayerExtentOffset(layer: Layer): [number, number, number, number] {
+    _getLayerExtentOffset(layer) {
         const v0s = layer._extent;
         const v0t = this._extent;
         const sSize_x = v0s.northEast.lon - v0s.southWest.lon;
@@ -258,31 +188,27 @@ class SegmentLonLat extends Segment {
         const dSize_y = (v0t.northEast.lat - v0t.southWest.lat) / sSize_y;
         return [dV0s_x, dV0s_y, dSize_x, dSize_y];
     }
-
-    public override layerOverlap(layer: Layer): boolean {
+    layerOverlap(layer) {
         return this._extent.overlaps(layer._extent);
     }
-
-    public override getDefaultTexture(): WebGLTextureExt | null {
+    getDefaultTexture() {
         return this._isNorth ? this.planet.solidTextureOne : this.planet.solidTextureTwo;
     }
-
-    public override getExtentLonLat(): Extent {
+    getExtentLonLat() {
         return this._extent;
     }
-
     /**
      * @todo: replace to the strategy
      */
-    public override getNodeState(): number {
+    getNodeState() {
         let vn;
         if (this._isNorth) {
             vn = this.planet._visibleNodesNorth[this.node.nodeId];
-        } else {
+        }
+        else {
             vn = this.planet._visibleNodesSouth[this.node.nodeId];
         }
         return (vn && vn.state) || quadTree.NOTRENDERING;
     }
 }
-
-export {SegmentLonLat};
+export { SegmentLonLat };

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

@@ -0,0 +1,10 @@
+import { Extent } from "../Extent";
+import { Node } from "../quadTree/Node";
+import { Planet } from "../scene/Planet";
+import { SegmentLonLat } from "./SegmentLonLat";
+export declare class SegmentLonLatWgs84 extends SegmentLonLat {
+    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    protected _getMaxZoom(): number;
+    protected _assignTileYIndexes(extent: Extent): void;
+    protected _assignTileXIndexes(extent: Extent): void;
+}

package/lib/js/segment/SegmentLonLatWgs84.js

@@ -0,0 +1,23 @@
+import { SegmentLonLat } from "./SegmentLonLat";
+import { TILEGROUP_COMMON } from "./Segment";
+export class SegmentLonLatWgs84 extends SegmentLonLat {
+    constructor(node, planet, tileZoom, extent) {
+        super(node, planet, tileZoom, extent);
+        this.isPole = false;
+        this._tileGroup = TILEGROUP_COMMON;
+    }
+    _getMaxZoom() {
+        return 150;
+    }
+    _assignTileYIndexes(extent) {
+        this.tileY = Math.round((90.0 - extent.northEast.lat) / (extent.northEast.lat - extent.southWest.lat));
+        this.tileYN = this.tileY - 1;
+        this.tileYS = this.tileY + 1;
+    }
+    _assignTileXIndexes(extent) {
+        this.tileX = Math.round(Math.abs(-180.0 - extent.southWest.lon) / (extent.northEast.lon - extent.southWest.lon));
+        let p2 = (1 << this.tileZoom) * 2;
+        this.tileXE = (this.tileX + 1) % p2;
+        this.tileXW = (p2 + this.tileX - 1) % p2;
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Layer } from "../layer/Layer";
+import { Segment } from "./Segment";
+import { Material } from "../layer/Material";
+declare class Slice {
+    segment: Segment;
+    layers: Layer[];
+    tileOffsetArr: Float32Array;
+    layerOpacityArr: Float32Array;
+    constructor(segment: Segment);
+    clear(): void;
+    append(layer: Layer, material: Material): void;
+}
+export { Slice };

package/{src/segment/Slice.ts → lib/js/segment/Slice.js}

@@ -1,21 +1,11 @@
-import {Layer} from "../layer/Layer";
-import {Segment} from "./Segment";
-import {Material} from "../layer/Material";
-
 class Slice {
-    public segment: Segment;
-    public layers: Layer[];
-    public tileOffsetArr: Float32Array;
-    public layerOpacityArr: Float32Array;
-
-    constructor(segment: Segment) {
+    constructor(segment) {
         this.segment = segment;
         this.layers = [];
         this.tileOffsetArr = new Float32Array(segment.planet.SLICE_SIZE_4);
         this.layerOpacityArr = new Float32Array(segment.planet.SLICE_SIZE);
     }
-
-    public clear() {
+    clear() {
         // @ts-ignore
         this.layers = null;
         // @ts-ignore
@@ -23,29 +13,21 @@ class Slice {
         // @ts-ignore
         this.layerOpacityArr = null;
     }
-
-    public append(layer: Layer, material: Material) {
+    append(layer, material) {
         let n = this.layers.length;
-
         this.layers.push(layer);
-
         this.layerOpacityArr[n] = layer.screenOpacity;
-
         let n4 = n * 4;
-
         let arr = layer.applyMaterial(material);
         this.tileOffsetArr[n4] = arr[0];
         this.tileOffsetArr[n4 + 1] = arr[1];
         this.tileOffsetArr[n4 + 2] = arr[2];
         this.tileOffsetArr[n4 + 3] = arr[3];
-
         //arr = this.segment._getLayerExtentOffset(layer);
         //slice.visibleExtentOffsetArr[n4] = arr[0];
         //slice.visibleExtentOffsetArr[n4 + 1] = arr[1];
         //slice.visibleExtentOffsetArr[n4 + 2] = arr[2];
         //slice.visibleExtentOffsetArr[n4 + 3] = arr[3];
-
     }
 }
-
-export {Slice}
+export { Slice };

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

@@ -0,0 +1,18 @@
+/**
+ * @module og/segment/SegmentHelper
+ */
+type IndexTypeArray = Uint32Array;
+type IndexesTable = [IndexTypeArray[][], IndexTypeArray[][], IndexTypeArray[][], IndexTypeArray[][]];
+declare class SegmentHelper {
+    protected _maxGridSize: number;
+    centerIndexesTable: IndexTypeArray[];
+    skirtsIndexesTable: IndexesTable;
+    constructor(maxGridSize?: number);
+    get maxGridSize(): number;
+    init(): void;
+    setMaxGridSize(gridSize: number): void;
+    createSegmentIndexes(size: number, sidesSizes: [number, number, number, number]): Uint32Array;
+    initTextureCoordsTable(pow: number): Uint16Array[];
+}
+export declare function getInstance(): SegmentHelper;
+export {};