@openglobus/og 0.20.4 → 0.22.0

package/lib/js/quadTree/equi/EquiQuadTreeStrategy.js

@@ -0,0 +1,62 @@
+import { Extent } from "../../Extent";
+import { equi } from "../../proj/equi";
+import { Node } from "../Node";
+import { SegmentLonLatEqui } from "../../segment/SegmentLonLatEqui";
+import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { getTileCellExtent, getTileCellIndex, TILEGROUP_COMMON } from "../../segment/Segment";
+import { EquiEntityCollectionsTreeStrategy } from "./EquiEntityCollectionsTreeStrategy";
+export class EquiQuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet) {
+        super(planet, "Mars", equi);
+        this._westExtent = Extent.createFromArray([-180, -90, 0, 90]);
+        this._eastExtent = Extent.createFromArray([0, -90, 180, 90]);
+        this._visibleNodesWest = {};
+        this._visibleNodesEast = {};
+    }
+    init() {
+        this._quadTreeList = [
+            new Node(SegmentLonLatEqui, this.planet, 0, null, 0, this._westExtent),
+            new Node(SegmentLonLatEqui, this.planet, 0, null, 0, this._eastExtent)
+        ];
+    }
+    getTileXY(lonLat, zoom) {
+        let z = zoom, x = -1, y = -1, pz = (1 << z);
+        if (lonLat.lon > 0) {
+            x = getTileCellIndex(lonLat.lon, 180 / pz, 0) + pz;
+        }
+        else {
+            x = getTileCellIndex(lonLat.lon, 180 / pz, -180);
+        }
+        y = getTileCellIndex(lonLat.lat, 180 / pz, 90);
+        return [x, y, z, TILEGROUP_COMMON];
+    }
+    getLonLatTileOffset(lonLat, x, y, z, gridSize) {
+        let coords = lonLat;
+        let extent = new Extent();
+        if (lonLat.lon > 0) {
+            extent = getTileCellExtent(x - (1 << z), y, z, this._eastExtent);
+        }
+        else {
+            extent = getTileCellExtent(x, y, z, this._westExtent);
+        }
+        let sizeImgW = extent.getWidth() / (gridSize - 1), sizeImgH = extent.getHeight() / (gridSize - 1);
+        let i = gridSize - Math.ceil((coords.lat - extent.southWest.lat) / sizeImgH) - 1, j = Math.floor((coords.lon - extent.southWest.lon) / sizeImgW);
+        return [i, j];
+    }
+    createEntitiCollectionsTreeStrategy(layer, nodeCapacity) {
+        return new EquiEntityCollectionsTreeStrategy(layer, nodeCapacity);
+    }
+    collectVisibleNode(node) {
+        let ext = node.segment.getExtent();
+        if (ext.southWest.lon < 0) {
+            this._visibleNodesWest[node.nodeId] = node;
+        }
+        else {
+            this._visibleNodesEast[node.nodeId] = node;
+        }
+    }
+    _clearVisibleNodes() {
+        this._visibleNodesWest = {};
+        this._visibleNodesEast = {};
+    }
+}

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

@@ -1,12 +1,12 @@
-import { EarthQuadTreeStrategy } from "./EarthQuadTreeStrategy";
-import { MarsQuadTreeStrategy } from "./MarsQuadTreeStrategy";
-import { EPSG4326QuadTreeStrategy } from "./EPSG4326QuadTreeStrategy";
+import { EarthQuadTreeStrategy } from "./earth/EarthQuadTreeStrategy";
+import { EquiQuadTreeStrategy } from "./equi/EquiQuadTreeStrategy";
+import { EPSG4326QuadTreeStrategy } from "./EPSG4326/EPSG4326QuadTreeStrategy";
 import { QuadTreeStrategy } from "./QuadTreeStrategy";
-import { Wgs84QuadTreeStrategy } from "./Wgs84QuadTreeStrategy";
+import { Wgs84QuadTreeStrategy } from "./wgs84/Wgs84QuadTreeStrategy";
 declare const quadTreeStrategyType: {
     epsg4326: typeof EPSG4326QuadTreeStrategy;
     earth: typeof EarthQuadTreeStrategy;
-    mars: typeof MarsQuadTreeStrategy;
+    equi: typeof EquiQuadTreeStrategy;
     wgs84: typeof Wgs84QuadTreeStrategy;
 };
-export { quadTreeStrategyType, QuadTreeStrategy, Wgs84QuadTreeStrategy, MarsQuadTreeStrategy, EarthQuadTreeStrategy };
+export { quadTreeStrategyType, QuadTreeStrategy, Wgs84QuadTreeStrategy, EquiQuadTreeStrategy, EarthQuadTreeStrategy };

package/lib/js/quadTree/index.js

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

package/lib/{@openglobus/js/quadTree → js/quadTree/wgs84}/Wgs84QuadTreeStrategy.d.ts

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

package/lib/js/quadTree/wgs84/Wgs84QuadTreeStrategy.js

@@ -0,0 +1,15 @@
+import { Extent } from "../../Extent";
+import { EPSG4326 } from "../../proj/EPSG4326";
+import { Node } from "../Node";
+import { SegmentLonLatEqui } from "../../segment/SegmentLonLatEqui";
+import { QuadTreeStrategy } from "../QuadTreeStrategy";
+export class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
+    constructor(planet) {
+        super(planet, "wgs84", EPSG4326);
+    }
+    init() {
+        this._quadTreeList = [
+            new Node(SegmentLonLatEqui, this.planet, 0, null, 0, Extent.createFromArray([-180, -90, 180, 90]))
+        ];
+    }
+}

package/lib/js/renderer/Renderer.d.ts

@@ -16,6 +16,8 @@ interface IRendererParams {
     msaa?: number;
     autoActivate?: boolean;
     fontsSrc?: string;
+    gamma?: number;
+    exposure?: number;
 }
 interface IPickingObject {
     _pickingColor?: Vec3;

package/lib/js/renderer/Renderer.js

@@ -130,8 +130,8 @@ class Renderer {
         };
         this.div = null;
         this.handler = handler;
-        this.exposure = 3.01;
-        this.gamma = 0.47;
+        this.exposure = params.exposure || 3.01;
+        this.gamma = params.gamma || 0.47;
         this.whitepoint = 1.0;
         this.brightThreshold = 0.9;
         this._renderNodesArr = [];

package/lib/js/scene/Planet.d.ts

@@ -184,33 +184,6 @@ export declare class Planet extends RenderNode {
     _renderedNodesInFrustum: Node[][];
     _fadingNodes: Map<number, Node>;
     _fadingNodesInFrustum: Node[][];
-    /**
-     * Current visible mercator segments tree nodes array.
-     * @public
-     * @type {Node}
-     *
-     * @todo
-     * _visibleNodes, _visibleNodesNorth and _visibleNodesSouth should
-     * be replaced to strategy and Vector layer reworked in collecting methods.
-     * _visibleNodes, and _visibleNodesNorth and South are used in Vector
-     * layer only, for entity terrain collision
-     *
-     */
-    _visibleNodes: Record<number, Node>;
-    /**
-     * 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>;
     /**
      * Layers activity lock.
      * @public

package/lib/js/scene/Planet.js

@@ -6,7 +6,7 @@ import { Atmosphere } from "../control/Atmosphere";
 import { createColorRGB } from "../utils/shared";
 import { createEvents } from "../Events";
 import { decodeFloatFromRGBAArr } from "../math/coder";
-import { EarthQuadTreeStrategy } from "../quadTree/EarthQuadTreeStrategy";
+import { EarthQuadTreeStrategy } from "../quadTree/earth/EarthQuadTreeStrategy";
 import { Extent } from "../Extent";
 import { Geoid } from "../terrain/Geoid";
 import { GeoImageCreator } from "../utils/GeoImageCreator";
@@ -108,7 +108,7 @@ export class Planet extends RenderNode {
         this.transitionTime = 580;
         this.ellipsoid = options.ellipsoid || wgs84;
         this.lightEnabled = true;
-        this._planetRadius2 = this.ellipsoid.getPolarSize() * this.ellipsoid.getPolarSize();
+        this._planetRadius2 = (this.ellipsoid.getPolarSize() - 10000.0) * (this.ellipsoid.getPolarSize() - 10000.0);
         this._layers = [];
         this._updateLayer = false;
         this.visibleTileLayers = [];
@@ -142,9 +142,6 @@ export class Planet extends RenderNode {
         this._renderedNodesInFrustum = [];
         this._fadingNodes = new Map;
         this._fadingNodesInFrustum = [];
-        this._visibleNodes = {};
-        this._visibleNodesNorth = {};
-        this._visibleNodesSouth = {};
         this.layerLock = new Lock();
         this.terrainLock = new Lock();
         this._heightFactor = 1.0;
@@ -798,10 +795,6 @@ export class Planet extends RenderNode {
         this._viewExtent.southWest.set(180, 180);
         this._viewExtent.northEast.set(-180, -180);
         // todo: replace to camera
-        this._visibleNodes = {};
-        this._visibleNodesNorth = {};
-        this._visibleNodesSouth = {};
-        // todo: replace to camera
         this.minCurrZoom = math.MAX;
         this.maxCurrZoom = math.MIN;
         this.quadTreeStrategy.collectRenderNodes();

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

@@ -277,7 +277,6 @@ declare class Segment {
     colorPickingRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;
     depthRendering(sh: Program, layerSlice: Layer[]): void;
     protected _getIndexBuffer(): WebGLBufferExt;
-    _collectVisibleNodes(): void;
     layerOverlap(layer: Layer): boolean;
     getDefaultTexture(): WebGLTextureExt | null;
     getExtentLonLat(): Extent;

package/lib/js/segment/Segment.js

@@ -1174,9 +1174,6 @@ class Segment {
         }
         return cache.buffer;
     }
-    _collectVisibleNodes() {
-        this.planet._visibleNodes[this.node.nodeId] = this.node;
-    }
     layerOverlap(layer) {
         return this._extent.overlaps(layer._extentMerc);
     }

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

@@ -25,10 +25,6 @@ declare class SegmentLonLat extends Segment {
     protected _assignTileYIndexes(extent: Extent): void;
     protected _projToDeg(lon: number, lat: number): LonLat;
     protected _assignGlobalTextureCoordinates(): void;
-    /**
-     * @todo: replace to the strategy
-     */
-    _collectVisibleNodes(): void;
     /**
      * @param layer
      * @protected

package/lib/js/segment/SegmentLonLat.js

@@ -80,17 +80,6 @@ class SegmentLonLat extends Segment {
         this._globalTextureCoordinates[2] = (e.northEast.lon + 180.0) / 360.0;
         this._globalTextureCoordinates[3] = (90 - e.southWest.lat) / 180.0;
     }
-    /**
-     * @todo: replace to the strategy
-     */
-    _collectVisibleNodes() {
-        if (this._isNorth) {
-            this.planet._visibleNodesNorth[this.node.nodeId] = this.node;
-        }
-        else {
-            this.planet._visibleNodesSouth[this.node.nodeId] = this.node;
-        }
-    }
     /**
      * @param layer
      * @protected

package/lib/js/segment/{SegmentLonLatWgs84.d.ts → SegmentLonLatEqui.d.ts}

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

package/lib/js/segment/{SegmentLonLatWgs84.js → SegmentLonLatEqui.js}

@@ -1,8 +1,10 @@
 import { SegmentLonLat } from "./SegmentLonLat";
 import { getTileCellIndex, TILEGROUP_COMMON } from "./Segment";
-export class SegmentLonLatWgs84 extends SegmentLonLat {
+import { equi } from "../proj/equi";
+export class SegmentLonLatEqui extends SegmentLonLat {
     constructor(node, planet, tileZoom, extent) {
         super(node, planet, tileZoom, extent);
+        this._projection = equi;
         this.isPole = false;
         this._tileGroup = TILEGROUP_COMMON;
     }

package/lib/js/shaders/geoObject.js

@@ -24,6 +24,7 @@ export const geo_object = () => new Program("geo_object", {
         aPositionLow: { type: "vec3", divisor: 1 },
         aColor: { type: "vec4", divisor: 1 },
         aScale: { type: "vec3", divisor: 1 },
+        aTranslate: { type: "vec3", divisor: 1 },
         aDispose: { type: "float", divisor: 1 },
         qRot: { type: "vec4", divisor: 1 }
     },
@@ -35,6 +36,7 @@ export const geo_object = () => new Program("geo_object", {
             attribute vec3 aPositionLow;    
             attribute vec4 aColor;
             attribute vec3 aScale;
+            attribute vec3 aTranslate;
             attribute float aDispose;
             attribute float aUseTexture;
             attribute vec2 aTexCoord;
@@ -91,7 +93,7 @@ export const geo_object = () => new Program("geo_object", {
                 // use scaleByDistance: [1.0, 1.0, 1.0] for real sized objects 
                 float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
                 
-                vec3 vert = qRotate(qRot, (aVertexPosition * aScale)) * scd;
+                vec3 vert = qRotate(qRot, scd * (aVertexPosition * aScale + aTranslate));
                 
                 vert += lowDiff;
                                
@@ -146,7 +148,7 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
         uScaleByDistance: "vec3",
         eyePositionHigh: "vec3",
         eyePositionLow: "vec3",
-        pickingScale: "float"
+        pickingScale: "vec3"
     },
     attributes: {
         aVertexPosition: "vec3",
@@ -154,6 +156,7 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
         aPositionLow: { type: "vec3", divisor: 1 },
         aPickingColor: { type: "vec3", divisor: 1 },
         aScale: { type: "vec3", divisor: 1 },
+        aTranslate: { type: "vec3", divisor: 1 },
         aDispose: { type: "float", divisor: 1 },
         qRot: { type: "vec4", divisor: 1 }
     },
@@ -164,6 +167,7 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
             attribute vec3 aPositionLow;
             attribute vec3 aPickingColor;    
             attribute vec3 aScale;
+            attribute vec3 aTranslate;
             attribute float aDispose;
             attribute vec4 qRot;
             
@@ -172,7 +176,7 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
             uniform vec3 uScaleByDistance;
             uniform mat4 projectionMatrix;
             uniform mat4 viewMatrix;
-            uniform float pickingScale;
+            uniform vec3 pickingScale;
 
             varying vec3 vColor;
             
@@ -210,9 +214,10 @@ export const geo_object_picking = () => new Program("geo_object_picking", {
                  // @hack
                  // pickingScale replace to this line, because when it s
                  // tays in the vert above it affects on Mac Safari jitter
-                 float scd = pickingScale * uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
+                 float scd = uScaleByDistance[2] * clamp(lookLength, uScaleByDistance[0], uScaleByDistance[1]) / uScaleByDistance[0];
 
-                 vec3 vert = qRotate(qRot, (aVertexPosition * aScale)) * scd;
+                 //vec3 vert = qRotate(qRot, (aVertexPosition * aScale + aTranslate) * pickingScale) * scd;
+                 vec3 vert = qRotate(qRot, scd * pickingScale * (aVertexPosition * aScale + aTranslate));
                  
                  vert += lowDiff;
                                 

package/lib/js/shaders/polyline.js

@@ -7,7 +7,7 @@ export function polyline_screen() {
             view: "mat4",
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
-            uFloatParams: "vec2",
+            //uFloatParams: "vec2",
             thickness: "float",
             opacity: "float",
             depthOffset: "float"
@@ -161,14 +161,15 @@ export function polyline_screen() {
                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
                 }`,
         fragmentShader: `precision highp float;
-                uniform vec2 uFloatParams;
+                //uniform vec2 uFloatParams;
                 varying vec3 uCamPos;
                 varying vec4 vColor;
                 varying vec3 vPos;
                 void main() {
                     vec3 look = vPos - uCamPos;
                     float lookLength = length(look);
-                    float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
+                    //float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
+                    float a = vColor.a;
                     gl_FragColor = vec4(vColor.rgb, a);
                 }`
     });
@@ -181,7 +182,7 @@ export function polyline_picking() {
             view: "mat4",
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
-            uFloatParams: "vec2",
+            //uFloatParams: "vec2",
             color: "vec4",
             thickness: "float",
             depthOffset: "float"
@@ -331,14 +332,15 @@ export function polyline_picking() {
                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
                 }`,
         fragmentShader: `precision highp float;
-                uniform vec2 uFloatParams;
+                //uniform vec2 uFloatParams;
                 varying vec3 uCamPos;
                 varying vec4 vColor;
                 varying vec3 vPos;
                 void main() {
                     vec3 look = vPos - uCamPos;
                     float lookLength = length(look);
-                    float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));                    
+                    //float a = vColor.a * step(lookLength, sqrt(dot(uCamPos,uCamPos) - uFloatParams[0]) + sqrt(dot(vPos,vPos) - uFloatParams[0]));
+                    float a = vColor.a;                    
                     gl_FragColor = vec4(vColor.rgb, a);
                 }`
     });

package/lib/js/terrain/RgbTerrain.d.ts

@@ -7,16 +7,36 @@ export interface IRgbTerrainParams extends IGlobusTerrainParams {
     equalizeNormals?: boolean;
     key?: string;
     imageSize?: number;
+    minHeight?: number;
+    resolution?: number;
 }
+/**
+ * @class
+ * @extends {GlobusTerrain}
+ * @param {string} [name=""] - Terrain provider name.
+ * @param {IRgbTerrainParams} [options]:
+ * @param {boolean} [equalizeNormals=true] - Make normal equalization on the edges of the tiles.
+ * @param {string} [key=""] - API key.
+ * @param {number} [imageSize=256] - Image size.
+ * @param {number} [minHeight=-10000] - Minimal height for rgb to height converter.
+ * @param {number} [resolution=0.1] - Height converter resolution.
+ */
 declare class RgbTerrain extends GlobusTerrain {
     protected _imageSize: number;
     protected _ctx: CanvasRenderingContext2D;
     protected _imageDataCache: Record<string, Uint8ClampedArray>;
+    protected _minHeight: number;
+    protected _resolution: number;
     constructor(name: string | null, options?: IRgbTerrainParams);
     static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
+    rgb2Height(r: number, g: number, b: number): number;
     isBlur(segment: Segment): boolean;
     protected _createTemporalCanvas(size: number): CanvasRenderingContext2D;
     protected _createHeights(data: HTMLImageElement | ImageBitmap, segment: Segment | null, tileGroup: number, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
     getHeightAsync(lonLat: LonLat, callback: (h: number) => void, zoom?: number): boolean;
+    extractElevationSimple(rgbaData: number[] | TypedArray, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentOffsetX: number, availableParentOffsetY: number, availableZoomDiff: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray, heightFactor: number | undefined, imageSize: number): void;
+    extractElevationTilesRgbNonPowerOfTwo(rgbaData: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, heightFactor?: number): void;
+    extractElevationTilesRgb(rgbaData: number[] | TypedArray, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentTileX: number, availableParentTileY: number, availableParentTileZoom: number, currentTileX: number, currentTileY: number, currentTileZoom: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]): void;
+    extractElevationTilesRgbNoChildren(rgbaData: number[] | TypedArray, heightFactor: number, noDataValues: number[] | TypedArray, availableParentData: (TypedArray | number[] | null) | undefined, availableParentTileX: number, availableParentTileY: number, availableParentTileZoom: number, currentTileX: number, currentTileY: number, currentTileZoom: number, skipPositiveHeights: boolean, outCurrenElevations: number[] | TypedArray): void;
 }
 export { RgbTerrain };