@openglobus/og 0.18.0 → 0.18.2

package/{src/shaders/polyline.ts → lib/js/shaders/polyline.js}

@@ -1,6 +1,5 @@
 import { Program } from '../webgl/Program';
-
-export function polyline_screen(): Program {
+export function polyline_screen() {
     return new Program("polyline_screen", {
         uniforms: {
             viewport: "vec2",
@@ -17,18 +16,13 @@ export function polyline_screen(): Program {
             prevHigh: "vec3",
             currentHigh: "vec3",
             nextHigh: "vec3",
-
             prevLow: "vec3",
             currentLow: "vec3",
             nextLow: "vec3",
-
             order: "float",
-
             color: "vec4"
         },
-
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
 
                 attribute vec3 prevHigh;
                 attribute vec3 currentHigh;
@@ -166,9 +160,7 @@ export function polyline_screen(): Program {
 
                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
                 }`,
-
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
                 uniform vec2 uFloatParams;
                 varying vec3 uCamPos;
                 varying vec4 vColor;
@@ -181,8 +173,7 @@ export function polyline_screen(): Program {
                 }`
     });
 }
-
-export function polyline_picking(): Program {
+export function polyline_picking() {
     return new Program("polyline_picking", {
         uniforms: {
             viewport: "vec2",
@@ -199,16 +190,12 @@ export function polyline_picking(): Program {
             prevHigh: "vec3",
             currentHigh: "vec3",
             nextHigh: "vec3",
-
             prevLow: "vec3",
             currentLow: "vec3",
             nextLow: "vec3",
-
             order: "float"
         },
-
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
                 
                 attribute vec3 prevHigh;
                 attribute vec3 currentHigh;
@@ -343,9 +330,7 @@ export function polyline_picking(): Program {
                     }
                     gl_Position = vec4((2.0 * m / viewport - 1.0) * dCurrent.w, dCurrent.z + depthOffset, dCurrent.w);
                 }`,
-
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
                 uniform vec2 uFloatParams;
                 varying vec3 uCamPos;
                 varying vec4 vColor;
@@ -357,4 +342,4 @@ export function polyline_picking(): Program {
                     gl_FragColor = vec4(vColor.rgb, a);
                 }`
     });
-}
+}

package/lib/js/shaders/ray.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function rayScreen(): Program;

package/{src/shaders/ray.ts → lib/js/shaders/ray.js}

@@ -1,6 +1,5 @@
-import {Program} from '../webgl/Program';
-
-export function rayScreen(): Program {
+import { Program } from '../webgl/Program';
+export function rayScreen() {
     return new Program("rayScreen", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -19,8 +18,7 @@ export function rayScreen(): Program {
             a_thickness: "float",
             a_rgba: "vec4"
         },
-        vertexShader:
-            `precision highp float;
+        vertexShader: `precision highp float;
 
             attribute vec4 a_rgba;
             attribute vec3 a_startPosHigh;
@@ -69,8 +67,7 @@ export function rayScreen(): Program {
                 
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + vert, 1.0);
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             varying vec4 v_rgba;
             void main () {
                 gl_FragColor = v_rgba;

package/lib/js/shaders/screenFrame.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function screenFrame(): Program;

package/{src/shaders/screenFrame.ts → lib/js/shaders/screenFrame.js}

@@ -1,6 +1,5 @@
-import {Program} from '../webgl/Program';
-
-export function screenFrame(): Program {
+import { Program } from '../webgl/Program';
+export function screenFrame() {
     return new Program("screenFrame", {
         uniforms: {
             texture: "sampler2d"
@@ -8,16 +7,14 @@ export function screenFrame(): Program {
         attributes: {
             corners: "vec3"
         },
-        vertexShader:
-            `attribute vec2 corners;
+        vertexShader: `attribute vec2 corners;
             
             varying vec2 tc;
             void main(void) {
                 gl_Position = vec4(corners, 0.0, 1.0);
                 tc = corners * 0.5 + 0.5;
             }`,
-        fragmentShader:
-            `precision highp float;
+        fragmentShader: `precision highp float;
             uniform sampler2D texture;
             
             varying vec2 tc;
@@ -26,4 +23,4 @@ export function screenFrame(): Program {
                 gl_FragColor = texture2D( texture, tc );
             }`
     });
-}
+}

package/lib/js/shaders/skybox.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function skybox(): Program;

package/{src/shaders/skybox.ts → lib/js/shaders/skybox.js}

@@ -1,18 +1,16 @@
-import {Program} from '../webgl/Program';
-import {types} from '../webgl/types';
-
-export function skybox(): Program {
+import { Program } from '../webgl/Program';
+import { types } from '../webgl/types';
+export function skybox() {
     return new Program("skybox", {
         uniforms: {
-            projectionViewMatrix: {type: types.MAT4},
-            uSampler: {type: types.SAMPLERCUBE},
-            pos: {type: types.VEC3}
+            projectionViewMatrix: { type: types.MAT4 },
+            uSampler: { type: types.SAMPLERCUBE },
+            pos: { type: types.VEC3 }
         },
         attributes: {
-            aVertexPosition: {type: types.VEC3, enableArray: true}
+            aVertexPosition: { type: types.VEC3, enableArray: true }
         },
-        vertexShader:
-            `attribute vec3 aVertexPosition;
+        vertexShader: `attribute vec3 aVertexPosition;
             uniform mat4 projectionViewMatrix;
             uniform vec3 pos;
             varying vec3 vTextureCoord;
@@ -20,12 +18,11 @@ export function skybox(): Program {
                 vTextureCoord = aVertexPosition;
                 gl_Position = projectionViewMatrix * vec4(aVertexPosition + pos, 1.0);
             }`,
-        fragmentShader:
-            `precision lowp float;
+        fragmentShader: `precision lowp float;
             varying vec3 vTextureCoord;
             uniform samplerCube uSampler;
             void main(void) {
                 gl_FragColor = textureCube(uSampler, vTextureCoord);
             }`
     });
-}
+}

package/lib/js/shaders/toneMapping.d.ts

@@ -0,0 +1,2 @@
+import { Program } from '../webgl/Program';
+export declare function toneMapping(): Program;

package/{src/shaders/toneMapping.ts → lib/js/shaders/toneMapping.js}

@@ -1,6 +1,5 @@
-import {Program} from '../webgl/Program';
-
-export function toneMapping(): Program {
+import { Program } from '../webgl/Program';
+export function toneMapping() {
     return new Program("toneMapping", {
         uniforms: {
             hdrBuffer: "sampler2d",
@@ -11,8 +10,7 @@ export function toneMapping(): Program {
         attributes: {
             corners: "vec3"
         },
-        vertexShader:
-            `#version 300 es
+        vertexShader: `#version 300 es
             
             in vec2 corners;
             
@@ -22,8 +20,7 @@ export function toneMapping(): Program {
                 gl_Position = vec4(corners, 0.0, 1.0);
                 tc = corners * 0.5 + 0.5;
             }`,
-        fragmentShader:
-            `#version 300 es
+        fragmentShader: `#version 300 es
 
             precision highp float;
 
@@ -85,4 +82,4 @@ export function toneMapping(): Program {
                 fragColor = vec4(mapped, hdrColor.a);
             }`
     });
-}
+}

package/lib/js/shaders/utils.d.ts

@@ -0,0 +1 @@
+export declare const UTILS = "\n    float getLerpValue(in float min, in float max, in float between)\n    {\n        return (clamp(between, min, max) - min) / (max - min);\n    }\n    \n    vec3 aces(vec3 color) \n    {\n        float a = 2.51;\n        float b = 0.03;\n        float c = 2.43;\n        float d = 0.59;\n        float e = 0.14;\n        return clamp((color * (a * color + b)) / (color * (c * color + d ) + e), 0.0, 1.0);\n    }\n     \n    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t1, inout float t2) \n    {\n        float b = dot(rayDirection, rayOrigin);\n        float c = dot(rayOrigin, rayOrigin) - radius * radius;\n        float d = b * b - c;\n        if (d < 0.0) {\n            return false;\n        }\n        t1 = -b - sqrt(d);\n        t2 = -b + sqrt(d);\n        return true;\n    }\n    \n    bool intersectSphere(vec3 rayOrigin, vec3 rayDirection, float radius, inout float t) \n    {\n        float b = dot(rayDirection, rayOrigin);\n        float c = dot(rayOrigin, rayOrigin) - radius * radius;\n        float d = b * b - c;\n        if (d < 0.0) {\n            return false;\n        }\n        t = -b - sqrt(d);\n        return true;\n    }\n    \n    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t )\n    {\n        vec3 ocn = ro/ra;\n        vec3 rdn = rd/ra;\n        float a = dot( rdn, rdn );\n        float b = dot( ocn, rdn );\n        float c = dot( ocn, ocn );\n        float h = b*b - a*(c-1.0);\n                       \n        if (h < 0.0) \n        { \n            return false; \n        }\n        \n        t = (-b-sqrt(h))/a;\n        \n        return true;\n    }\n    \n    bool intersectEllipsoid( in vec3 ro, in vec3 rd, in vec3 ra, inout float t1, inout float t2)\n    {\n        vec3 ocn = ro/ra;\n        vec3 rdn = rd/ra;\n        float a = dot( rdn, rdn );\n        float b = dot( ocn, rdn );\n        float c = dot( ocn, ocn );\n        float h = b*b - a*(c-1.0);\n                \n        if (h < 0.0) \n        { \n            return false; \n        }\n        \n        h = sqrt(h);\n        t1 = (-b-h)/a;\n        t2 = (-b+h)/a;\n        \n        return true;\n    }\n    \n    vec3 normalEllipsoid( in vec3 pos, in vec3 ra )\n    {\n        return normalize( pos/(ra*ra) );\n    }\n";

package/{src/shaders/utils.ts → lib/js/shaders/utils.js}

@@ -83,4 +83,4 @@ export const UTILS = `
     {
         return normalize( pos/(ra*ra) );
     }
-`;
+`;

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

@@ -0,0 +1,18 @@
+import { GlobusTerrain, IGlobusTerrainParams } from "./GlobusTerrain";
+import { Segment } from "../segment/Segment";
+import { Extent } from "../Extent";
+import { TypedArray } from "../utils/shared";
+interface IBilTerrainParams extends IGlobusTerrainParams {
+    layers?: string;
+    imageSize?: number;
+}
+declare class BilTerrain extends GlobusTerrain {
+    protected _format: string;
+    protected _layers: string;
+    protected _imageSize: number;
+    constructor(options?: IBilTerrainParams);
+    isBlur(segment: Segment): boolean;
+    protected _createUrl(segment: Segment): string;
+    protected _createHeights(data: number[], tileIndex: string, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[];
+}
+export { BilTerrain };

package/{src/terrain/BilTerrain.ts → lib/js/terrain/BilTerrain.js}

@@ -1,75 +1,33 @@
-import {getTileExtent} from "../mercator";
-import {GlobusTerrain, IGlobusTerrainParams} from "./GlobusTerrain";
-import {Layer} from "../layer/Layer";
-import {WMS} from "../layer/WMS";
-import {isPowerOfTwo, nextHighestPowerOfTwo} from "../math";
-import {Segment} from "../segment/Segment";
-import {Extent} from "../Extent";
-import {TypedArray} from "../utils/shared";
-
-interface IBilTerrainParams extends IGlobusTerrainParams {
-    layers?: string;
-    imageSize?: number;
-}
-
+import { getTileExtent } from "../mercator";
+import { GlobusTerrain } from "./GlobusTerrain";
+import { Layer } from "../layer/Layer";
+import { WMS } from "../layer/WMS";
+import { isPowerOfTwo, nextHighestPowerOfTwo } from "../math";
 class BilTerrain extends GlobusTerrain {
-
-    protected _format: string;
-
-    protected _layers: string;
-
-    protected _imageSize: number;
-
-    constructor(options: IBilTerrainParams = {}) {
+    constructor(options = {}) {
         super("BilTerrain", options);
-
         this.equalizeVertices = true;
-
         this.equalizeNormals = true;
-
         this.minZoom = options.minZoom || 2;
-
         this.maxZoom = options.maxZoom || 14;
-
         this.noDataValues = options.noDataValues || [-9999, 32767];
-
         this.url = options.url || "";
-
         this._format = "application/bil16";
-
         this._layers = options.layers || "";
-
         this._imageSize = options.imageSize || 256;
-
         this.plainGridSize = options.plainGridSize != undefined
             ? options.plainGridSize
             : isPowerOfTwo(this._imageSize) ? this._imageSize / 2 : nextHighestPowerOfTwo(this._imageSize) / 2;
-
         this._dataType = "arrayBuffer";
     }
-
-    public override isBlur(segment: Segment): boolean {
+    isBlur(segment) {
         return segment.tileZoom >= 18;
     }
-
-    protected override _createUrl(segment: Segment): string {
-        return WMS.createRequestUrl(
-            this.url,
-            this._layers,
-            this._format,
-            "1.1.1",
-            "GetMap",
-            segment._projection.code,
-            WMS.get_bbox_v1_1_1(segment.getExtent()),
-            this._imageSize,
-            this._imageSize
-        );
+    _createUrl(segment) {
+        return WMS.createRequestUrl(this.url, this._layers, this._format, "1.1.1", "GetMap", segment._projection.code, WMS.get_bbox_v1_1_1(segment.getExtent()), this._imageSize, this._imageSize);
     }
-
-    protected override _createHeights(data: number[], tileIndex: string, tileX: number, tileY: number, tileZoom: number, extent: Extent, preventChildren: boolean): TypedArray | number[] {
-
+    _createHeights(data, tileIndex, tileX, tileY, tileZoom, extent, preventChildren) {
         let bil16 = new Int16Array(data);
-
         //
         //Non-power of two images
         //
@@ -79,36 +37,25 @@ class BilTerrain extends GlobusTerrain {
             extractElevationTilesNonPowerOfTwo(bil16, outCurrenElevations);
             return outCurrenElevations;
         }
-
         let elevationsSize = (this.plainGridSize + 1) * (this.plainGridSize + 1);
-
         let d = 4;
-
         let outChildrenElevations = new Array(d);
-
         for (let i = 0; i < d; i++) {
             outChildrenElevations[i] = [];
             for (let j = 0; j < d; j++) {
                 outChildrenElevations[i][j] = new Float32Array(elevationsSize);
             }
         }
-
         let outCurrenElevations = new Float32Array(elevationsSize);
-
         extractElevationTiles(bil16, this.noDataValues, outCurrenElevations, outChildrenElevations);
-
         this._elevationCache[tileIndex] = {
             heights: outCurrenElevations,
             extent: extent
         };
-
         let dd = this._imageSize / this.plainGridSize;
-
         for (let i = 0; i < dd; i++) {
             for (let j = 0; j < dd; j++) {
-                let x = tileX * 2 + j,
-                    y = tileY * 2 + i,
-                    z = tileZoom + 1;
+                let x = tileX * 2 + j, y = tileY * 2 + i, z = tileZoom + 1;
                 let tileIndex = Layer.getTileIndex(x, y, z);
                 this._elevationCache[tileIndex] = {
                     heights: outChildrenElevations[i][j],
@@ -116,134 +63,90 @@ class BilTerrain extends GlobusTerrain {
                 };
             }
         }
-
         return outCurrenElevations;
     }
 }
-
-function extractElevationTilesNonPowerOfTwo(data: number[] | TypedArray, outCurrenElevations: number[] | TypedArray) {
+function extractElevationTilesNonPowerOfTwo(data, outCurrenElevations) {
     for (let i = 0, len = outCurrenElevations.length; i < len; i++) {
         outCurrenElevations[i] = data[i];
     }
 }
-
-function extractElevationTiles(data: number[] | TypedArray, noDataValues: number[] | TypedArray, outCurrenElevations: number[] | TypedArray, outChildrenElevations: number[][][] | TypedArray[][]) {
+function extractElevationTiles(data, noDataValues, outCurrenElevations, outChildrenElevations) {
     let destSize = Math.sqrt(outCurrenElevations.length) - 1;
     let destSizeOne = destSize + 1;
     let sourceSize = Math.sqrt(data.length);
     let dt = sourceSize / destSize;
-
-    let rightHeight = 0,
-        bottomHeight = 0;
-
+    let rightHeight = 0, bottomHeight = 0;
     for (let k = 0, currIndex = 0, sourceDataLength = data.length; k < sourceDataLength; k++) {
         let height = data[k];
-
-        let isNoDataCurrent = BilTerrain.checkNoDataValue(noDataValues, height),
-            isNoDataRight = false,
-            isNoDataBottom = false;
-
-        let i = Math.floor(k / sourceSize),
-            j = k % sourceSize;
-
-        let tileX = Math.floor(j / destSize),
-            tileY = Math.floor(i / destSize);
-
+        let isNoDataCurrent = BilTerrain.checkNoDataValue(noDataValues, height), isNoDataRight = false, isNoDataBottom = false;
+        let i = Math.floor(k / sourceSize), j = k % sourceSize;
+        let tileX = Math.floor(j / destSize), tileY = Math.floor(i / destSize);
         let destArr = outChildrenElevations[tileY][tileX];
-
-        let ii = i % destSize,
-            jj = j % destSize;
-
+        let ii = i % destSize, jj = j % destSize;
         let destIndex = (ii + tileY) * destSizeOne + jj + tileX;
-
         destArr[destIndex] = height;
-
         if ((i + tileY) % dt === 0 && (j + tileX) % dt === 0) {
             outCurrenElevations[currIndex++] = height;
         }
-
         if ((j + 1) % destSize === 0 && j !== sourceSize - 1) {
             //current tile
             rightHeight = data[k];
-
             isNoDataRight = BilTerrain.checkNoDataValue(noDataValues, rightHeight);
-
             let middleHeight = height;
             if (!(isNoDataCurrent || isNoDataRight)) {
                 middleHeight = (height + rightHeight) * 0.5;
             }
-
             destIndex = (ii + tileY) * destSizeOne + jj + 1;
             destArr[destIndex] = middleHeight;
-
             if ((i + tileY) % dt === 0) {
                 outCurrenElevations[currIndex++] = middleHeight;
             }
-
             //next right tile
             let rightindex = (ii + tileY) * destSizeOne + ((jj + 1) % destSize);
             outChildrenElevations[tileY][tileX + 1][rightindex] = middleHeight;
         }
-
         if ((i + 1) % destSize === 0 && i !== sourceSize - 1) {
             //current tile
             bottomHeight = data[k + sourceSize];
-
             isNoDataBottom = BilTerrain.checkNoDataValue(noDataValues, bottomHeight);
-
             let middleHeight = height;
-
             if (!(isNoDataCurrent || isNoDataBottom)) {
                 middleHeight = (height + bottomHeight) * 0.5;
             }
-
             destIndex = (ii + 1) * destSizeOne + jj + tileX;
             destArr[destIndex] = middleHeight;
-
             if ((j + tileX) % dt === 0) {
                 outCurrenElevations[currIndex++] = middleHeight;
             }
-
             //next bottom tile
             let bottomindex = ((ii + 1) % destSize) * destSizeOne + jj + tileX;
             outChildrenElevations[tileY + 1][tileX][bottomindex] = middleHeight;
         }
-
-        if (
-            (j + 1) % destSize === 0 &&
+        if ((j + 1) % destSize === 0 &&
             j !== sourceSize - 1 &&
             (i + 1) % destSize === 0 &&
-            i !== sourceSize - 1
-        ) {
+            i !== sourceSize - 1) {
             //current tile
             let rightBottomHeight = data[k + sourceSize + 1];
-
             let isNoDataRightBottom = BilTerrain.checkNoDataValue(noDataValues, rightBottomHeight);
-
             let middleHeight = height;
-
             if (!(isNoDataCurrent || isNoDataRight || isNoDataBottom || isNoDataRightBottom)) {
                 middleHeight = (height + rightHeight + bottomHeight + rightBottomHeight) * 0.25;
             }
-
             destIndex = (ii + 1) * destSizeOne + (jj + 1);
             destArr[destIndex] = middleHeight;
-
             outCurrenElevations[currIndex++] = middleHeight;
-
             //next right tile
             let rightindex = (ii + 1) * destSizeOne;
             outChildrenElevations[tileY][tileX + 1][rightindex] = middleHeight;
-
             //next bottom tile
             let bottomindex = destSize;
             outChildrenElevations[tileY + 1][tileX][bottomindex] = middleHeight;
-
             //next right bottom tile
             let rightBottomindex = 0;
             outChildrenElevations[tileY + 1][tileX + 1][rightBottomindex] = middleHeight;
         }
     }
 }
-
-export {BilTerrain};
+export { BilTerrain };

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

@@ -0,0 +1,106 @@
+import { TypedArray } from "../utils/shared";
+import { Geoid } from "./Geoid";
+import { LonLat } from "../LonLat";
+import { Planet } from "../scene/Planet";
+import { Segment } from "../segment/Segment";
+export interface IEmptyTerrainParams {
+    equalizeVertices?: boolean;
+    name?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    maxNativeZoom?: number;
+    geoidSrc?: string;
+    geoid?: Geoid;
+    gridSizeByZoom?: number[];
+}
+/**
+ * Class represents terrain provider without elevation data.
+ * @param {IEmptyTerrainParams} [options] - Provider options:
+ * @param {string} [options.name="empty"] - Provider name.
+ * @param {boolean} [options.equalizeVertices] -
+ * @param {number} [options.minZoom=2] - Minimal visible zoom index when terrain handler works.
+ * @param {number} [options.minZoom=50] - Maximal visible zoom index when terrain handler works.
+ * @param {number} [options.maxNativeZoom=19] - Maximal available terrain zoom level.
+ * @param {Array.<number>} [options.gridSizeByZoom] - Array of segment triangulation grid sizes where array index agreed to the segment zoom index.
+ * @param {Array.<number>} [gridSizeByZoom] - Array of values, where each value corresponds to the size of a tile(or segment) on the globe. Each value must be power of two.
+ * @param {Geoid} [options.geoid] -
+ * @param {string} [options.geoidSrc] -
+ */
+declare class EmptyTerrain {
+    static __counter__: number;
+    /**
+     * Uniq identifier.
+     * @public
+     * @type {number}
+     */
+    __id: number;
+    equalizeVertices: boolean;
+    equalizeNormals: boolean;
+    isEmpty: boolean;
+    /**
+     * Provider name is "empty"
+     * @public
+     * @type {string}
+     */
+    name: string;
+    /**
+     * Minimal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    minZoom: number;
+    /**
+     * Maximal z-index value for segment elevation data handling.
+     * @public
+     * @type {number}
+     */
+    maxZoom: number;
+    noDataValues: number[];
+    /**
+     * Maximal existent available zoom
+     * @type {number}
+     */
+    maxNativeZoom: number;
+    /**
+     * @public
+     * @type {Array.<number>}
+     */
+    gridSizeByZoom: number[];
+    _maxNodeZoom: number;
+    /**
+     * Elevation grid size. Current is 2x2 is the smallest grid size.
+     * @public
+     * @type {number}
+     */
+    plainGridSize: number;
+    /**
+     * Planet scene.
+     * @public
+     * @type {Planet}
+     */
+    _planet: Planet | null;
+    _geoid: Geoid;
+    _isReady: boolean;
+    constructor(options?: IEmptyTerrainParams);
+    get isIdle(): boolean;
+    isEqual(obj: this): boolean;
+    static checkNoDataValue(noDataValues: number[] | TypedArray, value: number): boolean;
+    isBlur(segment?: Segment): boolean;
+    set maxNodeZoom(val: number);
+    get maxNodeZoom(): number;
+    set geoid(geoid: Geoid);
+    get geoid(): Geoid;
+    getGeoid(): Geoid;
+    /**
+     * Loads or creates segment elevation data.
+     * @public
+     * @param {Segment} segment - Segment to create elevation data.
+     */
+    handleSegmentTerrain(segment: Segment): void;
+    isReady(): boolean;
+    abortLoading(): void;
+    clearCache(): void;
+    getHeightAsync(lonLat: LonLat, callback: (height: number) => void): boolean;
+    loadTerrain(segment: Segment, forceLoading?: boolean): void;
+}
+export { EmptyTerrain };