astro-viewer 3.0.0 → 3.1.0

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 {};

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

@@ -1,187 +0,0 @@
-import global from '../../Global.js';
-const MAX_MERCATOR_LAT = 85.0511287798066;
-export class XYZTileProvider {
-    _config;
-    constructor(config) {
-        this._config = config;
-    }
-    get config() {
-        return this._config;
-    }
-    get minZoom() {
-        return Math.max(0, Math.floor(this._config.minZoom ?? 0));
-    }
-    get maxZoom() {
-        return Math.max(this.minZoom, Math.floor(this._config.maxZoom ?? 6));
-    }
-    getInitialTiles() {
-        return this.getVisibleTilesAtZoom(1, null, [], [], 1);
-    }
-    getTileUrl(tile) {
-        if (this._config.urlResolver) {
-            return this._config.urlResolver(tile);
-        }
-        const effectiveY = this.getEffectiveTileY(tile);
-        const subdomain = this.getSubdomain(tile);
-        return this._config.urlTemplate
-            .replace(/\{z\}/g, String(tile.z))
-            .replace(/\{x\}/g, String(tile.x))
-            .replace(/\{y\}/g, String(effectiveY))
-            .replace(/\{s\}/g, subdomain);
-    }
-    resolveZoom(fovDeg) {
-        const safeFov = Math.max(0.01, Math.min(180, fovDeg));
-        const targetTileWidthDeg = Math.max(0.01, safeFov / 2);
-        const rawZoom = Math.ceil(Math.log2(360 / targetTileWidthDeg));
-        return this.clampZoom(rawZoom);
-    }
-    clampZoom(zoom) {
-        return Math.max(this.minZoom, Math.min(this.maxZoom, zoom));
-    }
-    getEffectiveTileY(tile) {
-        if (!this._config.flipY) {
-            return tile.y;
-        }
-        const dim = 2 ** tile.z;
-        return dim - 1 - tile.y;
-    }
-    getSubdomain(tile) {
-        const subdomains = this._config.subdomains ?? [];
-        if (subdomains.length === 0) {
-            return '';
-        }
-        const index = Math.abs(tile.x + tile.y + tile.z) % subdomains.length;
-        return subdomains[index] ?? '';
-    }
-    getVisibleTilesAtZoom(z, centerSphericalDeg, fovPolygon, viewportSphericalSamples, padding = 1) {
-        const dim = 2 ** z;
-        const center = this.resolveViewCenter(null, centerSphericalDeg);
-        const normalizedCenterLon = this.normalizeLonAround(center.lonDeg, center.lonDeg);
-        const polygonPoints = fovPolygon.length > 0
-            ? fovPolygon.map((point) => ({
-                lonDeg: this.normalizeLonAround(point.raDeg > 180 ? point.raDeg - 360 : point.raDeg, normalizedCenterLon),
-                latDeg: point.decDeg,
-            }))
-            : [center];
-        const samplePoints = viewportSphericalSamples.map((sample) => ({
-            lonDeg: this.normalizeLonAround(sample.phi > 180 ? sample.phi - 360 : sample.phi, normalizedCenterLon),
-            latDeg: 90 - sample.theta,
-        }));
-        const coveragePoints = [center, ...polygonPoints, ...samplePoints];
-        let minLon = normalizedCenterLon;
-        let maxLon = normalizedCenterLon;
-        let minLat = center.latDeg;
-        let maxLat = center.latDeg;
-        for (const point of coveragePoints) {
-            minLon = Math.min(minLon, point.lonDeg);
-            maxLon = Math.max(maxLon, point.lonDeg);
-            minLat = Math.min(minLat, point.latDeg);
-            maxLat = Math.max(maxLat, point.latDeg);
-        }
-        const adaptivePadding = Math.max(padding, Math.min(3, Math.max(1, Math.ceil(z / 3))));
-        const minX = Math.floor(((minLon + 180) / 360) * dim) - adaptivePadding;
-        const maxX = Math.floor(((maxLon + 180) / 360) * dim) + adaptivePadding;
-        const minY = Math.floor(this.latToTileY(maxLat, z)) - adaptivePadding;
-        const maxY = Math.floor(this.latToTileY(minLat, z)) + adaptivePadding;
-        const tiles = [];
-        for (let x = minX; x <= maxX; x++) {
-            for (let y = minY; y <= maxY; y++) {
-                tiles.push({
-                    z,
-                    x: this.wrapTileX(x, dim),
-                    y: this.clampTileY(y, dim),
-                });
-            }
-        }
-        for (const point of coveragePoints) {
-            const centerTileX = Math.floor(((point.lonDeg + 180) / 360) * dim);
-            const centerTileY = Math.floor(this.latToTileY(point.latDeg, z));
-            for (let dx = -adaptivePadding; dx <= adaptivePadding; dx++) {
-                for (let dy = -adaptivePadding; dy <= adaptivePadding; dy++) {
-                    tiles.push({
-                        z,
-                        x: this.wrapTileX(centerTileX + dx, dim),
-                        y: this.clampTileY(centerTileY + dy, dim),
-                    });
-                }
-            }
-        }
-        return this.deduplicateTiles(tiles);
-    }
-    tileFromSpherical(zoom, sphericalDeg) {
-        const lonDeg = sphericalDeg.phi > 180 ? sphericalDeg.phi - 360 : sphericalDeg.phi;
-        const latDeg = 90 - sphericalDeg.theta;
-        const dim = 2 ** zoom;
-        const x = Math.floor(((lonDeg + 180) / 360) * dim);
-        const y = Math.floor(this.latToTileY(latDeg, zoom));
-        return {
-            z: zoom,
-            x: this.wrapTileX(x, dim),
-            y: this.clampTileY(y, dim),
-        };
-    }
-    getNeighborTiles(tile, ring = 1) {
-        const dim = 2 ** tile.z;
-        const neighbors = [];
-        for (let dx = -ring; dx <= ring; dx++) {
-            for (let dy = -ring; dy <= ring; dy++) {
-                neighbors.push({
-                    z: tile.z,
-                    x: this.wrapTileX(tile.x + dx, dim),
-                    y: this.clampTileY(tile.y + dy, dim),
-                });
-            }
-        }
-        return this.deduplicateTiles(neighbors);
-    }
-    deduplicateTiles(tiles) {
-        const unique = new Map();
-        for (const tile of tiles) {
-            unique.set(`${tile.z}/${tile.x}/${tile.y}`, tile);
-        }
-        return Array.from(unique.values());
-    }
-    resolveViewCenter(camera, centerSphericalDeg) {
-        if (centerSphericalDeg) {
-            return {
-                lonDeg: centerSphericalDeg.phi > 180 ? centerSphericalDeg.phi - 360 : centerSphericalDeg.phi,
-                latDeg: 90 - centerSphericalDeg.theta,
-            };
-        }
-        if (!camera) {
-            return { lonDeg: 0, latDeg: 0 };
-        }
-        const [x, y, z] = camera.getCameraPosition();
-        const len = Math.hypot(x, y, z);
-        if (!Number.isFinite(len) || len === 0) {
-            return { lonDeg: 0, latDeg: 0 };
-        }
-        const scale = global.insideSphere ? 1 / len : -1 / len;
-        const vx = x * scale;
-        const vy = y * scale;
-        const vz = z * scale;
-        const lonDeg = (Math.atan2(vy, vx) * 180) / Math.PI;
-        const latDeg = (Math.asin(Math.max(-1, Math.min(1, vz))) * 180) / Math.PI;
-        return { lonDeg, latDeg };
-    }
-    latToTileY(latDeg, z) {
-        const lat = Math.max(-MAX_MERCATOR_LAT, Math.min(MAX_MERCATOR_LAT, latDeg));
-        const latRad = (lat * Math.PI) / 180;
-        const n = 2 ** z;
-        return ((1 - Math.asinh(Math.tan(latRad)) / Math.PI) / 2) * n;
-    }
-    wrapTileX(x, dim) {
-        return ((x % dim) + dim) % dim;
-    }
-    normalizeLonAround(lonDeg, referenceLonDeg) {
-        let lon = lonDeg;
-        while (lon - referenceLonDeg > 180)
-            lon -= 360;
-        while (lon - referenceLonDeg < -180)
-            lon += 360;
-        return lon;
-    }
-    clampTileY(y, dim) {
-        return Math.max(0, Math.min(dim - 1, y));
-    }
-}

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

@@ -1 +0,0 @@
-export {};

package/lib-esm/model/earth/wmts/types.d.ts

@@ -1 +0,0 @@
-export type {};

package/lib-esm/model/earth/wmts/types.js

@@ -1 +0,0 @@
-export {};