astro-viewer 3.0.0 → 3.1.0

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

@@ -1,52 +1,53 @@
-import { xyzTileRequestScheduler, XYZTileRequestError } from './XYZTileRequestScheduler.js';
+/*
+ * 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';
 export class XYZTile {
     _coord;
     _url;
     _webgl;
     _shaderProgram;
-    _positionBuffer;
-    _uvBuffer;
-    _indexBuffer;
+    _meshBuilder;
+    _gpuMesh;
     _texture = null;
-    _indices;
-    _indexType;
+    _image;
     _ready = false;
-    _aborted = false;
     _loading = false;
+    _aborted = false;
     _failedUntil = 0;
     _lastUsedAt = 0;
     _createdAt = Date.now();
-    _image;
-    _objectUrl = null;
-    constructor(coord, url, mesh, webgl, shaderProgram) {
+    constructor(coord, url, webgl, shaderProgram, meshBuilder = new XYZMeshBuilder(), segmentsPerSide = 16) {
         this._coord = coord;
         this._url = url;
         this._webgl = webgl;
         this._shaderProgram = shaderProgram;
-        this._positionBuffer = webgl.createBuffer();
-        this._uvBuffer = webgl.createBuffer();
-        this._indexBuffer = webgl.createBuffer();
-        this._indices = mesh.indices;
-        this._indexType = mesh.indices instanceof Uint32Array ? webgl.UNSIGNED_INT : webgl.UNSIGNED_SHORT;
-        webgl.bindBuffer(webgl.ARRAY_BUFFER, this._positionBuffer);
-        webgl.bufferData(webgl.ARRAY_BUFFER, mesh.positions, webgl.STATIC_DRAW);
-        webgl.bindBuffer(webgl.ARRAY_BUFFER, this._uvBuffer);
-        webgl.bufferData(webgl.ARRAY_BUFFER, mesh.uvs, webgl.STATIC_DRAW);
-        webgl.bindBuffer(webgl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
-        webgl.bufferData(webgl.ELEMENT_ARRAY_BUFFER, mesh.indices, webgl.STATIC_DRAW);
-    }
-    get ready() {
-        return this._ready;
+        this._meshBuilder = meshBuilder;
+        const mesh = this._meshBuilder.buildTileMesh(coord, segmentsPerSide);
+        this._gpuMesh = this._meshBuilder.uploadMesh(mesh, this._webgl);
+        this.initImage();
     }
     get coord() {
         return this._coord;
     }
-    get failedUntil() {
-        return this._failedUntil;
+    get ready() {
+        return this._ready;
     }
     get loading() {
         return this._loading;
     }
+    get failedUntil() {
+        return this._failedUntil;
+    }
     get lastUsedAt() {
         return this._lastUsedAt;
     }
@@ -56,10 +57,7 @@ export class XYZTile {
     touch() {
         this._lastUsedAt = Date.now();
     }
-    primeLoad(priority = 0) {
-        this.loadTexture(priority);
-    }
-    loadTexture(priority = 0) {
+    initImage() {
         if (this._loading || this._ready || this._aborted) {
             return;
         }
@@ -68,80 +66,88 @@ export class XYZTile {
             return;
         }
         this._loading = true;
-        xyzTileRequestScheduler.load(this._url, priority)
-            .then((blob) => this.loadImageFromBlob(blob))
-            .catch((error) => {
-            this._loading = false;
-            this._ready = false;
-            const cooldownMs = error instanceof XYZTileRequestError ? error.cooldownMs : 10000;
-            this._failedUntil = Date.now() + cooldownMs;
-        });
-    }
-    loadImageFromBlob(blob) {
         const image = new Image();
         this._image = image;
-        this._objectUrl = URL.createObjectURL(blob);
-        image.onload = () => this.onImageLoaded();
+        image.crossOrigin = 'anonymous';
+        image.onload = () => this.imageLoaded();
         image.onerror = () => {
-            this._loading = false;
             this._ready = false;
-            this._failedUntil = Date.now() + 30000;
-            this.revokeObjectUrl();
+            this._loading = false;
+            this._failedUntil = Date.now() + 30_000;
         };
-        image.src = this._objectUrl;
+        image.src = this._url;
     }
-    onImageLoaded() {
+    imageLoaded() {
         if (!this._image || this._aborted) {
             return;
         }
+        this.textureLoaded(this._image);
+        this._loading = false;
+        this._failedUntil = 0;
+        this._ready = true;
+    }
+    textureLoaded(image) {
         const gl = this._webgl;
+        this._shaderProgram.enableProgram();
         const texture = gl.createTexture();
         if (!texture) {
-            throw new Error('Could not create XYZ texture');
+            throw new Error(`Could not create XYZ texture for ${this.key}`);
         }
         this._texture = texture;
         gl.activeTexture(gl.TEXTURE0);
-        gl.bindTexture(gl.TEXTURE_2D, texture);
         gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
-        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
-        this._loading = false;
-        this._failedUntil = 0;
-        this._ready = true;
-        this.revokeObjectUrl();
     }
-    draw(pMatrix, vMatrix, mMatrix, priority = 0, allowLoad = true) {
+    draw(pMatrix, vMatrix, mMatrix, colorMapIdx) {
         this.touch();
-        if (!this._ready && allowLoad) {
-            this.loadTexture(priority);
-        }
-        if (!this._ready || !this._texture) {
-            return;
+        if (!this._ready || !this._texture || this._aborted) {
+            return false;
         }
-        this.drawWithGpuMesh({
-            positionBuffer: this._positionBuffer,
-            uvBuffer: this._uvBuffer,
-            indexBuffer: this._indexBuffer,
-            indexCount: this._indices.length,
-            indexType: this._indexType,
-        }, pMatrix, vMatrix, mMatrix);
-    }
-    drawRemapped(mesh, pMatrix, vMatrix, mMatrix) {
+        this.drawWithGpuMesh(this._gpuMesh, pMatrix, vMatrix, mMatrix, colorMapIdx);
+        return true;
+    }
+    drawRemapped(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx) {
         this.touch();
-        if (!this._ready || !this._texture) {
-            return;
+        if (!this._ready || !this._texture || this._aborted) {
+            return false;
         }
-        this.drawWithGpuMesh(mesh, pMatrix, vMatrix, mMatrix);
+        this.drawWithGpuMesh(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx);
+        return true;
+    }
+    dispose() {
+        const gl = this._webgl;
+        if (this._texture) {
+            gl.deleteTexture(this._texture);
+            this._texture = null;
+        }
+        if (this._gpuMesh.positionBuffer) {
+            gl.deleteBuffer(this._gpuMesh.positionBuffer);
+            this._gpuMesh.positionBuffer = null;
+        }
+        if (this._gpuMesh.uvBuffer) {
+            gl.deleteBuffer(this._gpuMesh.uvBuffer);
+            this._gpuMesh.uvBuffer = null;
+        }
+        if (this._gpuMesh.indexBuffer) {
+            gl.deleteBuffer(this._gpuMesh.indexBuffer);
+            this._gpuMesh.indexBuffer = null;
+        }
+        this._image = undefined;
+        this._ready = false;
+        this._loading = false;
+        this._aborted = true;
     }
-    drawWithGpuMesh(mesh, pMatrix, vMatrix, mMatrix) {
+    drawWithGpuMesh(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx) {
         if (!this._texture) {
             return;
         }
         const gl = this._webgl;
-        this._shaderProgram.enableShaders(pMatrix, vMatrix, mMatrix);
+        this._shaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx);
         gl.bindBuffer(gl.ARRAY_BUFFER, mesh.positionBuffer);
         gl.vertexAttribPointer(this._shaderProgram.locations.vertexPositionAttribute, 3, gl.FLOAT, false, 0, 0);
         gl.enableVertexAttribArray(this._shaderProgram.locations.vertexPositionAttribute);
@@ -155,33 +161,7 @@ export class XYZTile {
         gl.disableVertexAttribArray(this._shaderProgram.locations.vertexPositionAttribute);
         gl.disableVertexAttribArray(this._shaderProgram.locations.textureCoordAttribute);
     }
-    dispose() {
-        const gl = this._webgl;
-        if (this._texture) {
-            gl.deleteTexture(this._texture);
-            this._texture = null;
-        }
-        if (this._positionBuffer) {
-            gl.deleteBuffer(this._positionBuffer);
-            this._positionBuffer = null;
-        }
-        if (this._uvBuffer) {
-            gl.deleteBuffer(this._uvBuffer);
-            this._uvBuffer = null;
-        }
-        if (this._indexBuffer) {
-            gl.deleteBuffer(this._indexBuffer);
-            this._indexBuffer = null;
-        }
-        this._image = undefined;
-        this.revokeObjectUrl();
-        this._loading = false;
-        this._ready = false;
-    }
-    revokeObjectUrl() {
-        if (this._objectUrl) {
-            URL.revokeObjectURL(this._objectUrl);
-            this._objectUrl = null;
-        }
+    get key() {
+        return `${this._coord.z}/${this._coord.x}/${this._coord.y}`;
     }
 }

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

@@ -1,39 +1,37 @@
-import { XYZShaderProgram } from '../../shader/XYZShaderProgram.js';
-import { XYZMeshBuilder } from './XYZMeshBuilder.js';
-import { XYZTile } from './XYZTile.js';
-import type { XYZTileCoord } from './types.js';
-export type XYZTileRequest = {
-    tileCoord: XYZTileCoord;
-    url: string;
-    priority: number;
-    role: 'current' | 'coverage' | 'fallback' | 'base';
+import type { XYZTileCoord } from './XYZTypes.js';
+export type XYZBufferedTile = {
+    coord: XYZTileCoord;
+    loading?: boolean;
+    lastUsedAt?: number;
+    createdAt?: number;
+    touch?: () => void;
+    dispose?: () => void;
 };
-type XYZTileBufferEntry = {
-    tile: XYZTile;
+export type XYZTileBufferEntry<TTile extends XYZBufferedTile = XYZBufferedTile> = {
+    tile: TTile;
     cacheTime0?: number;
-    role: 'current' | 'coverage' | 'fallback' | 'base';
 };
-export declare class XYZTileBuffer {
+export type XYZTileFactory<TTile extends XYZBufferedTile = XYZBufferedTile> = (coord: XYZTileCoord) => TTile;
+export declare class XYZTileBuffer<TTile extends XYZBufferedTile = XYZBufferedTile> {
     private _tiles;
     private _cachedTiles;
     private _cacheAliveMilliSeconds;
     private _cleanerId;
-    private _webgl;
-    private _meshBuilder;
-    private _shaderProgram;
-    constructor(minutesToLiveInCache: number | undefined, webgl: WebGL2RenderingContext, meshBuilder: XYZMeshBuilder, shaderProgram: XYZShaderProgram);
-    get activeTiles(): Map<string, XYZTileBufferEntry>;
-    get cachedTiles(): Map<string, XYZTileBufferEntry>;
+    constructor(minutesToLiveInCache?: number);
+    get activeTiles(): Map<string, XYZTileBufferEntry<TTile>>;
+    get cachedTiles(): Map<string, XYZTileBufferEntry<TTile>>;
     get size(): number;
-    getTile(tileCoord: XYZTileCoord, url: string, segmentsPerSide: number, role: 'current' | 'coverage' | 'fallback' | 'base'): XYZTile;
-    private getExistingTile;
-    ensureTiles(requests: XYZTileRequest[], segmentsPerSide: number): string[];
-    getActiveTile(tileKey: string): XYZTile | null;
-    getAnyTile(tileKey: string): XYZTile | null;
+    ensureTiles(visibleTiles: XYZTileCoord[], tileFactory: XYZTileFactory<TTile>): string[];
+    getTile(tileCoord: XYZTileCoord, tileFactory: XYZTileFactory<TTile>): TTile;
+    getActiveTile(tileKey: string): TTile | null;
+    getAnyTile(tileKey: string): TTile | null;
+    getActiveTiles(): TTile[];
     syncVisibleTiles(visibleTileKeys: string[]): void;
     evictCached(maxCachedTiles: number): void;
     dispose(): void;
+    key(tileCoord: XYZTileCoord): string;
+    static key(tileCoord: XYZTileCoord): string;
     private cacheCleaner;
-    private key;
+    private touchTile;
+    private getTileAgeScore;
 }
-export {};

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

@@ -1,20 +1,27 @@
-import { XYZTile } from './XYZTile.js';
+/*
+ * 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 class XYZTileBuffer {
     _tiles = new Map();
     _cachedTiles = new Map();
     _cacheAliveMilliSeconds;
     _cleanerId;
-    _webgl;
-    _meshBuilder;
-    _shaderProgram;
-    constructor(minutesToLiveInCache = 1, webgl, meshBuilder, shaderProgram) {
+    constructor(minutesToLiveInCache = 1) {
         this._cacheAliveMilliSeconds = minutesToLiveInCache * 60 * 1000;
-        this._webgl = webgl;
-        this._meshBuilder = meshBuilder;
-        this._shaderProgram = shaderProgram;
-        this._cleanerId = window.setInterval(() => {
-            this.cacheCleaner();
-        }, 10_000);
+        if (typeof window !== 'undefined') {
+            this._cleanerId = window.setInterval(() => {
+                this.cacheCleaner();
+            }, 10_000);
+        }
     }
     get activeTiles() {
         return this._tiles;
@@ -25,64 +32,31 @@ export class XYZTileBuffer {
     get size() {
         return this._tiles.size + this._cachedTiles.size;
     }
-    getTile(tileCoord, url, segmentsPerSide, role) {
-        const tileKey = this.key(tileCoord);
-        if (!this._tiles.has(tileKey)) {
-            if (this._cachedTiles.has(tileKey)) {
-                const entry = this._cachedTiles.get(tileKey);
-                entry.cacheTime0 = undefined;
-                entry.role = role;
-                this._tiles.set(tileKey, entry);
-                this._cachedTiles.delete(tileKey);
-            }
-            else {
-                const mesh = this._meshBuilder.buildTileMesh(tileCoord, segmentsPerSide);
-                this._tiles.set(tileKey, {
-                    tile: new XYZTile(tileCoord, url, mesh, this._webgl, this._shaderProgram),
-                    role,
-                });
-            }
-        }
-        else {
-            const entry = this._tiles.get(tileKey);
-            entry.role = role;
+    ensureTiles(visibleTiles, tileFactory) {
+        const visibleTileKeys = [];
+        for (const tileCoord of visibleTiles) {
+            const tile = this.getTile(tileCoord, tileFactory);
+            this.touchTile(tile);
+            visibleTileKeys.push(this.key(tileCoord));
         }
-        return this._tiles.get(tileKey).tile;
+        this.syncVisibleTiles(visibleTileKeys);
+        return visibleTileKeys;
     }
-    getExistingTile(tileCoord, role) {
+    getTile(tileCoord, tileFactory) {
         const tileKey = this.key(tileCoord);
         if (this._tiles.has(tileKey)) {
-            const entry = this._tiles.get(tileKey);
-            entry.role = role;
-            return entry.tile;
+            return this._tiles.get(tileKey).tile;
         }
         if (this._cachedTiles.has(tileKey)) {
             const entry = this._cachedTiles.get(tileKey);
             entry.cacheTime0 = undefined;
-            entry.role = role;
             this._tiles.set(tileKey, entry);
             this._cachedTiles.delete(tileKey);
             return entry.tile;
         }
-        return null;
-    }
-    ensureTiles(requests, segmentsPerSide) {
-        const visibleTileKeys = [];
-        for (const request of requests) {
-            const tile = request.role === 'fallback'
-                ? this.getExistingTile(request.tileCoord, 'fallback')
-                : this.getTile(request.tileCoord, request.url, segmentsPerSide, request.role);
-            if (!tile) {
-                continue;
-            }
-            tile.touch();
-            if (request.role !== 'fallback') {
-                tile.primeLoad(request.priority);
-            }
-            visibleTileKeys.push(this.key(request.tileCoord));
-        }
-        this.syncVisibleTiles(visibleTileKeys);
-        return visibleTileKeys;
+        const tile = tileFactory(tileCoord);
+        this._tiles.set(tileKey, { tile });
+        return tile;
     }
     getActiveTile(tileKey) {
         return this._tiles.get(tileKey)?.tile ?? null;
@@ -90,11 +64,14 @@ export class XYZTileBuffer {
     getAnyTile(tileKey) {
         return this._tiles.get(tileKey)?.tile ?? this._cachedTiles.get(tileKey)?.tile ?? null;
     }
+    getActiveTiles() {
+        return Array.from(this._tiles.values(), (entry) => entry.tile);
+    }
     syncVisibleTiles(visibleTileKeys) {
         const visibleKeySet = new Set(visibleTileKeys);
         for (const [tileKey, entry] of this._tiles) {
             if (visibleKeySet.has(tileKey)) {
-                entry.tile.touch();
+                this.touchTile(entry.tile);
                 continue;
             }
             entry.cacheTime0 = Date.now();
@@ -107,9 +84,7 @@ export class XYZTileBuffer {
             return;
         }
         const candidates = Array.from(this._cachedTiles.entries()).sort((a, b) => {
-            const scoreA = Math.min(a[1].tile.lastUsedAt || a[1].tile.createdAt, a[1].tile.createdAt);
-            const scoreB = Math.min(b[1].tile.lastUsedAt || b[1].tile.createdAt, b[1].tile.createdAt);
-            return scoreA - scoreB;
+            return this.getTileAgeScore(a[1].tile) - this.getTileAgeScore(b[1].tile);
         });
         for (const [tileKey, entry] of candidates) {
             if (this.size <= maxCachedTiles) {
@@ -118,32 +93,47 @@ export class XYZTileBuffer {
             if (entry.tile.loading) {
                 continue;
             }
-            entry.tile.dispose();
+            entry.tile.dispose?.();
             this._cachedTiles.delete(tileKey);
         }
     }
     dispose() {
-        window.clearInterval(this._cleanerId);
+        if (this._cleanerId !== undefined && typeof window !== 'undefined') {
+            window.clearInterval(this._cleanerId);
+            this._cleanerId = undefined;
+        }
         for (const entry of this._tiles.values()) {
-            entry.tile.dispose();
+            entry.tile.dispose?.();
         }
         for (const entry of this._cachedTiles.values()) {
-            entry.tile.dispose();
+            entry.tile.dispose?.();
         }
         this._tiles.clear();
         this._cachedTiles.clear();
     }
+    key(tileCoord) {
+        return XYZTileBuffer.key(tileCoord);
+    }
+    static key(tileCoord) {
+        return `${tileCoord.z}/${tileCoord.x}/${tileCoord.y}`;
+    }
     cacheCleaner() {
         const now = Date.now();
         for (const [tileKey, entry] of this._cachedTiles) {
             const t0 = entry.cacheTime0;
-            if (t0 !== undefined && now - t0 > this._cacheAliveMilliSeconds && !entry.tile.loading) {
-                entry.tile.dispose();
-                this._cachedTiles.delete(tileKey);
+            if (t0 === undefined || now - t0 <= this._cacheAliveMilliSeconds || entry.tile.loading) {
+                continue;
             }
+            entry.tile.dispose?.();
+            this._cachedTiles.delete(tileKey);
         }
     }
-    key(tileCoord) {
-        return `${tileCoord.z}/${tileCoord.x}/${tileCoord.y}`;
+    touchTile(tile) {
+        tile.touch?.();
+    }
+    getTileAgeScore(tile) {
+        const lastUsedAt = tile.lastUsedAt ?? 0;
+        const createdAt = tile.createdAt ?? lastUsedAt;
+        return Math.min(lastUsedAt || createdAt, createdAt);
     }
 }

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

@@ -1,4 +1,4 @@
-import type { XYZRequestSchedulerDebugStats } from './types.js';
+import type { XYZRequestSchedulerDebugStats } from './XYZConfig.js';
 export declare class XYZTileRequestError extends Error {
     cooldownMs: number;
     retryable: boolean;

package/lib-esm/model/earth/XYZTileRequestScheduler.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.
+ */
 export class XYZTileRequestError extends Error {
     cooldownMs;
     retryable;
@@ -73,9 +85,8 @@ export class XYZTileRequestScheduler {
     pump() {
         while (this._activeCount < this._maxConcurrent && this._queue.length > 0) {
             const item = this._queue.shift();
-            if (!item) {
+            if (!item)
                 return;
-            }
             const hostCooldown = this.getHostCooldown(item.url);
             const now = Date.now();
             if (hostCooldown > now) {

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

@@ -0,0 +1,24 @@
+export type XYZTileCoord = {
+    z: number;
+    x: number;
+    y: number;
+};
+export type XYZVisibleTileSelection = {
+    key: string;
+    currentZoom: number;
+    visibleTiles: XYZTileCoord[];
+    visibleTilesMap: Map<string, XYZTileCoord>;
+    ancestorsMap: Map<string, XYZTileCoord>;
+};
+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;
+};

package/lib-esm/model/earth/XYZTypes.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/XYZVisibleTilesManager.d.ts

@@ -1,30 +1,19 @@
-import type { XYZTileCoord } from './types.js';
-import { XYZTileProvider } from './XYZTileProvider.js';
-import type { SkyEntityDrawInput } from '../AbstractSkyEntity.js';
-export type XYZTileSelection = {
-    key: string;
-    currentTiles: XYZTileCoord[];
-    fallbackTiles: XYZTileCoord[];
-    currentZoom: number;
-    coreTileCount: number;
-    coverageTileCount: number;
-};
+import { ReadonlyMat4 } from 'gl-matrix';
+import Camera from '../../Camera.js';
+import { AbstractSkyEntity } from '../AbstractSkyEntity.js';
+import type { XYZTileCoord, XYZVisibleTileSelection } from './XYZTypes.js';
 export declare class XYZVisibleTilesManager {
-    private _provider;
-    constructor(provider: XYZTileProvider);
-    selectTiles(input: SkyEntityDrawInput): XYZTileSelection;
-    private buildCoreVisibleTiles;
-    private buildCoverageTiles;
-    private collectCoverageSamples;
-    private interpolateFoVPolygon;
-    private getNeighborRing;
-    private isBoundaryTile;
-    private normalizeTile;
-    private normalizePhi;
-    private buildFallbackMap;
-    private buildFallbackSeedTiles;
-    private orderTilesByScreenRelevance;
-    private orderFallbackTiles;
-    private getCenterTileCoord;
+    private _ancestorsMap;
+    private _visibleTilesMap;
+    private _visibleTiles;
+    private _selection;
+    get ancestorsMap(): Map<string, XYZTileCoord>;
+    get visibleTiles(): XYZTileCoord[];
+    get visibleTilesMap(): Map<string, XYZTileCoord>;
+    get selection(): XYZVisibleTileSelection;
+    computeVisibleTiles(z: number, xyzModel: AbstractSkyEntity, webgl: WebGL2RenderingContext, camera: Camera, pMatrix: ReadonlyMat4, sampleCount?: number, padding?: number): XYZVisibleTileSelection;
+    private refreshAncestorsMap;
+    private buildTileMap;
+    private buildSelectionKey;
     private key;
 }