astro-viewer 3.0.0 → 3.2.0

package/lib-esm/model/SphereFoV.js

@@ -0,0 +1,196 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+import { mat4, vec3 } from 'gl-matrix';
+import { radToDeg } from '../utils/Utils.js';
+export class SphereFoV {
+    static MIN_FOV_DEG = 1e-6;
+    fovXDeg = 180;
+    fovYDeg = 180;
+    ratio = 0;
+    _minFoV = 180;
+    _webgl;
+    _lastModel = null;
+    _lastCamera = null;
+    constructor(webgl) {
+        this._webgl = webgl;
+    }
+    getFoV(insideSphere, model, camera, pMatrix) {
+        this._lastModel = model;
+        this._lastCamera = camera;
+        const canvas = this._webgl.canvas;
+        if (!canvas) {
+            this.fovXDeg = 180;
+            this.fovYDeg = 180;
+            this._minFoV = this.minFoV;
+            return this;
+        }
+        const rect = canvas.getBoundingClientRect();
+        const canvasWidth = rect.width;
+        const canvasHeight = rect.height;
+        this.fovXDeg = this.computeAngle(0, canvasHeight / 2, insideSphere, model, camera, pMatrix).angleDeg;
+        this.fovYDeg = this.computeAngle(canvasWidth / 2, 0, insideSphere, model, camera, pMatrix).angleDeg;
+        this._minFoV = this.minFoV;
+        this.ratio = this.computeRatio(camera);
+        return this;
+    }
+    computeRatio(camera) {
+        const pos = camera.getCameraPosition();
+        const distanceFromCenter = Math.sqrt(pos[0] * pos[0] + pos[1] * pos[1] + pos[2] * pos[2]);
+        return distanceFromCenter / this.fovYDeg;
+    }
+    get minFoV() {
+        const minFov = this.fovYDeg <= this.fovXDeg ? this.fovYDeg : this.fovXDeg;
+        this._minFoV = Math.max(minFov, SphereFoV.MIN_FOV_DEG);
+        return this._minFoV;
+    }
+    get xFoV() {
+        return this.fovXDeg;
+    }
+    get yFoV() {
+        return this.fovYDeg;
+    }
+    computeDistanceFromAngle(angleDeg) {
+        return angleDeg * this.ratio;
+    }
+    changeMinFov(deg) {
+        if (this.fovYDeg <= this.fovXDeg) {
+            this.fovYDeg = deg;
+        }
+        else {
+            this.fovXDeg = deg;
+        }
+        this.minFoV;
+    }
+    computeCameraPositionForMinFoV(targetMinFoVDeg) {
+        return this.computeCameraPositionForFoV(targetMinFoVDeg);
+    }
+    computeCameraPositionForFoV(targetFoVDeg) {
+        return this.computeCameraPositionForAngularDiameter(targetFoVDeg);
+    }
+    computeCameraPositionForAngularDiameter(targetAngularDiameterDeg) {
+        if (!this._lastModel || !this._lastCamera) {
+            return [0, 0, 0];
+        }
+        const eps = 1e-6;
+        const clamped = Math.max(eps, Math.min(180 - eps, targetAngularDiameterDeg));
+        const halfRad = (clamped * Math.PI) / 360.0;
+        const sinHalf = Math.sin(halfRad);
+        if (sinHalf <= 0) {
+            return [0, 0, 0];
+        }
+        const model = this._lastModel;
+        const camera = this._lastCamera;
+        const targetDistance = Math.max(model.radius / sinHalf, model.radius + 1e-4);
+        const camPos = camera.getCameraPosition();
+        const direction = vec3.fromValues(camPos[0] - model.center[0], camPos[1] - model.center[1], camPos[2] - model.center[2]);
+        if (vec3.length(direction) < eps) {
+            vec3.set(direction, 0, 0, 1);
+        }
+        else {
+            vec3.normalize(direction, direction);
+        }
+        return [
+            model.center[0] + direction[0] * targetDistance,
+            model.center[1] + direction[1] * targetDistance,
+            model.center[2] + direction[2] * targetDistance,
+        ];
+    }
+    computeAngle(canvasX, canvasY, insideSphere, model, camera, pMatrix) {
+        const canvas = this._webgl.canvas;
+        const rect = canvas.getBoundingClientRect();
+        const centerHit = this.getIntersectionPointWithModel(rect.width / 2, rect.height / 2, model, camera, pMatrix);
+        const edgeHit = this.getIntersectionPointWithModel(canvasX, canvasY, model, camera, pMatrix);
+        if (!centerHit || !edgeHit) {
+            return { angleDeg: 180, distance: -1 };
+        }
+        const angleDeg = 2 * this.computeAngularDistanceDeg(centerHit.point, edgeHit.point);
+        return {
+            angleDeg,
+            distance: edgeHit.distance,
+        };
+    }
+    computeAngularDistanceDeg(a, b) {
+        const aNorm = vec3.normalize(vec3.create(), a);
+        const bNorm = vec3.normalize(vec3.create(), b);
+        const dot = vec3.dot(aNorm, bNorm);
+        const cross = vec3.cross(vec3.create(), aNorm, bNorm);
+        const angleRad = Math.atan2(vec3.length(cross), Math.min(1, Math.max(-1, dot)));
+        return radToDeg(angleRad);
+    }
+    getIntersectionPointWithModel(mouseX, mouseY, model, camera, pMatrix) {
+        const rayWorld = this.getRayFromMouse(mouseX, mouseY, pMatrix, camera.getCameraMatrix());
+        const distance = this.raySphere(camera.getCameraPosition(), rayWorld, model);
+        if (distance < 0) {
+            return null;
+        }
+        const worldHit = vec3.create();
+        vec3.scale(worldHit, rayWorld, distance);
+        vec3.add(worldHit, camera.getCameraPosition(), worldHit);
+        const worldHit4 = [worldHit[0], worldHit[1], worldHit[2], 1.0];
+        const modelHit4 = [0, 0, 0, 0];
+        this.mat4MultiplyVec4(model.getModelMatrixInverse(), worldHit4, modelHit4);
+        return {
+            point: vec3.fromValues(modelHit4[0], modelHit4[1], modelHit4[2]),
+            distance,
+        };
+    }
+    getRayFromMouse(mouseX, mouseY, pMatrix, vMatrix) {
+        const gl = this._webgl;
+        const canvas = gl.canvas;
+        const rect = canvas.getBoundingClientRect();
+        const x = (2.0 * mouseX) / rect.width - 1.0;
+        const y = 1.0 - (2.0 * mouseY) / rect.height;
+        const rayClip = [x, y, -1.0, 1.0];
+        const pInv = mat4.create();
+        mat4.invert(pInv, pMatrix);
+        const rayEye4 = [0, 0, 0, 0];
+        this.mat4MultiplyVec4(pInv, rayClip, rayEye4);
+        const rayEye = [rayEye4[0], rayEye4[1], -1.0, 0.0];
+        const vInv = mat4.create();
+        mat4.invert(vInv, vMatrix);
+        const rayWorld4 = [0, 0, 0, 0];
+        this.mat4MultiplyVec4(vInv, rayEye, rayWorld4);
+        const rayWorld = vec3.fromValues(rayWorld4[0], rayWorld4[1], rayWorld4[2]);
+        vec3.normalize(rayWorld, rayWorld);
+        return rayWorld;
+    }
+    raySphere(rayOrigWorld, rayDirectionWorld, sphere) {
+        let intersectionDistance = -1;
+        const L = vec3.create();
+        vec3.subtract(L, rayOrigWorld, sphere.center);
+        const b = vec3.dot(rayDirectionWorld, L);
+        const c = vec3.dot(L, L) - sphere.radius * sphere.radius;
+        const disc = b * b - c;
+        if (disc > 0.0) {
+            const s = Math.sqrt(disc);
+            const ta = -b + s;
+            const tb = -b - s;
+            if (ta >= 0.0 || tb >= 0.0) {
+                intersectionDistance = tb < 0.0 ? ta : Math.min(ta, tb);
+            }
+        }
+        else if (disc === 0.0) {
+            const t = -b;
+            if (t >= 0.0) {
+                intersectionDistance = t;
+            }
+        }
+        return intersectionDistance;
+    }
+    mat4MultiplyVec4(m, v, out) {
+        out[0] = m[0] * v[0] + m[4] * v[1] + m[8] * v[2] + m[12] * v[3];
+        out[1] = m[1] * v[0] + m[5] * v[1] + m[9] * v[2] + m[13] * v[3];
+        out[2] = m[2] * v[0] + m[6] * v[1] + m[10] * v[2] + m[14] * v[3];
+        out[3] = m[3] * v[0] + m[7] * v[1] + m[11] * v[2] + m[15] * v[3];
+    }
+}

package/lib-esm/model/catalogues/CatalogueGL.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 import { Source } from '../Source.js';
 import { Point } from '../Point.js';
 import { CoordsType } from '../..//utils/CoordsType.js';

package/lib-esm/model/catalogues/CatalogueProps.js

@@ -1,6 +1,18 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+export {};
 // // CatalogueProps.ts
 // type UCD = string | undefined;
-export {};
 // import {Metadata} from "../tap/TapMetadata.js";
 // import {TapMetadataList} from "../tap/TapMetadataList.js";
 // function colName(col?: Metadata): string | undefined {

package/lib-esm/model/earth/{wmts/WMTSAdapter.d.ts → WMTSAdapter.d.ts}

@@ -1,4 +1,5 @@
-import type { WMTSLayerConfig, XYZLayerConfig, XYZTileCoord } from '../types.js';
+import type { WMTSLayerConfig, XYZLayerConfig } from './XYZConfig.js';
+import type { XYZTileCoord } from './XYZTypes.js';
 export declare class WMTSAdapter {
     private _config;
     constructor(config: WMTSLayerConfig);

package/lib-esm/model/earth/{wmts/WMTSAdapter.js → WMTSAdapter.js}

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 function replaceTokens(template, values) {
     return Object.entries(values).reduce((result, [key, value]) => result.replace(new RegExp(`\\{${key}\\}`, 'g'), value), template);
 }

package/lib-esm/model/earth/XYZAnchestorTile.d.ts

@@ -0,0 +1,17 @@
+import { XYZShaderProgram } from '../../shader/XYZShaderProgram.js';
+import { XYZMeshBuilder } from './XYZMeshBuilder.js';
+import { XYZTile } from './XYZTile.js';
+import type { XYZTileCoord } from './XYZTypes.js';
+type Mat4 = Float32Array;
+export declare class XYZAnchestorTile extends XYZTile {
+    private _ancestorMeshBuilder;
+    private _ancestorWebgl;
+    private _segmentsPerSide;
+    private _meshCache;
+    constructor(coord: XYZTileCoord, url: string, webgl: WebGL2RenderingContext, shaderProgram: XYZShaderProgram, meshBuilder?: XYZMeshBuilder, segmentsPerSide?: number);
+    draw(pMatrixOrVisibleZoom: Mat4 | number, vMatrixOrVisibleTiles: Mat4 | XYZTileCoord[], mMatrixOrAncestorsMap: Mat4 | Map<string, XYZTileCoord>, colorMapIdxOrPMatrix: number | Mat4, vMatrix?: Mat4, mMatrix?: Mat4, colorMapIdx?: number): boolean;
+    dispose(): void;
+    private getRemappedMesh;
+    private isAncestorOf;
+}
+export { XYZAnchestorTile as XYZAncestorTile };

package/lib-esm/model/earth/XYZAnchestorTile.js

@@ -0,0 +1,87 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+import { XYZMeshBuilder } from './XYZMeshBuilder.js';
+import { XYZTile } from './XYZTile.js';
+export class XYZAnchestorTile extends XYZTile {
+    _ancestorMeshBuilder;
+    _ancestorWebgl;
+    _segmentsPerSide;
+    _meshCache = new Map();
+    constructor(coord, url, webgl, shaderProgram, meshBuilder = new XYZMeshBuilder(), segmentsPerSide = 16) {
+        super(coord, url, webgl, shaderProgram, meshBuilder, segmentsPerSide);
+        this._ancestorMeshBuilder = meshBuilder;
+        this._ancestorWebgl = webgl;
+        this._segmentsPerSide = segmentsPerSide;
+    }
+    draw(pMatrixOrVisibleZoom, vMatrixOrVisibleTiles, mMatrixOrAncestorsMap, colorMapIdxOrPMatrix, vMatrix, mMatrix, colorMapIdx) {
+        if (typeof pMatrixOrVisibleZoom !== 'number') {
+            return super.draw(pMatrixOrVisibleZoom, vMatrixOrVisibleTiles, mMatrixOrAncestorsMap, colorMapIdxOrPMatrix);
+        }
+        if (!vMatrix || !mMatrix || colorMapIdx === undefined) {
+            return false;
+        }
+        const visibleZoom = pMatrixOrVisibleZoom;
+        const visibleTiles = vMatrixOrVisibleTiles;
+        const ancestorsMap = mMatrixOrAncestorsMap;
+        const pMatrix = colorMapIdxOrPMatrix;
+        let drawn = false;
+        if (visibleZoom <= this.coord.z) {
+            return super.draw(pMatrix, vMatrix, mMatrix, colorMapIdx);
+        }
+        for (const targetTile of visibleTiles) {
+            if (!this.isAncestorOf(targetTile)) {
+                continue;
+            }
+            const ancestorKey = `${this.coord.z}/${this.coord.x}/${this.coord.y}`;
+            if (!ancestorsMap.has(ancestorKey)) {
+                continue;
+            }
+            const mesh = this.getRemappedMesh(targetTile);
+            drawn = super.drawRemapped(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx) || drawn;
+        }
+        return drawn;
+    }
+    dispose() {
+        for (const mesh of this._meshCache.values()) {
+            if (mesh.positionBuffer)
+                this._ancestorWebgl.deleteBuffer(mesh.positionBuffer);
+            if (mesh.uvBuffer)
+                this._ancestorWebgl.deleteBuffer(mesh.uvBuffer);
+            if (mesh.indexBuffer)
+                this._ancestorWebgl.deleteBuffer(mesh.indexBuffer);
+        }
+        this._meshCache.clear();
+        super.dispose();
+    }
+    getRemappedMesh(targetTile) {
+        const key = `${targetTile.z}/${targetTile.x}/${targetTile.y}->${this.coord.z}/${this.coord.x}/${this.coord.y}`;
+        const existing = this._meshCache.get(key);
+        if (existing) {
+            return existing;
+        }
+        const mesh = this._ancestorMeshBuilder.buildAncestorMesh(targetTile, this.coord, this._segmentsPerSide);
+        const uploaded = this._ancestorMeshBuilder.uploadMesh(mesh, this._ancestorWebgl);
+        this._meshCache.set(key, uploaded);
+        return uploaded;
+    }
+    isAncestorOf(targetTile) {
+        if (targetTile.z <= this.coord.z) {
+            return targetTile.z === this.coord.z
+                && targetTile.x === this.coord.x
+                && targetTile.y === this.coord.y;
+        }
+        const dz = targetTile.z - this.coord.z;
+        return (targetTile.x >> dz) === this.coord.x && (targetTile.y >> dz) === this.coord.y;
+    }
+}
+export { XYZAnchestorTile as XYZAncestorTile };

package/lib-esm/model/earth/{types.d.ts → XYZConfig.d.ts}

@@ -1,5 +1,7 @@
+import type { XYZTileCoord } from './XYZTypes.js';
 export type XYZLayerConfig = {
     urlTemplate: string;
+    name?: string;
     minZoom?: number;
     maxZoom?: number;
     segmentsPerSide?: number;
@@ -27,6 +29,10 @@ export type XYZLayerDebugStats = {
     coarseTileCount: number;
     hasPendingSelection: boolean;
     pendingSelectionKey: string | null;
+    hipsName?: string;
+    hipsUrl?: string;
+    isGalactic?: boolean;
+    currentOrder?: number | null;
 };
 export type XYZRequestBackoffDebugEntry = {
     host: string;
@@ -46,23 +52,6 @@ export type XYZDebugStats = {
     layer: XYZLayerDebugStats | null;
     requests: XYZRequestSchedulerDebugStats;
 };
-export type XYZTileCoord = {
-    z: number;
-    x: number;
-    y: number;
-};
-export type XYZTileMesh = {
-    positions: Float32Array;
-    uvs: Float32Array;
-    indices: Uint16Array | Uint32Array;
-};
-export type XYZTileGpuMesh = {
-    positionBuffer: WebGLBuffer | null;
-    uvBuffer: WebGLBuffer | null;
-    indexBuffer: WebGLBuffer | null;
-    indexCount: number;
-    indexType: number;
-};
 export type WMTSRequestEncoding = 'kvp' | 'rest';
 export type WMTSLayerConfig = {
     baseUrl: string;

package/lib-esm/model/earth/XYZConfig.js

@@ -0,0 +1,13 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+export {};

package/lib-esm/model/earth/XYZFoVHelper.d.ts

@@ -0,0 +1,12 @@
+declare class XYZFoVHelper {
+    private static readonly LEVEL_HYSTERESIS;
+    private static readonly ZOOM_MIN_FOV;
+    getZoom(fov: number, currentZoom?: number): number;
+    private getRawZoom;
+    getLonLatSteps(fov: number, coarse?: boolean): {
+        lonStep: number;
+        latStep: number;
+    };
+}
+export declare const xyzFovHelper: XYZFoVHelper;
+export default XYZFoVHelper;

package/lib-esm/model/earth/XYZFoVHelper.js

@@ -0,0 +1,138 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+// FoVHelper.ts
+'use strict';
+class XYZFoVHelper {
+    static LEVEL_HYSTERESIS = 0.12;
+    static ZOOM_MIN_FOV = {
+        2: 179,
+        3: 90,
+        4: 30,
+        5: 20,
+        6: 6,
+        7: 3.2,
+        8: 1.6,
+        9: 0.85,
+        10: 0.42,
+        11: 0.21,
+        12: 0.12,
+        13: 0.06,
+        14: 0.015,
+        15: 0,
+    };
+    getZoom(fov, currentZoom) {
+        const rawZoom = this.getRawZoom(fov);
+        if (currentZoom === undefined || currentZoom === rawZoom)
+            return rawZoom;
+        if (rawZoom > currentZoom) {
+            const boundary = XYZFoVHelper.ZOOM_MIN_FOV[currentZoom];
+            if (boundary > 0 && fov > boundary * (1 - XYZFoVHelper.LEVEL_HYSTERESIS))
+                return currentZoom;
+        }
+        else {
+            const boundary = XYZFoVHelper.ZOOM_MIN_FOV[rawZoom];
+            if (boundary > 0 && fov < boundary * (1 + XYZFoVHelper.LEVEL_HYSTERESIS))
+                return currentZoom;
+        }
+        return rawZoom;
+    }
+    getRawZoom(fov) {
+        if (fov >= 179)
+            return 2;
+        if (fov >= 90)
+            return 3;
+        if (fov >= 30)
+            return 4;
+        if (fov >= 20)
+            return 5;
+        if (fov >= 6)
+            return 6;
+        if (fov >= 3.2)
+            return 7;
+        if (fov >= 1.6)
+            return 8;
+        if (fov >= 0.85)
+            return 9;
+        if (fov >= 0.42)
+            return 10;
+        if (fov >= 0.21)
+            return 11;
+        if (fov >= 0.12)
+            return 12;
+        if (fov >= 0.06)
+            return 13;
+        if (fov >= 0.015)
+            return 14;
+        return 15;
+    }
+    // used in grid drawing
+    getLonLatSteps(fov, coarse = false) {
+        let lonStep;
+        let latStep;
+        if (coarse && fov < 0.21) {
+            lonStep = 10;
+            latStep = 10;
+        }
+        else if (fov >= 179) {
+            lonStep = 10;
+            latStep = 10;
+        }
+        else if (fov >= 25) {
+            lonStep = 9;
+            latStep = 9;
+        }
+        else if (fov >= 12.5) {
+            lonStep = 8;
+            latStep = 8;
+        }
+        else if (fov >= 6) {
+            lonStep = 6;
+            latStep = 6;
+        }
+        else if (fov >= 3.2) {
+            lonStep = 5;
+            latStep = 5;
+        }
+        else if (fov >= 1.6) {
+            lonStep = 4;
+            latStep = 4;
+        }
+        else if (fov >= 0.85) {
+            lonStep = 3;
+            latStep = 3;
+        }
+        else if (fov >= 0.42) {
+            lonStep = 2;
+            latStep = 2;
+        }
+        else if (fov >= 0.21) {
+            lonStep = 1;
+            latStep = 1;
+        }
+        else if (fov >= 0.12) {
+            lonStep = 0.5;
+            latStep = 0.5;
+        }
+        else if (fov >= 0.06) {
+            lonStep = 0.25;
+            latStep = 0.25;
+        }
+        else {
+            lonStep = 10;
+            latStep = 10;
+        }
+        return { lonStep, latStep };
+    }
+}
+export const xyzFovHelper = new XYZFoVHelper();
+export default XYZFoVHelper;

package/lib-esm/model/earth/XYZMap.d.ts

@@ -0,0 +1,31 @@
+import { AbstractSkyEntity, SkyEntityDrawInput } from "../AbstractSkyEntity.js";
+import { XYZMapDescriptor } from "./XYZMapDescriptor.js";
+import { ColorMap } from "../ColorMaps.js";
+import { SphereFoV } from "../SphereFoV.js";
+import type { XYZLayerDebugStats } from "./XYZConfig.js";
+export declare class XYZMap extends AbstractSkyEntity {
+    private _xyzShaderProgram;
+    private _descriptor;
+    private _visibleTilesManager;
+    private _tileBuffer;
+    private _meshBuilder;
+    private _baseurl;
+    private _zoom;
+    private _latLonGrid;
+    private _colorMapIdx;
+    private _colorMap;
+    constructor(radius: number, position: [number, number, number], xrad: number, yrad: number, descriptor: XYZMapDescriptor, webgl: WebGL2RenderingContext);
+    changeColorMap(colorMap: ColorMap): void;
+    private initShaders;
+    isLonLatGridVisible(): boolean;
+    toggleLonLatGrid(): boolean;
+    getFoV(): SphereFoV;
+    private refresh;
+    draw(input: SkyEntityDrawInput): void;
+    private createTile;
+    private getTilesToEnsure;
+    private findBestAvailableAncestor;
+    private resolveTileUrl;
+    getDebugStats(): XYZLayerDebugStats;
+    private tileKey;
+}