@pirireis/webglobeplugins 0.15.35 → 0.16.1

package/programs/picking/pickable-polygon-renderer.js

@@ -0,0 +1,184 @@
+import { createProgram } from "../../util";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems";
+import { mercatorXYToGLPosition, cartesian3DToGLPosition, R_3D, R } from "../../util/shaderfunctions/geometrytransformations";
+import { noRegisterGlobeProgramCache } from "../programcache";
+import { drawArrays, DrawRangeIndexParams } from "../../util/gl-util/draw-options/methods";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
+import { UniformBlockManager } from "../../util/gl-util/uniform-block/manager";
+const uniformBindingPoints = {
+    camera: 0,
+    flexible: 1
+};
+const uniformBlockManager = new UniformBlockManager("FlexibleBlock", [
+    { name: "u_rgba", type: "vec4", value: new Float32Array([1, 1, 1, 1]) },
+    { name: "u_opacity", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_size_multiplier", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_size", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_minimum_size", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_draw_mode", type: "int", value: new Int32Array([0]) }, // 0.0 for point, 1.0 for line
+    { name: "u_is_circle", type: "bool", value: new Float32Array([1.0]) },
+    { name: "u_dash_count", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_dash_opacity_multiplier", type: "float", value: new Float32Array([1.0]) },
+    { name: "u_dash_phase", type: "float", value: new Float32Array([0.0]) },
+], uniformBindingPoints.flexible);
+const vs = `#version 300 es
+${R}
+${R_3D}
+${CameraUniformBlockString}
+${mercatorXYToGLPosition}
+${cartesian3DToGLPosition}
+
+${uniformBlockManager.glslCode()}
+
+precision highp float;
+precision highp int;
+
+in vec3 pos3D;
+in vec2 pos2D;
+in vec4 rgba;
+in float size;
+
+
+flat out highp int vVertexID;
+
+out vec4 v_rgba;
+
+out float v_length;
+
+void main() {
+    
+    v_rgba =  (rgba.r == -1.0) ? u_rgba : rgba;
+    v_rgba.a *= u_opacity;
+    gl_PointSize = max(((size == -1.0) ? u_size : size) * u_size_multiplier, u_minimum_size);
+    
+    float size_fixer; 
+    if(is3D){
+        gl_Position = cartesian3DToGLPosition(pos3D);
+        size_fixer = smoothstep(0.15, 1.0, 0.5 * R_3D / gl_Position.w) ;
+    } else {
+        gl_Position = mercatorXYToGLPosition(pos2D);
+        size_fixer = smoothstep(2.0, 5.2, z_level);
+    }
+    gl_PointSize *= size_fixer;
+    switch (u_draw_mode) {
+        case 0:
+            vVertexID = gl_VertexID;
+            break;
+        case 1:
+            v_length = float(gl_VertexID % 2);
+            vVertexID = (gl_VertexID - gl_VertexID % 2) / 2; // a line takes two points
+            break;
+        default:
+            break;
+    }
+}`;
+const fs = `#version 300 es
+precision highp float;
+precision highp int;
+
+${uniformBlockManager.glslCode()}
+
+flat in highp int vVertexID;
+
+in vec4 v_rgba;
+in float v_length;
+
+layout(location = 0) out vec4 fragColor;
+layout(location = 1) out int vertexID;
+
+void main() {
+    vertexID = vVertexID; 
+    fragColor = v_rgba;
+
+    switch (u_draw_mode) {
+        case 0:
+            float d = distance(gl_PointCoord, vec2(0.5, 0.5));
+            if (u_is_circle) {
+                if (d > 0.5) discard;
+                fragColor.a *= smoothstep(0.5, 0.45, d);
+            }
+            if (u_dash_opacity_multiplier < 1.0) {
+                float dash = sin(d * 3.14159 * 2.0 * u_dash_count + u_dash_phase) * (1.0 - u_dash_opacity_multiplier) + u_dash_opacity_multiplier;
+                fragColor.a *= dash;
+            }
+            break;
+        case 1:
+            if (u_dash_opacity_multiplier < 1.0 && fract((v_length + u_dash_phase) * u_dash_count) < 0.5) {
+                fragColor.a *= u_dash_opacity_multiplier;
+            }
+            break;
+    }
+}`;
+class PointOnGlobeProgram {
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this._isFreed = false;
+        this.program = createProgram(this.gl, vs, fs);
+        const { gl, program } = this;
+        // assign opacity
+        // assign attribute locations
+        gl.bindAttribLocation(program, 0, "pos3D");
+        gl.bindAttribLocation(program, 1, "pos2D");
+        gl.bindAttribLocation(program, 2, "rgba");
+        gl.bindAttribLocation(program, 3, "size");
+        // arrange camera uniform block
+        this.cameraBlockTotem = CameraUniformBlockTotemCache.get(globe);
+        this.cameraBlockTotem.assignBindingPoint(program, uniformBindingPoints.camera);
+        uniformBlockManager.assignBindingPoint(this.gl, this.program);
+        this._defaultUBO = uniformBlockManager.createUBO(this.gl);
+        this._defaultUBO.update(new Map([
+            ["u_rgba", [1, 1, 1, 1]],
+            ["u_opacity", [1.0]],
+            ["u_size_multiplier", [1.0]],
+            ["u_size", [1.0]],
+            ["u_is_circle", [1.0]],
+        ]));
+    }
+    createUBO() {
+        const ubo = uniformBlockManager.createUBO(this.gl);
+        return ubo;
+    }
+    createVAO(pos3DBufferObj, pos2DBufferObj, rgbaBufferObj, sizeBufferObj) {
+        const { gl } = this;
+        const vao = gl.createVertexArray();
+        gl.bindVertexArray(vao);
+        attributeLoader(gl, pos3DBufferObj, 0, 3);
+        attributeLoader(gl, pos2DBufferObj, 1, 2);
+        attributeLoader(gl, rgbaBufferObj, 2, 4, { escapeValues: [-1, -1, -1, -1] });
+        attributeLoader(gl, sizeBufferObj, 3, 1, { escapeValues: [-1] });
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return vao;
+    }
+    /**
+     *
+     * @param {vertexArrayObject} vao
+     * @param {DrawRangeIndexParams} drawOptions
+     */
+    draw(vao, drawOptions, ubo = null) {
+        const { gl, program } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(vao);
+        this.cameraBlockTotem.bind(uniformBindingPoints.camera);
+        ubo = ubo || this._defaultUBO;
+        ubo.bind();
+        drawArrays(gl, gl.POINTS, drawOptions);
+        ubo.unbind();
+        this.cameraBlockTotem.unbind(uniformBindingPoints.camera);
+        gl.bindVertexArray(null);
+    }
+    free() {
+        if (this._isFreed)
+            return;
+        const { gl, globe } = this;
+        CameraUniformBlockTotemCache.release(globe);
+        gl.deleteProgram(this.program);
+        this._isFreed = true;
+    }
+}
+const PickableRendererProgramCache = Object.freeze({
+    get: (globe) => noRegisterGlobeProgramCache.getProgram(globe, PointOnGlobeProgram),
+    release: (globe) => noRegisterGlobeProgramCache.releaseProgram(globe, PointOnGlobeProgram)
+});
+export { PickableRendererProgramCache };

package/programs/polygon-on-globe/texture-dem-triangle-test-plugin.js

@@ -0,0 +1,97 @@
+import { TextureDemTriangles } from "./texture-dem-triangles";
+/**
+ * Loads a plugin with test data for TextureDemTriangles
+ */
+const TEST_ITEM_COUNT = 1000000;
+function createTestLongLatArray() {
+    const arr = new Float32Array(TEST_ITEM_COUNT * 2);
+    for (let i = 0; i < TEST_ITEM_COUNT; i++) {
+        arr[i * 2 + 0] = Math.random() * 360 - 180; // longitude
+        arr[i * 2 + 1] = Math.random() * 180 - 90; // latitude
+    }
+    return arr;
+}
+function createTestPos3dArray(longLatArray) {
+    const arr = new Float32Array(TEST_ITEM_COUNT * 3);
+    for (let i = 0; i < TEST_ITEM_COUNT; i++) {
+        const long = longLatArray[i * 2 + 0] / 180 * Math.PI;
+        const lat = longLatArray[i * 2 + 1] / 180 * Math.PI;
+        // Convert long/lat to 3D position (simplified)
+        arr[i * 3 + 0] = Math.cos(lat) * Math.cos(long);
+        arr[i * 3 + 1] = Math.cos(lat) * Math.sin(long);
+        arr[i * 3 + 2] = Math.sin(lat);
+    }
+    return arr;
+}
+const createTestBBOXES = () => {
+    const bboxes = [];
+    for (let i = 0; i < 6; i++) {
+        const north = Math.random() * 90; // random latitude
+        const west = Math.random() * -180; // random longitude
+        const south = north - 30; // random latitude
+        const east = west + 30; // random longitude
+        const nw = [west, north]; // random northWest
+        const se = [east, south]; // random southEast
+        bboxes.push({ northWest: nw, southEast: se });
+    }
+    return bboxes;
+};
+const createTestDemTextures = () => {
+    const textures = [];
+    for (let i = 0; i < 6; i++) {
+        const texture = [];
+        for (let j = 0; j < 5 * 5; j++) {
+            const value = 1000 * Math.random(); // random elevation value
+            texture.push(value);
+        }
+        textures.push(texture);
+    }
+    return textures;
+};
+export class TextureDemTrianglesTestPlugin {
+    globe = null;
+    textureDemTriangles = null;
+    vao = null;
+    drawOptions = null;
+    bufferInfo = null;
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+    init(globe) {
+        this.globe = globe;
+        this.textureDemTriangles = new TextureDemTriangles(globe);
+        // set bboxes and dem textures
+        const demTextures = createTestDemTextures();
+        const demTextureBBOX = createTestBBOXES();
+        this.textureDemTriangles.setDemTextures(demTextures, demTextureBBOX);
+        // 
+        const bufferInfo = {
+            pos3dBufferInfo: {
+                buffer: globe.gl.createBuffer(),
+                stride: 0,
+                offset: 0,
+            },
+            longLatBufferInfo: {
+                buffer: globe.gl.createBuffer(),
+                stride: 0,
+                offset: 0,
+            },
+            drawOptions: { drawRange: { count: TEST_ITEM_COUNT, first: 0 } }
+        };
+        this.vao = this.textureDemTriangles.createVAO(bufferInfo.pos3dBufferInfo, bufferInfo.longLatBufferInfo);
+        const gl = globe.gl;
+        const longLatArray = createTestLongLatArray();
+        const pos3dArray = createTestPos3dArray(longLatArray);
+        gl.bindBuffer(gl.ARRAY_BUFFER, bufferInfo.pos3dBufferInfo.buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, pos3dArray, gl.STATIC_DRAW);
+        gl.bindBuffer(gl.ARRAY_BUFFER, bufferInfo.longLatBufferInfo.buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, longLatArray, gl.STATIC_DRAW);
+        this.bufferInfo = bufferInfo;
+    }
+    draw3D() {
+        if (!this.globe || !this.textureDemTriangles || !this.vao || !this.bufferInfo)
+            return;
+        this.textureDemTriangles.draw(this.vao, this.bufferInfo.drawOptions);
+    }
+}

package/programs/polygon-on-globe/texture-dem-triangles.js

@@ -0,0 +1,167 @@
+import { createProgram } from "../../util/webglobjectbuilders";
+import { CameraUniformBlockTotemCache, CameraUniformBlockString } from "../totems/camerauniformblock";
+import { cartesian3DToGLPosition } from "../../util/shaderfunctions/geometrytransformations";
+import { drawArrays } from "../../util/gl-util/draw-options/methods";
+import { attributeLoader } from "../../util/gl-util/buffer/attribute-loader";
+import { WORLD_RADIUS_3D } from "../../Math/constants";
+const uniformBindingPoints = {
+    camera: 0,
+};
+const vertexShaderSource = `#version 300 es
+#pragma vscode_glsllint_stage : vert
+
+precision highp float;
+precision highp sampler2DArray;
+
+${CameraUniformBlockString}
+
+${cartesian3DToGLPosition}
+in vec3 a_position;
+in vec2 a_longLat;
+uniform sampler2DArray u_demTexture; // <-- changed from array to single
+uniform vec4 u_demTextureBBOX[6];
+
+
+
+// TODO: light directioni 
+// out vec3 v_position;
+// out vec3 v_normal;
+// out vec2 v_textureCoord;
+
+out vec4 v_color;
+
+bool isPointInBBox(vec2 point, vec4 bbox) {
+    return point.x >= bbox.x && point.x <= bbox.z && point.y >= bbox.y && point.y <= bbox.w;
+}
+
+void main() {
+
+    float elevation = ${WORLD_RADIUS_3D}; // default elevation at sea level
+    v_color = vec4(1.0, 1.0, 1.0, 1.0); // default color white
+    for (int i = 0; i < 6; i++) {
+        if (isPointInBBox(a_longLat, u_demTextureBBOX[i])) {
+            vec2 uv = (a_longLat - u_demTextureBBOX[i].xy) / (u_demTextureBBOX[i].zw - u_demTextureBBOX[i].xy);
+            float altitude = texture(u_demTexture, vec3(uv, float(i))).r;
+            elevation += altitude;
+            v_color = mix(vec4(0.0, 0.0, 1.0, 1.0), vec4(1.0, 0.0, 0.0, 1.0), altitude / 1000.0); // color from blue to red based on altitude
+            // elevation += 1000.0 * float(i); // temporary for testing
+            break;
+     }
+    }
+    
+
+    vec3 position = a_position * elevation;
+    gl_Position = cartesian3DToGLPosition(position);
+    gl_PointSize = 1.0; // for POINTS rendering
+}
+`;
+const fragmentShaderSource = `#version 300 es
+#pragma vscode_glsllint_stage : frag
+
+precision highp float;
+in vec4 v_color;
+out vec4 outColor;
+void main() {
+    outColor = v_color; // use the varying color from the vertex shader
+}
+`;
+export class TextureDemTriangles {
+    globe;
+    gl;
+    program;
+    // Later an injection will handle demTextures and demTextureBBOX
+    texture;
+    // demTextures: WebGLTexture[] = [];
+    // demTextureBBOX: Float32Array = new Float32Array(6 * 4); // 6 bounding boxes
+    cameraUniformBlock;
+    locations = {
+        attributes: {
+            a_position: -1,
+            a_longLat: -1,
+        },
+        uniforms: {
+            u_demTexture: -1,
+            u_demTextureBBOX: -1,
+        }
+    };
+    constructor(globe) {
+        this.globe = globe;
+        this.gl = globe.gl;
+        this.program = createProgram(this.gl, vertexShaderSource, fragmentShaderSource);
+        this.cameraUniformBlock = CameraUniformBlockTotemCache.get(this.globe);
+        this.cameraUniformBlock.assignBindingPoint(this.program, uniformBindingPoints.camera);
+        // get attribute locations
+        this.locations.attributes.a_position = this.gl.getAttribLocation(this.program, 'a_position');
+        this.locations.attributes.a_longLat = this.gl.getAttribLocation(this.program, 'a_longLat');
+        // get uniform locations
+        this.locations.uniforms.u_demTexture = this.gl.getUniformLocation(this.program, 'u_demTexture');
+        this.locations.uniforms.u_demTextureBBOX = this.gl.getUniformLocation(this.program, 'u_demTextureBBOX');
+        // create 3d texture
+        const texture = this.gl.createTexture();
+        this.gl.bindTexture(this.gl.TEXTURE_2D_ARRAY, texture);
+        // this.gl.texImage3D(this.gl.TEXTURE_2D_ARRAY, 0, this.gl.R32F, 25, 25, 6, 0, this.gl.RED, this.gl.FLOAT, null);
+        this.gl.texStorage3D(this.gl.TEXTURE_2D_ARRAY, 1, this.gl.R32F, 5, 5, 6);
+        // set texture parameters
+        const ext = this.gl.getExtension('OES_texture_float_linear');
+        this.gl.texParameteri(this.gl.TEXTURE_2D_ARRAY, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR);
+        this.gl.texParameteri(this.gl.TEXTURE_2D_ARRAY, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR);
+        this.gl.texParameteri(this.gl.TEXTURE_2D_ARRAY, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE);
+        this.gl.texParameteri(this.gl.TEXTURE_2D_ARRAY, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE);
+        this.gl.bindTexture(this.gl.TEXTURE_2D_ARRAY, null);
+        this.texture = texture;
+    }
+    createVAO(pos3dBufferInfo, longLatBufferInfo) {
+        const vao = this.gl.createVertexArray();
+        this.gl.bindVertexArray(vao);
+        attributeLoader(this.gl, pos3dBufferInfo, this.locations.attributes.a_position, 3);
+        attributeLoader(this.gl, longLatBufferInfo, this.locations.attributes.a_longLat, 2);
+        this.gl.bindVertexArray(null);
+        return vao;
+    }
+    setDemTextures(demTexturesData, demTextureBBOX) {
+        // bind textures to texture units
+        const gl = this.gl;
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.texture);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, false);
+        // turn off premultiply alpha
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
+        // bind and upload each texture to the 3D texture array
+        for (let i = 0; i < demTexturesData.length; i++) {
+            const data = demTexturesData[i];
+            if (data.length === 5 * 5) { // <-- FIXED
+                gl.texSubImage3D(gl.TEXTURE_2D_ARRAY, 0, 0, 0, i, 5, 5, 1, gl.RED, gl.FLOAT, new Float32Array(data));
+            }
+        }
+        // set uniform for texture units
+        const bboxVec4Array = new Float32Array(6 * 4);
+        for (let i = 0; i < demTextureBBOX.length; i++) {
+            const bbox = demTextureBBOX[i];
+            bboxVec4Array[i * 4 + 0] = bbox.northWest[0];
+            bboxVec4Array[i * 4 + 1] = bbox.southEast[1];
+            bboxVec4Array[i * 4 + 2] = bbox.southEast[0];
+            bboxVec4Array[i * 4 + 3] = bbox.northWest[1];
+        }
+        const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
+        gl.useProgram(this.program);
+        gl.uniform4fv(this.locations.uniforms.u_demTextureBBOX, bboxVec4Array);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+        gl.useProgram(currentProgram);
+    }
+    draw(vao, drawOptions, ubo = null) {
+        const gl = this.gl;
+        console.log('Drawing TextureDemTriangles drawOptions:', drawOptions);
+        gl.useProgram(this.program);
+        this.cameraUniformBlock.bind(uniformBindingPoints.camera);
+        // TURN OFF flip y for texture
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, this.texture);
+        gl.uniform1i(this.locations.uniforms.u_demTexture, 0); // texture unit 0
+        // bind VAO and draw
+        gl.bindVertexArray(vao);
+        drawArrays(gl, gl.POINTS, drawOptions);
+        gl.bindVertexArray(null);
+        gl.bindTexture(gl.TEXTURE_2D_ARRAY, null);
+        gl.useProgram(null);
+        this.cameraUniformBlock.unbind(uniformBindingPoints.camera);
+    }
+}

package/programs/totems/camerauniformblock.js

@@ -2,6 +2,7 @@ import { globeProgramCache } from "../programcache";
 import { fromLongLatToUnitVector } from "../../Math/vec3";
 import { RADIANS } from "../../Math/methods";
 import { GlobeChangeObserver } from "./globe-changes";
+// import { approximatedZoomLevel } from "../../util/geometry/index";
 export const CameraUniformBlockString = `
 layout(std140) uniform CameraUniformBlock {
     mat4 view; // 64 bytes           0
@@ -30,6 +31,7 @@ export class CameraUniformBlockTotem {
     _isMovedParams;
     _normalizedCameraVector = [0, 0, 0]; // Normalized camera vector
     // _frustumPlanes: any; // Uncomment and type if used
+    _aproximatedLOD = -1;
     _globeChangeObserver = null;
     constructor() {
         this.id = "CameraUniformBlockTotem";
@@ -135,6 +137,7 @@ export class CameraUniformBlockTotem {
             this._isMovedParams.lastLod = currentLOD;
         }
         this.__setCameraVectors();
+        // this._calculateAproximatedLOD();
     }
     __setCameraVectors() {
         if (!this.globe) {
@@ -167,9 +170,6 @@ export class CameraUniformBlockTotem {
     getUBO() {
         return this.ubo;
     }
-    // getFrustumPlanes() {
-    //     return this._frustumPlanes;
-    // }
     bind(bindingPoint) {
         const gl = this.gl;
         const ubo = this.ubo;
@@ -203,6 +203,13 @@ export class CameraUniformBlockTotem {
     getGlobeChanges() {
         return this._globeChangeObserver?.getChanges();
     }
+    // getApproximatedLOD(): number {
+    //     return this._aproximatedLOD;
+    // }
+    // _calculateAproximatedLOD(){
+    //     const globe = this.globe!;
+    //     this._aproximatedLOD = approximatedZoomLevel(globe)
+    // }
     free() {
         const gl = this.gl;
         const ubo = this.ubo;

package/semiplugins/shape-on-terrain/terrain-cover/texture-dem-cover.js

@@ -0,0 +1 @@
+"use strict";

package/util/geometry/index.js

@@ -1,3 +1,4 @@
+import { GLOBE_DEFAULT_MIN_LOD, GLOBE_DEFAULT_MAX_LOD, POLE2 } from "../../constants";
 function latLongToPixelXY(latitude, longitude) {
     return {
         x: (longitude + 180) / 360,
@@ -44,4 +45,77 @@ function normalize(array, newLength = 1) {
 function sphereCoord(long, lat, globe, height = 0) {
     return normalize(globe.api_GetCartesian3DPoint(long, lat, 0, false), 6378.137 + height);
 }
-export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize };
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function _flatZoomLevel(globe) {
+    const { width, height } = globe.api_GetCurrentWorldWH();
+    const curLod = Math.log(POLE2 / Math.min(width, height)) / Math.LN2 + GLOBE_DEFAULT_MIN_LOD;
+    return curLod;
+}
+function _sphereZoomLevel(globe) {
+    // Sorted array of [lod, altitude]
+    const altitudesAsMeterByLod = [
+        [25, 39.97],
+        [24, 39.97],
+        [23, 39.97],
+        [22, 39.97],
+        [21, 84.84],
+        [20, 169.95],
+        [19, 335.87],
+        [18, 672.80],
+        [17, 1352.01],
+        [16, 2688.90],
+        [15, 5386.31],
+        [14, 10611.02],
+        [13, 21526.80],
+        [12, 43121.77],
+        [11, 86927.14],
+        [10, 171201.96],
+        [9, 336039.90],
+        [8, 678769.05],
+        [7, 1379009.96],
+        [6, 2770920.56],
+        [5, 5837640.93],
+        [4, 12408290.88],
+        [3, 25512546.06],
+        [2, 25512546.06],
+        [1, 25512546.06],
+        [0, 25512546.06]
+    ];
+    const { Distance: altitude } = globe.api_GetCurrentLookInfo();
+    const defMinLod = GLOBE_DEFAULT_MIN_LOD;
+    const defMaxLod = GLOBE_DEFAULT_MAX_LOD;
+    // Binary search for correct LOD
+    let left = 0, right = altitudesAsMeterByLod.length - 1;
+    if (altitude > altitudesAsMeterByLod[right][1]) {
+        return clamp(0, defMinLod, defMaxLod);
+    }
+    if (altitude < altitudesAsMeterByLod[0][1]) {
+        return clamp(25, defMinLod, defMaxLod);
+    }
+    while (left < right) {
+        let mid = Math.floor((left + right) / 2);
+        let currAlt = altitudesAsMeterByLod[mid][1];
+        let nextAlt = altitudesAsMeterByLod[mid + 1][1];
+        if (altitude >= currAlt && altitude <= nextAlt) {
+            let lod = altitudesAsMeterByLod[mid][0];
+            if (currAlt === nextAlt) {
+                return clamp(lod, defMinLod, defMaxLod);
+            }
+            return clamp(lod + (-currAlt + altitude) / (-currAlt + nextAlt), defMinLod, defMaxLod);
+        }
+        if (altitude > nextAlt) {
+            left = mid + 1;
+        }
+        else {
+            right = mid;
+        }
+    }
+    return GLOBE_DEFAULT_MIN_LOD;
+}
+function approximatedZoomLevel(globe) {
+    const is3D = globe.api_GetCurrentGeometry() === 0;
+    return is3D ? _sphereZoomLevel(globe) : _flatZoomLevel(globe);
+}
+export { createBBoxMatrix, latLongToPixelXY, latLongBboxtoPixelXYBbox, sphereCoord, normalize, approximatedZoomLevel };