astro-viewer 3.0.0 → 3.2.0

package/lib-esm/model/FoV.d.ts

@@ -1,62 +0,0 @@
-/**
- * FoV singleton (TypeScript)
- * - Uses computePerspectiveMatrixSingleton.pMatrix
- * - Guards acos domain (numeric safety)
- * - Uses vec3.transformMat4 instead of custom mat4*vec3
- * - Keeps original “insideSphere ? 360 - angle : angle” behavior
- */
-import { ReadonlyMat4 } from 'gl-matrix';
-import { HealpixGrid } from './grid/HealpixGrid.js';
-import Camera from '../Camera.js';
-export declare class FoV {
-    private static readonly MIN_FOV_DEG;
-    private fovXDeg;
-    private fovYDeg;
-    private ratio;
-    private _minFoV;
-    private _webgl;
-    constructor(webgl: WebGL2RenderingContext);
-    /** Recomputes FoV for current camera + projection */
-    getFoV(insideSphere: boolean, healpixGridSingleton: HealpixGrid, camera: Camera, pMatrix: ReadonlyMat4): FoV;
-    private computeRatio;
-    changeMinFov(deg: number): void;
-    get minFoV(): number;
-    get xFoV(): number;
-    get yFoV(): number;
-    computeDistanceFromAngle(angleDeg: number): number;
-    /** FoV half-screen chord angle doubled (deg) along a given canvas axis */
-    private computeAngle;
-    /**
-   * Computes the camera position (x,y,z) along the current view direction that would
-   * yield the requested minFoV (in degrees), assuming the camera is OUTSIDE the sphere.
-   * This method does NOT mutate the camera; it only returns the suggested position.
-   *
-   * Geometry: for a sphere of radius R observed from distance d (from center),
-   * the apparent angular diameter is 2*arcsin(R/d). Our minFoV is that angular diameter
-   * along the tighter axis; we solve for d and place the camera on the current
-   * center→camera direction with that distance.
-   *
-   * @param targetMinFoVDeg Desired min FoV in degrees, 0 < targetMinFoVDeg < 180
-   * @returns Tuple [x, y, z] for the recommended camera position in world coordinates.
-   */
-    computeCameraPositionForMinFoV(targetMinFoVDeg: number): [number, number, number];
-    /**
-       * Computes the camera world-space position required to achieve a target FoV (deg),
-       * keeping the same viewing direction. Acts as the inverse of computeAngle().
-       *
-       * @param targetFoVDeg desired full FoV angle in degrees (0 < FoV < 180)
-       * @param canvasWidth  canvas width in pixels
-       * @param canvasHeight canvas height in pixels
-       * @returns [x, y, z] coordinates for the new camera position
-       */
-    computeCameraPositionForFoV(targetFoVDeg: number): [number, number, number];
-    /**
-   * Return a camera position such that the sphere's apparent angular diameter
-   * (the silhouette, not the surface coverage) equals targetAngularDiameterDeg.
-   * Keeps current view direction; does not mutate the camera.
-   *
-   * @param targetAngularDiameterDeg desired apparent diameter in degrees (0<α<180)
-   * @returns [x,y,z] world position
-   */
-    computeCameraPositionForAngularDiameter(targetAngularDiameterDeg: number): [number, number, number];
-}

package/lib-esm/model/FoV.js

@@ -1,274 +0,0 @@
-'use strict';
-/**
- * FoV singleton (TypeScript)
- * - Uses computePerspectiveMatrixSingleton.pMatrix
- * - Guards acos domain (numeric safety)
- * - Uses vec3.transformMat4 instead of custom mat4*vec3
- * - Keeps original “insideSphere ? 360 - angle : angle” behavior
- */
-import { vec3, mat4 } from 'gl-matrix';
-import RayPickingUtils from '../utils/RayPickingUtils.js';
-import { radToDeg } from '../utils/Utils.js';
-export class FoV {
-    static MIN_FOV_DEG = 1e-6;
-    fovXDeg = 180;
-    fovYDeg = 180;
-    ratio = +0;
-    _minFoV = 180;
-    _webgl;
-    constructor(webgl) {
-        this._webgl = webgl;
-    }
-    /** Recomputes FoV for current camera + projection */
-    getFoV(insideSphere, healpixGridSingleton, camera, pMatrix) {
-        // const gl = webgl
-        const gl = this._webgl;
-        if (!gl || !gl.canvas) {
-            // Handle the error or assign default values
-            this.fovXDeg = 180;
-            this.fovYDeg = 180;
-            this._minFoV = this.minFoV;
-            return this;
-        }
-        // horizontal FoV: ray through (centerY)
-        // const xFoVComputed = this.computeAngle(0, gl.canvas.height / 2, insideSphere, healpixGridSingleton, camera)
-        const canvas = gl.canvas;
-        const rect = canvas.getBoundingClientRect();
-        const canvasWidth = rect.width;
-        const canvasHeight = rect.height;
-        // const xFoVComputed = this.computeAngle(0, gl.canvas.height / 2, insideSphere, healpixGridSingleton, camera, pMatrix)
-        const xFoVComputed = this.computeAngle(0, canvasHeight / 2, insideSphere, healpixGridSingleton, camera, pMatrix);
-        this.fovXDeg = xFoVComputed.angleDeg;
-        // vertical FoV: ray through (centerX)
-        // const yFoVComputed = this.computeAngle(gl.canvas.width / 2, 0, insideSphere, healpixGridSingleton, camera, pMatrix)
-        const yFoVComputed = this.computeAngle(canvasWidth / 2, 0, insideSphere, healpixGridSingleton, camera, pMatrix);
-        this.fovYDeg = yFoVComputed.angleDeg;
-        this._minFoV = this.minFoV;
-        this.ratio = this.computeRatio(camera);
-        return this;
-    }
-    computeRatio(camera) {
-        // const camera = global.camera
-        if (!camera)
-            throw Error("Camera not defined");
-        const pos = camera.getCameraPosition();
-        const distanceFromCenter = Math.sqrt(pos[0] * pos[0] + pos[1] * pos[1] + pos[2] * pos[2]);
-        // const distanceFromSphere = distanceFromCenter - healpixGridSingleton.RADIUS
-        const ratio = distanceFromCenter / this.fovYDeg;
-        return ratio;
-    }
-    changeMinFov(deg) {
-        console.log("inside changeMinFov");
-        if (this.fovYDeg <= this.fovXDeg) {
-            this.fovYDeg = deg;
-        }
-        else {
-            this.fovXDeg = deg;
-        }
-        console.log("changeMinFov: ping");
-        this.minFoV;
-        // this.fovYDeg <= this.fovXDeg ? this.fovYDeg = deg : this.fovXDeg = deg
-    }
-    get minFoV() {
-        const minFov = this.fovYDeg <= this.fovXDeg ? this.fovYDeg : this.fovXDeg;
-        this._minFoV = Math.max(minFov, FoV.MIN_FOV_DEG);
-        return this._minFoV;
-    }
-    get xFoV() {
-        return this.fovXDeg;
-    }
-    get yFoV() {
-        return this.fovYDeg;
-    }
-    computeDistanceFromAngle(angleDeg) {
-        const desiredFoV = angleDeg;
-        const distance = desiredFoV * this.ratio;
-        // return Math.abs(distance)
-        return distance;
-    }
-    /** FoV half-screen chord angle doubled (deg) along a given canvas axis */
-    computeAngle(canvasX, canvasY, insideSphere, healpixGridSingleton, camera, pMatrix) {
-        // const pMatrix = computePerspectiveMatrixSingleton.pMatrix
-        if (!pMatrix) {
-            // Handle the error or assign a default value
-            console.warn('FoV: projection matrix is null');
-            return { angleDeg: 180, distance: 1 };
-        }
-        const vMatrix = camera.getCameraMatrix();
-        if (!camera) {
-            // Handle the error or assign a default value
-            console.warn('FoV: camera is null');
-            return { angleDeg: 180, distance: 1 };
-        }
-        const rayWorld = RayPickingUtils.getRayFromMouse(canvasX, canvasY, pMatrix, this._webgl, vMatrix);
-        const intersectionDistance = RayPickingUtils.raySphere(camera.getCameraPosition(), rayWorld, healpixGridSingleton);
-        let angleDeg;
-        if (intersectionDistance > 0) {
-            // world-space intersection point on the sphere
-            const hit = vec3.create();
-            vec3.scale(hit, rayWorld, intersectionDistance);
-            vec3.add(hit, camera.getCameraPosition(), hit);
-            const center = healpixGridSingleton.center;
-            // vectors from sphere center
-            const vHit = vec3.create();
-            vec3.subtract(vHit, hit, center);
-            // reference vector: rotate world +Z into current camera orientation, then from center
-            const refWorldZ = vec3.fromValues(center[0], center[1], center[2] + healpixGridSingleton.radius);
-            const vInv = mat4.create();
-            mat4.invert(vInv, camera.getCameraMatrix());
-            const refCamZ = vec3.create();
-            vec3.transformMat4(refCamZ, refWorldZ, vInv);
-            const vRef = vec3.create();
-            vec3.subtract(vRef, refCamZ, center);
-            // angle between vHit and vRef, doubled
-            const dot = vec3.dot(vHit, vRef);
-            const n1 = vec3.length(vHit);
-            const n2 = vec3.length(vRef);
-            // numeric safety for acos
-            const c = Math.min(1, Math.max(-1, dot / (n1 * n2)));
-            const angleRad = Math.acos(c);
-            angleDeg = 2 * radToDeg(angleRad);
-        }
-        else {
-            angleDeg = 180;
-        }
-        const finalAngle = insideSphere ? 360 - angleDeg : angleDeg;
-        // return insideSphere ? 360 - angleDeg : angleDeg
-        return { angleDeg: finalAngle, distance: intersectionDistance };
-    }
-    /**
-   * Computes the camera position (x,y,z) along the current view direction that would
-   * yield the requested minFoV (in degrees), assuming the camera is OUTSIDE the sphere.
-   * This method does NOT mutate the camera; it only returns the suggested position.
-   *
-   * Geometry: for a sphere of radius R observed from distance d (from center),
-   * the apparent angular diameter is 2*arcsin(R/d). Our minFoV is that angular diameter
-   * along the tighter axis; we solve for d and place the camera on the current
-   * center→camera direction with that distance.
-   *
-   * @param targetMinFoVDeg Desired min FoV in degrees, 0 < targetMinFoVDeg < 180
-   * @returns Tuple [x, y, z] for the recommended camera position in world coordinates.
-   */
-    computeCameraPositionForMinFoV(targetMinFoVDeg) {
-        // const camera = global.camera
-        // const center = healpixGridSingleton.center
-        // const R = healpixGridSingleton.radius
-        // if (!camera) {
-        //   console.warn('FoV.computeCameraPositionForMinFoV: camera not available; returning a sensible default.')
-        //   return [center[0], center[1], center[2] + 2 * R]
-        // }
-        // // Clamp and validate input
-        // const eps = 1e-6
-        // const clamped = Math.max(eps, Math.min(180 - eps, targetMinFoVDeg))
-        // const halfRad = (clamped * Math.PI / 180) * 0.5
-        // // Distance from center needed to achieve the angular diameter
-        // // minFoV = 2 * arcsin(R / d)  =>  d = R / sin(minFoV/2)
-        // const sinHalf = Math.sin(halfRad)
-        // if (sinHalf <= 0) {
-        //   console.warn('FoV.computeCameraPositionForMinFoV: invalid targetMinFoVDeg, using fallback.')
-        //   return [center[0], center[1], center[2] + 2 * R]
-        // }
-        // let d = R / sinHalf
-        // // Ensure we remain strictly outside the sphere
-        // d = Math.max(d, R + 1e-4)
-        // // Use the current center→camera direction to keep orientation
-        // const camPos = camera.getCameraPosition()
-        // let dirX = camPos[0] - center[0]
-        // let dirY = camPos[1] - center[1]
-        // let dirZ = camPos[2] - center[2]
-        // const len = Math.hypot(dirX, dirY, dirZ)
-        // if (len < eps) {
-        //   // If somehow at the center, use +Z as a default direction
-        //   dirX = 0; dirY = 0; dirZ = 1;
-        // } else {
-        //   dirX /= len
-        //   dirY /= len
-        //   dirZ /= len
-        // }
-        // const newX = center[0] + dirX * d
-        // const newY = center[1] + dirY * d
-        // const newZ = center[2] + dirZ * d
-        // return [newX, newY, newZ]
-        return [0, 0, 0];
-    }
-    /**
-       * Computes the camera world-space position required to achieve a target FoV (deg),
-       * keeping the same viewing direction. Acts as the inverse of computeAngle().
-       *
-       * @param targetFoVDeg desired full FoV angle in degrees (0 < FoV < 180)
-       * @param canvasWidth  canvas width in pixels
-       * @param canvasHeight canvas height in pixels
-       * @returns [x, y, z] coordinates for the new camera position
-       */
-    computeCameraPositionForFoV(targetFoVDeg) {
-        // const camera = global.camera;
-        // const center = healpixGridSingleton.center;
-        // const R = healpixGridSingleton.radius;
-        // if (!camera) {
-        //   console.warn("FoV.computeCameraPositionForFoV: camera missing.");
-        //   return [center[0], center[1], center[2] + 2 * R];
-        // }
-        // const eps = 1e-6;
-        // const clamped = Math.max(eps, Math.min(180 - eps, targetFoVDeg));
-        // const halfRad = (clamped * Math.PI) / 360.0; // half-angle in radians
-        // // Distance from center that yields this FoV
-        // const sinHalf = Math.sin(halfRad);
-        // if (sinHalf <= 0) {
-        //   console.warn("FoV.computeCameraPositionForFoV: invalid FoV.");
-        //   return [center[0], center[1], center[2] + 2 * R];
-        // }
-        // let d = R / sinHalf;
-        // // Slightly outside sphere to avoid clipping
-        // d = Math.max(d, R + 1e-4);
-        // // Get current viewing direction
-        // const camPos = camera.getCameraPosition();
-        // let dirX = camPos[0] - center[0];
-        // let dirY = camPos[1] - center[1];
-        // let dirZ = camPos[2] - center[2];
-        // const len = Math.hypot(dirX, dirY, dirZ);
-        // if (len < eps) {
-        //   dirX = 0; dirY = 0; dirZ = 1;
-        // } else {
-        //   dirX /= len;
-        //   dirY /= len;
-        //   dirZ /= len;
-        // }
-        // const newX = center[0] + dirX * d;
-        // const newY = center[1] + dirY * d;
-        // const newZ = center[2] + dirZ * d;
-        // return [newX, newY, newZ];
-        return [0, 0, 0];
-    }
-    /**
-   * Return a camera position such that the sphere's apparent angular diameter
-   * (the silhouette, not the surface coverage) equals targetAngularDiameterDeg.
-   * Keeps current view direction; does not mutate the camera.
-   *
-   * @param targetAngularDiameterDeg desired apparent diameter in degrees (0<α<180)
-   * @returns [x,y,z] world position
-   */
-    computeCameraPositionForAngularDiameter(targetAngularDiameterDeg) {
-        // const camera = global.camera;
-        // const center = healpixGridSingleton.center;
-        // const R = healpixGridSingleton.radius;
-        // if (!camera) {
-        //   console.warn('computeCameraPositionForAngularDiameter: camera missing.');
-        //   return [center[0], center[1], center[2] + 2 * R];
-        // }
-        // const eps = 1e-6;
-        // const α = Math.max(eps, Math.min(180 - eps, targetAngularDiameterDeg));
-        // const half = (α * Math.PI) / 360.0;
-        // const sinHalf = Math.sin(half);
-        // // d = R / sin(α/2)
-        // let d = R / sinHalf;
-        // d = Math.max(d, R + 1e-4); // stay outside
-        // // project along current center→camera direction
-        // const [cx, cy, cz] = center as [number, number, number];
-        // const [px, py, pz] = camera.getCameraPosition();
-        // let dx = px - cx, dy = py - cy, dz = pz - cz;
-        // const L = Math.hypot(dx, dy, dz);
-        // if (L < eps) { dx = 0; dy = 0; dz = 1; } else { dx /= L; dy /= L; dz /= L; }
-        // return [cx + dx * d, cy + dy * d, cz + dz * d];
-        return [0, 0, 0];
-    }
-}

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

@@ -1,10 +0,0 @@
-import type { XYZTileCoord, XYZTileGpuMesh } from './types.js';
-import { XYZMeshBuilder } from './XYZMeshBuilder.js';
-export declare class XYZAncestorMeshCache {
-    private _webgl;
-    private _meshBuilder;
-    private _meshes;
-    constructor(webgl: WebGL2RenderingContext, meshBuilder: XYZMeshBuilder);
-    getMesh(targetTile: XYZTileCoord, ancestorTile: XYZTileCoord, segmentsPerSide: number): XYZTileGpuMesh;
-    dispose(): void;
-}

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

@@ -1,31 +0,0 @@
-export class XYZAncestorMeshCache {
-    _webgl;
-    _meshBuilder;
-    _meshes = new Map();
-    constructor(webgl, meshBuilder) {
-        this._webgl = webgl;
-        this._meshBuilder = meshBuilder;
-    }
-    getMesh(targetTile, ancestorTile, segmentsPerSide) {
-        const key = `${targetTile.z}/${targetTile.x}/${targetTile.y}->${ancestorTile.z}/${ancestorTile.x}/${ancestorTile.y}@${segmentsPerSide}`;
-        const existing = this._meshes.get(key);
-        if (existing) {
-            return existing;
-        }
-        const mesh = this._meshBuilder.buildAncestorMesh(targetTile, ancestorTile, segmentsPerSide);
-        const uploaded = this._meshBuilder.uploadMesh(mesh, this._webgl);
-        this._meshes.set(key, uploaded);
-        return uploaded;
-    }
-    dispose() {
-        for (const mesh of this._meshes.values()) {
-            if (mesh.positionBuffer)
-                this._webgl.deleteBuffer(mesh.positionBuffer);
-            if (mesh.uvBuffer)
-                this._webgl.deleteBuffer(mesh.uvBuffer);
-            if (mesh.indexBuffer)
-                this._webgl.deleteBuffer(mesh.indexBuffer);
-        }
-        this._meshes.clear();
-    }
-}

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

@@ -1,31 +0,0 @@
-import { AbstractSkyEntity, SkyEntityDrawInput } from '../AbstractSkyEntity.js';
-import type { XYZLayerConfig, XYZLayerDebugStats } from './types.js';
-export declare class XYZLayer extends AbstractSkyEntity {
-    private static readonly DEFAULT_MAX_CACHED_TILES;
-    private _config;
-    private _provider;
-    private _visibleTilesManager;
-    private _meshBuilder;
-    private _xyzShaderProgram;
-    private _tileBuffer;
-    private _ancestorMeshCache;
-    private _visibleTileKeys;
-    private _fallbackVisibleTileKeys;
-    private _baseVisibleTileKeys;
-    private _tilePriorities;
-    private _tileSelectionKey;
-    private _currentTileCount;
-    private _fallbackTileCount;
-    private _coreTileCount;
-    private _coverageTileCount;
-    constructor(config: XYZLayerConfig, webgl: WebGL2RenderingContext);
-    get config(): XYZLayerConfig;
-    getDebugStats(): XYZLayerDebugStats;
-    private bootstrapTiles;
-    draw(input: SkyEntityDrawInput): void;
-    private evictCache;
-    private disposeTiles;
-    private getTileKey;
-    private parseTileKey;
-    private findBestAvailableAncestor;
-}

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

@@ -1,231 +0,0 @@
-import { AbstractSkyEntity } from '../AbstractSkyEntity.js';
-import { XYZShaderProgram } from '../../shader/XYZShaderProgram.js';
-import { XYZAncestorMeshCache } from './XYZAncestorMeshCache.js';
-import { XYZMeshBuilder } from './XYZMeshBuilder.js';
-import { XYZTileBuffer } from './XYZTileBuffer.js';
-import { XYZTileProvider } from './XYZTileProvider.js';
-import { XYZVisibleTilesManager } from './XYZVisibleTilesManager.js';
-export class XYZLayer extends AbstractSkyEntity {
-    static DEFAULT_MAX_CACHED_TILES = 384;
-    _config;
-    _provider;
-    _visibleTilesManager;
-    _meshBuilder;
-    _xyzShaderProgram;
-    _tileBuffer;
-    _ancestorMeshCache;
-    _visibleTileKeys = [];
-    _fallbackVisibleTileKeys = [];
-    _baseVisibleTileKeys = [];
-    _tilePriorities = new Map();
-    _tileSelectionKey = null;
-    _currentTileCount = 0;
-    _fallbackTileCount = 0;
-    _coreTileCount = 0;
-    _coverageTileCount = 0;
-    constructor(config, webgl) {
-        super(1, [0, 0, 0], 0, 0, 'XYZ Earth Layer', webgl, false);
-        this._config = config;
-        this._provider = new XYZTileProvider(config);
-        this._visibleTilesManager = new XYZVisibleTilesManager(this._provider);
-        this._meshBuilder = new XYZMeshBuilder();
-        this._xyzShaderProgram = new XYZShaderProgram(webgl);
-        this._tileBuffer = new XYZTileBuffer(1, webgl, this._meshBuilder, this._xyzShaderProgram);
-        this._ancestorMeshCache = new XYZAncestorMeshCache(webgl, this._meshBuilder);
-        this.initGL(webgl);
-        this.bootstrapTiles(180, null, null);
-    }
-    get config() {
-        return this._config;
-    }
-    getDebugStats() {
-        let readyTileCount = 0;
-        let loadingTileCount = 0;
-        let coolingDownTileCount = 0;
-        const now = Date.now();
-        const allTiles = [
-            ...Array.from(this._tileBuffer.activeTiles.values(), (entry) => entry.tile),
-            ...Array.from(this._tileBuffer.cachedTiles.values(), (entry) => entry.tile),
-        ];
-        for (const tile of allTiles) {
-            if (tile.ready) {
-                readyTileCount += 1;
-            }
-            if (tile.loading) {
-                loadingTileCount += 1;
-            }
-            if (tile.failedUntil > now) {
-                coolingDownTileCount += 1;
-            }
-        }
-        const currentZoom = this._visibleTileKeys.reduce((maxZoom, tileKey) => {
-            const zoom = Number.parseInt(tileKey.split('/')[0] ?? '', 10);
-            if (!Number.isFinite(zoom)) {
-                return maxZoom;
-            }
-            return maxZoom == null ? zoom : Math.max(maxZoom, zoom);
-        }, null);
-        return {
-            cacheSize: this._tileBuffer.size,
-            visibleTileCount: this._visibleTileKeys.length,
-            currentTileCount: this._currentTileCount,
-            fallbackTileCount: this._fallbackTileCount,
-            coreTileCount: this._coreTileCount,
-            coverageTileCount: this._coverageTileCount,
-            readyTileCount,
-            loadingTileCount,
-            coolingDownTileCount,
-            currentZoom,
-            tileSelectionKey: this._tileSelectionKey,
-            isSettling: false,
-            coarseTileCount: 0,
-            hasPendingSelection: false,
-            pendingSelectionKey: null,
-        };
-    }
-    bootstrapTiles(fovDeg, camera, centerSphericalDeg, fovPolygon = null, viewportSphericalSamples = null) {
-        const selection = camera
-            ? this._visibleTilesManager.selectTiles({
-                fovDeg,
-                camera,
-                pMatrix: new Float32Array(),
-                centerSphericalDeg: centerSphericalDeg ?? undefined,
-                fovPolygon: fovPolygon ?? undefined,
-                viewportSphericalSamples: viewportSphericalSamples ?? undefined,
-            })
-            : {
-                key: 'initial',
-                currentTiles: this._provider.getInitialTiles(),
-                fallbackTiles: [],
-                currentZoom: 1,
-                coreTileCount: this._provider.getInitialTiles().length,
-                coverageTileCount: 0,
-            };
-        if (selection.key === this._tileSelectionKey) {
-            return;
-        }
-        this._tileSelectionKey = selection.key;
-        this._currentTileCount = selection.currentTiles.length;
-        this._fallbackTileCount = selection.fallbackTiles.length;
-        this._coreTileCount = selection.coreTileCount;
-        this._coverageTileCount = selection.coverageTileCount;
-        const segments = this._config.segmentsPerSide ?? 16;
-        const baseTiles = this._provider.getInitialTiles();
-        const coreTileKeys = new Set(selection.currentTiles
-            .slice(0, selection.coreTileCount)
-            .map((tileCoord) => this.getTileKey(tileCoord)));
-        const baseTileKeys = new Set(baseTiles.map((tileCoord) => this.getTileKey(tileCoord)));
-        const prioritizedBaseTiles = baseTiles.map((tileCoord, index) => ({
-            tileCoord,
-            priority: 5000 + (baseTiles.length - index),
-            role: 'base',
-        }));
-        const prioritizedCurrentTiles = selection.currentTiles.map((tileCoord, index) => ({
-            tileCoord,
-            priority: 10000 + (selection.currentTiles.length - index),
-            role: coreTileKeys.has(this.getTileKey(tileCoord)) ? 'current' : 'coverage',
-        }));
-        const prioritizedFallbackTiles = selection.fallbackTiles.map((tileCoord, index) => ({
-            tileCoord,
-            priority: 1000 + (selection.fallbackTiles.length - index),
-            role: 'fallback',
-        }));
-        const requestedTiles = [...prioritizedBaseTiles, ...prioritizedCurrentTiles, ...prioritizedFallbackTiles];
-        this._tilePriorities.clear();
-        this._fallbackVisibleTileKeys = [];
-        this._baseVisibleTileKeys = [];
-        const orderedRequests = requestedTiles
-            .sort((a, b) => a.tileCoord.z - b.tileCoord.z)
-            .map(({ tileCoord, priority, role }) => {
-            const tileKey = this.getTileKey(tileCoord);
-            this._tilePriorities.set(tileKey, priority);
-            return {
-                tileCoord,
-                priority,
-                url: this._provider.getTileUrl(tileCoord),
-                role,
-            };
-        });
-        const ensuredKeys = this._tileBuffer.ensureTiles(orderedRequests, segments);
-        const fallbackKeySet = new Set(selection.fallbackTiles.map((tileCoord) => this.getTileKey(tileCoord)));
-        this._baseVisibleTileKeys = ensuredKeys.filter((tileKey) => baseTileKeys.has(tileKey));
-        this._fallbackVisibleTileKeys = ensuredKeys.filter((tileKey) => fallbackKeySet.has(tileKey) && !baseTileKeys.has(tileKey));
-        this._visibleTileKeys = ensuredKeys.filter((tileKey) => !fallbackKeySet.has(tileKey) && !baseTileKeys.has(tileKey));
-        this.evictCache();
-    }
-    draw(input) {
-        const vMatrix = input.camera.getCameraMatrix();
-        if (!vMatrix)
-            return;
-        this.bootstrapTiles(input.fovDeg ?? 180, input.camera, input.centerSphericalDeg ?? null, input.fovPolygon ?? null, input.viewportSphericalSamples ?? null);
-        const pMatrix = input.pMatrix;
-        const mMatrix = this.getModelMatrix();
-        for (const tileKey of this._baseVisibleTileKeys) {
-            const tile = this._tileBuffer.getActiveTile(tileKey);
-            if (!tile)
-                continue;
-            tile.draw(pMatrix, vMatrix, mMatrix, this._tilePriorities.get(tileKey) ?? 0);
-        }
-        for (const tileKey of this._fallbackVisibleTileKeys) {
-            const tile = this._tileBuffer.getActiveTile(tileKey);
-            if (!tile)
-                continue;
-            tile.draw(pMatrix, vMatrix, mMatrix, this._tilePriorities.get(tileKey) ?? 0, false);
-        }
-        for (const tileKey of this._visibleTileKeys) {
-            const tile = this._tileBuffer.getActiveTile(tileKey);
-            if (tile?.ready) {
-                tile.draw(pMatrix, vMatrix, mMatrix, this._tilePriorities.get(tileKey) ?? 0);
-                continue;
-            }
-            const targetCoord = this.parseTileKey(tileKey);
-            if (targetCoord) {
-                const ancestorTile = this.findBestAvailableAncestor(targetCoord);
-                if (ancestorTile) {
-                    const ancestorMesh = this._ancestorMeshCache.getMesh(targetCoord, ancestorTile.coord, this._config.segmentsPerSide ?? 16);
-                    ancestorTile.drawRemapped(ancestorMesh, pMatrix, vMatrix, mMatrix);
-                }
-            }
-            tile?.draw(pMatrix, vMatrix, mMatrix, this._tilePriorities.get(tileKey) ?? 0);
-        }
-    }
-    evictCache() {
-        const maxCachedTiles = this._config.maxCachedTiles ?? XYZLayer.DEFAULT_MAX_CACHED_TILES;
-        this._tileBuffer.evictCached(maxCachedTiles);
-    }
-    disposeTiles() {
-        this._tileBuffer.dispose();
-        this._ancestorMeshCache.dispose();
-        this._visibleTileKeys = [];
-        this._fallbackVisibleTileKeys = [];
-        this._baseVisibleTileKeys = [];
-    }
-    getTileKey(tileCoord) {
-        return `${tileCoord.z}/${tileCoord.x}/${tileCoord.y}`;
-    }
-    parseTileKey(tileKey) {
-        const [zRaw, xRaw, yRaw] = tileKey.split('/');
-        const z = Number.parseInt(zRaw ?? '', 10);
-        const x = Number.parseInt(xRaw ?? '', 10);
-        const y = Number.parseInt(yRaw ?? '', 10);
-        if (!Number.isFinite(z) || !Number.isFinite(x) || !Number.isFinite(y)) {
-            return null;
-        }
-        return { z, x, y };
-    }
-    findBestAvailableAncestor(targetCoord) {
-        for (let z = targetCoord.z - 1; z >= this._provider.minZoom; z--) {
-            const dz = targetCoord.z - z;
-            const ancestorCoord = {
-                z,
-                x: targetCoord.x >> dz,
-                y: targetCoord.y >> dz,
-            };
-            const ancestor = this._tileBuffer.getAnyTile(this.getTileKey(ancestorCoord));
-            if (ancestor?.ready) {
-                return ancestor;
-            }
-        }
-        return null;
-    }
-}

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

@@ -1,29 +0,0 @@
-import { Point } from '../Point.js';
-import type { XYZLayerConfig, XYZTileCoord } from './types.js';
-type ViewCenterSpherical = {
-    phi: number;
-    theta: number;
-};
-export declare class XYZTileProvider {
-    private _config;
-    constructor(config: XYZLayerConfig);
-    get config(): XYZLayerConfig;
-    get minZoom(): number;
-    get maxZoom(): number;
-    getInitialTiles(): XYZTileCoord[];
-    getTileUrl(tile: XYZTileCoord): string;
-    resolveZoom(fovDeg: number): number;
-    private clampZoom;
-    private getEffectiveTileY;
-    private getSubdomain;
-    getVisibleTilesAtZoom(z: number, centerSphericalDeg: ViewCenterSpherical | null, fovPolygon: Point[], viewportSphericalSamples: ViewCenterSpherical[], padding?: number): XYZTileCoord[];
-    tileFromSpherical(zoom: number, sphericalDeg: ViewCenterSpherical): XYZTileCoord;
-    getNeighborTiles(tile: XYZTileCoord, ring?: number): XYZTileCoord[];
-    deduplicateTiles(tiles: XYZTileCoord[]): XYZTileCoord[];
-    private resolveViewCenter;
-    private latToTileY;
-    private wrapTileX;
-    private normalizeLonAround;
-    private clampTileY;
-}
-export {};