astro-viewer 3.2.1 → 3.3.0

package/lib-esm/AstroSphere.d.ts

@@ -13,6 +13,9 @@ import type { WMTSLayerConfig, XYZDebugStats, XYZLayerConfig } from "./model/ear
 import type { HiPSDebugStats } from "./model/hips/HiPSConfig.js";
 import { XYZMapDescriptor } from "./model/earth/XYZMapDescriptor.js";
 import { XYZMap } from "./model/earth/XYZMap.js";
+import { MeshHiPS } from "./model/meships/MeshHiPS.js";
+import { MeshHiPSDescriptor } from "./model/meships/MeshHiPSDescriptor.js";
+import type { MeshHiPSDebugStats } from "./model/meships/MeshHiPSTypes.js";
 export type PointCoordinates = {
     astroDeg: AstroCoords;
     raHMS: HMS;
@@ -59,6 +62,7 @@ declare class AstroSphere {
     private pointerDownAt;
     private _activeHiPS;
     private _activeXYZ2;
+    private _activeMeshHiPS;
     private _activeBaseLayer;
     private startup;
     private fov;
@@ -103,6 +107,7 @@ declare class AstroSphere {
     activateHiPS(hipsDescriptor: HiPSDescriptor): void;
     activateXYZ(config: XYZLayerConfig): void;
     activateXYZ2(config: XYZMapDescriptor): void;
+    activateMeshHiPS(descriptor: MeshHiPSDescriptor): void;
     activateWMTS(config: WMTSLayerConfig): void;
     showCatalogue(cat: CatalogueGL): Promise<CatalogueGL>;
     deleteCatalogue(catalogue: CatalogueGL): void;
@@ -132,6 +137,7 @@ declare class AstroSphere {
     private prevCentralDecDeg;
     get activeHiPS(): HiPS | null;
     get activeXYZ(): XYZMap | null;
+    get activeMeshHiPS(): MeshHiPS | null;
     isLonLatGridVisible(): boolean;
     toggleLonLatGrid(): boolean;
     setEastWestRotationLocked(locked: boolean): void;
@@ -140,6 +146,7 @@ declare class AstroSphere {
     isNorthSouthRotationLocked(): boolean;
     getXYZDebugStats(): XYZDebugStats;
     getHiPSDebugStats(): HiPSDebugStats | null;
+    getMeshHiPSDebugStats(): MeshHiPSDebugStats | null;
     draw(canvas: HTMLCanvasElement): void;
     private emitHoveredSourceIfChanged;
 }

package/lib-esm/AstroSphere.js

@@ -28,6 +28,7 @@ import { xyzTileRequestScheduler } from "./model/earth/XYZTileRequestScheduler.j
 import { WMTSAdapter } from "./model/earth/WMTSAdapter.js";
 import { XYZMapDescriptor } from "./model/earth/XYZMapDescriptor.js";
 import { XYZMap } from "./model/earth/XYZMap.js";
+import { MeshHiPS } from "./model/meships/MeshHiPS.js";
 import { mat4, vec3, vec4 } from "gl-matrix";
 /**
  * AstroSphere — main WebGL scene controller (TS port)
@@ -54,6 +55,7 @@ class AstroSphere {
     pointerDownAt = 0;
     _activeHiPS = null;
     _activeXYZ2 = null;
+    _activeMeshHiPS = null;
     _activeBaseLayer = null;
     startup = true;
     fov;
@@ -287,7 +289,7 @@ class AstroSphere {
     }
     emitCameraChanged(reason) {
         // avoid dispatch before scene is ready
-        if (!this._activeHiPS)
+        if (!this._activeHiPS && !this._activeXYZ2 && !this._activeMeshHiPS)
             return;
         if (!this._healpixGrid?.fovObj)
             return;
@@ -566,6 +568,10 @@ class AstroSphere {
         this._activeXYZ2 = new XYZMap(1, [0.0, 0.0, 0.0], 0, 0, config, this._webgl);
         this._activeBaseLayer = "xyz";
     }
+    activateMeshHiPS(descriptor) {
+        this._activeMeshHiPS = new MeshHiPS(descriptor.meshRadius, [0.0, 0.0, 0.0], 0, 0, descriptor, this._webgl, this._healpixGrid);
+        this._activeBaseLayer = "meships";
+    }
     activateWMTS(config) {
         const adapter = new WMTSAdapter(config);
         const xyzConfig = adapter.toXYZLayerConfig();
@@ -746,7 +752,7 @@ class AstroSphere {
         // return null
     }
     changeColorMap(cm) {
-        if (!this._activeHiPS && !this._activeXYZ2)
+        if (!this._activeHiPS && !this._activeXYZ2 && !this._activeMeshHiPS)
             return;
         this._selectedColorMap = cm;
         this._activeHiPS?.changeColorMap(cm);
@@ -761,6 +767,9 @@ class AstroSphere {
     get activeXYZ() {
         return this._activeXYZ2;
     }
+    get activeMeshHiPS() {
+        return this._activeMeshHiPS;
+    }
     isLonLatGridVisible() {
         return this._activeXYZ2?.isLonLatGridVisible() ?? false;
     }
@@ -801,12 +810,17 @@ class AstroSphere {
             return null;
         return this._activeHiPS.getDebugStats();
     }
+    getMeshHiPSDebugStats() {
+        if (!this._activeMeshHiPS)
+            return null;
+        return this._activeMeshHiPS.getDebugStats();
+    }
     draw(canvas) {
         if (this._refreshingStatus)
             return;
         if (!this._webgl)
             return;
-        if (!this._activeHiPS && !this._activeXYZ2)
+        if (!this._activeHiPS && !this._activeXYZ2 && !this._activeMeshHiPS)
             return;
         if (!this._healpixGrid || Object.keys(this._healpixGrid).length === 0)
             return;
@@ -913,6 +927,10 @@ class AstroSphere {
             const visibleOrder = Math.min(this._healpixGrid.visibleorder, this._activeHiPS.maxOrder);
             this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
         }
+        if (this._activeBaseLayer === "meships" && this._activeMeshHiPS) {
+            const visibleOrder = this._activeMeshHiPS.refreshOrder(this.fov?.minFoV ?? this._healpixGrid.getMinFoV());
+            this._healpixGrid.visibleTilesManager.computeVisiblePixels(visibleOrder, this._webgl, this._camera, this._perspectiveMatrixManager.pMatrix);
+        }
         // DRAW HiPS
         const stableFovDeg = this.fov?.minFoV ?? this._healpixGrid.getMinFoV();
         const nowForGrid = performance.now();
@@ -944,6 +962,9 @@ class AstroSphere {
         if (this._activeBaseLayer === "xyz") {
             this._activeXYZ2?.draw(skyEntityDrawInput);
         }
+        if (this._activeBaseLayer === "meships") {
+            this._activeMeshHiPS?.draw(skyEntityDrawInput);
+        }
         this._healpixGrid.draw(skyEntityDrawInput);
         this._equatorialGrid.draw(skyEntityDrawInput);
         this._webgl.enable(this._webgl.DEPTH_TEST);
@@ -966,7 +987,8 @@ class AstroSphere {
         }
         this.activeCatalogues.forEach((cat) => {
             const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix();
+                this._activeXYZ2?.getModelMatrix() ??
+                this._activeMeshHiPS?.getModelMatrix();
             if (activeModelMatrix) {
                 cat.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
             }
@@ -974,7 +996,8 @@ class AstroSphere {
         this.emitHoveredSourceIfChanged();
         this.activeFootprintSets.forEach((fst) => {
             const activeModelMatrix = this._activeHiPS?.getModelMatrix() ??
-                this._activeXYZ2?.getModelMatrix();
+                this._activeXYZ2?.getModelMatrix() ??
+                this._activeMeshHiPS?.getModelMatrix();
             if (activeModelMatrix) {
                 fst.draw(activeModelMatrix, this.mouseHelper, this._camera.getCameraMatrix(), this._perspectiveMatrixManager.pMatrix);
             }

package/lib-esm/AstroViewer.d.ts

@@ -14,6 +14,7 @@ import type { HiPSDebugStats } from './model/hips/HiPSConfig.js';
 import { XYZMap } from './model/earth/XYZMap.js';
 import { TerraPointSetGL } from './model/terra/TerraPointSetGL.js';
 import { TerraFootprintSetGL } from './model/terra/TerraFootprintSetGL.js';
+import type { MeshHiPSConfig, MeshHiPSDebugStats } from './model/meships/MeshHiPSTypes.js';
 export declare class AstroViewer {
     private astroSphere;
     private canvas;
@@ -54,11 +55,14 @@ export declare class AstroViewer {
         name?: string;
     }): void;
     activateWMTS(config: WMTSLayerConfig): void;
+    activateMeshHiPS(config: MeshHiPSConfig): void;
     setXYZMaxConcurrentRequests(value: number): void;
     getXYZMaxConcurrentRequests(): number;
     getXYZDebugStats(): XYZDebugStats;
     getHiPSDebugStats(): HiPSDebugStats | null;
+    getMeshHiPSDebugStats(): MeshHiPSDebugStats | null;
     loadHiPS(baseUrl: string): Promise<string>;
+    loadMeshHiPS(baseUrl: string, config?: Omit<MeshHiPSConfig, 'baseUrl'>): Promise<string>;
     changeColorMap(colorMapName: ColorMapName): void;
     changeCustomColorMap(colorMap: ColorMap): void;
     getActiveHiPS(): HiPS | null;

package/lib-esm/AstroViewer.js

@@ -21,6 +21,7 @@ import { xyzTileRequestScheduler } from './model/earth/XYZTileRequestScheduler.j
 import { XYZMapDescriptor } from './model/earth/XYZMapDescriptor.js';
 import { TerraPointSetGL } from './model/terra/TerraPointSetGL.js';
 import { TerraFootprintSetGL } from './model/terra/TerraFootprintSetGL.js';
+import { MeshHiPSDescriptor } from './model/meships/MeshHiPSDescriptor.js';
 // & {
 //   viewportWidth: number
 //   viewportHeight: number
@@ -136,6 +137,9 @@ export class AstroViewer {
     activateWMTS(config) {
         this.astroSphere.activateWMTS(config);
     }
+    activateMeshHiPS(config) {
+        this.astroSphere.activateMeshHiPS(new MeshHiPSDescriptor(config));
+    }
     setXYZMaxConcurrentRequests(value) {
         xyzTileRequestScheduler.setMaxConcurrent(value);
     }
@@ -148,6 +152,9 @@ export class AstroViewer {
     getHiPSDebugStats() {
         return this.astroSphere.getHiPSDebugStats();
     }
+    getMeshHiPSDebugStats() {
+        return this.astroSphere.getMeshHiPSDebugStats();
+    }
     async loadHiPS(baseUrl) {
         const hipsUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
         const resp = await fetch(hipsUrl + 'properties');
@@ -159,6 +166,26 @@ export class AstroViewer {
         return desc.surveyName;
         // this.activateHiPS(desc);
     }
+    async loadMeshHiPS(baseUrl, config = {}) {
+        const meshHiPSUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
+        let propsText = '';
+        const resp = await fetch(meshHiPSUrl + 'properties');
+        if (resp.ok) {
+            propsText = await resp.text();
+        }
+        else {
+            const jsonResp = await fetch(meshHiPSUrl + 'properties.json');
+            if (!jsonResp.ok)
+                throw new Error(`HTTP ${jsonResp.status} fetching MeshHiPS properties`);
+            const json = await jsonResp.json();
+            propsText = Object.entries(json)
+                .map(([key, value]) => `${key}=${String(value)}`)
+                .join('\n');
+        }
+        const desc = new MeshHiPSDescriptor({ ...config, baseUrl: meshHiPSUrl }, propsText);
+        this.astroSphere.activateMeshHiPS(desc);
+        return desc.name;
+    }
     // changeColorMap(hips: HiPS, colorMapName: ColorMapName) {
     changeColorMap(colorMapName) {
         const colorMap = ColorMaps[colorMapName];

package/lib-esm/index.d.ts

@@ -19,7 +19,10 @@ export type { ColorMap, ColorMapName } from './model/ColorMaps.js';
 export { HiPS } from './model/hips/HiPS.js';
 export { XYZMap } from './model/earth/XYZMap.js';
 export { WMTSAdapter } from './model/earth/WMTSAdapter.js';
+export { MeshHiPS } from './model/meships/MeshHiPS.js';
+export { MeshHiPSDescriptor } from './model/meships/MeshHiPSDescriptor.js';
 export type { XYZLayerConfig, WMTSLayerConfig, WMTSRequestEncoding } from './model/earth/XYZConfig.js';
 export type { XYZTileCoord, XYZTileMesh } from './model/earth/XYZTypes.js';
+export type { MeshHiPSConfig, MeshHiPSDebugStats, MeshHiPSTileCoord } from './model/meships/MeshHiPSTypes.js';
 export { Source } from './model/Source.js';
 export { Footprint } from './model/footprints/Footprint.js';

package/lib-esm/index.js

@@ -28,6 +28,8 @@ export { ColorMaps, COLOR_MAP_SAMPLE_COUNT, createColorMapFromSamples } from './
 export { HiPS } from './model/hips/HiPS.js';
 export { XYZMap } from './model/earth/XYZMap.js';
 export { WMTSAdapter } from './model/earth/WMTSAdapter.js';
+export { MeshHiPS } from './model/meships/MeshHiPS.js';
+export { MeshHiPSDescriptor } from './model/meships/MeshHiPSDescriptor.js';
 export { Source } from './model/Source.js';
 export { Footprint } from './model/footprints/Footprint.js';
 console.log('astroviewer UMD loaded');

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

@@ -48,7 +48,7 @@ export type XYZRequestSchedulerDebugStats = {
     hostsInBackoff: XYZRequestBackoffDebugEntry[];
 };
 export type XYZDebugStats = {
-    activeBaseLayer: 'hips' | 'xyz' | null;
+    activeBaseLayer: 'hips' | 'xyz' | 'meships' | null;
     layer: XYZLayerDebugStats | null;
     requests: XYZRequestSchedulerDebugStats;
 };

package/lib-esm/model/hips/HiPSConfig.d.ts

@@ -1,5 +1,5 @@
 export type HiPSDebugStats = {
-    activeBaseLayer: 'hips' | 'xyz' | null;
+    activeBaseLayer: 'hips' | 'xyz' | 'meships' | null;
     hipsName: string | null;
     hipsUrl: string | null;
     isGalactic: boolean | null;

package/lib-esm/model/meships/MeshHiPS.d.ts

@@ -0,0 +1,30 @@
+import { AbstractSkyEntity, SkyEntityDrawInput } from '../AbstractSkyEntity.js';
+import { HealpixGrid } from '../grid/HealpixGrid.js';
+import { MeshHiPSDescriptor } from './MeshHiPSDescriptor.js';
+import type { MeshHiPSDebugStats } from './MeshHiPSTypes.js';
+export declare class MeshHiPS extends AbstractSkyEntity {
+    private _descriptor;
+    private _healpixGrid;
+    private _shaderProgram;
+    private _tiles;
+    private _currentOrder;
+    private _visibleTiles;
+    private _coverageTiles;
+    constructor(radius: number, position: [number, number, number], xrad: number, yrad: number, _descriptor: MeshHiPSDescriptor, webgl: WebGL2RenderingContext, _healpixGrid: HealpixGrid);
+    get currentOrder(): number;
+    get maxOrder(): number;
+    get minOrder(): number;
+    get baseURL(): string;
+    get propertiesRawText(): string;
+    get properties(): ReadonlyMap<string, string>;
+    getProperty(key: string): string | undefined;
+    refreshOrder(fovDeg: number | undefined): number;
+    draw(input: SkyEntityDrawInput): void;
+    getDebugStats(): MeshHiPSDebugStats;
+    private resolveVisibleTiles;
+    private resolveCoverageTiles;
+    private groupTilesByOrder;
+    private ensureTiles;
+    private evictCached;
+    private tileKey;
+}

package/lib-esm/model/meships/MeshHiPS.js

@@ -0,0 +1,182 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ */
+import { AbstractSkyEntity } from '../AbstractSkyEntity.js';
+import { fovHelper } from '../hips/FoVHelper.js';
+import { MeshHiPSShaderProgram } from '../../shader/MeshHiPSShaderProgram.js';
+import { MeshHiPSTile } from './MeshHiPSTile.js';
+export class MeshHiPS extends AbstractSkyEntity {
+    _descriptor;
+    _healpixGrid;
+    _shaderProgram;
+    _tiles = new Map();
+    _currentOrder;
+    _visibleTiles = [];
+    _coverageTiles = [];
+    constructor(radius, position, xrad, yrad, _descriptor, webgl, _healpixGrid) {
+        super(radius, position, xrad, yrad, _descriptor.name, webgl, false);
+        this._descriptor = _descriptor;
+        this._healpixGrid = _healpixGrid;
+        this.initGL(webgl);
+        this._shaderProgram = new MeshHiPSShaderProgram(webgl);
+        this._shaderProgram.enableProgram();
+        this._currentOrder = _descriptor.selectedOrder;
+    }
+    get currentOrder() {
+        return this._currentOrder;
+    }
+    get maxOrder() {
+        return this._descriptor.maxOrder;
+    }
+    get minOrder() {
+        return this._descriptor.minOrder;
+    }
+    get baseURL() {
+        return this._descriptor.baseUrl;
+    }
+    get propertiesRawText() {
+        return this._descriptor.propertiesRawText;
+    }
+    get properties() {
+        return this._descriptor.properties;
+    }
+    getProperty(key) {
+        return this._descriptor.getProperty(key);
+    }
+    refreshOrder(fovDeg) {
+        if (this._descriptor.fixedOrder) {
+            this._currentOrder = this._descriptor.selectedOrder;
+            return this._currentOrder;
+        }
+        const fov = Number.isFinite(fovDeg) && fovDeg > 0
+            ? fovDeg
+            : this._healpixGrid.getMinFoV();
+        const safeFov = Number.isFinite(fov) && fov > 0 ? fov : 1e-6;
+        const order = fovHelper.getHiPSNorder(safeFov, this._currentOrder);
+        this._currentOrder = Math.max(this._descriptor.minOrder, Math.min(this._descriptor.maxOrder, order));
+        return this._currentOrder;
+    }
+    draw(input) {
+        const vMatrix = input.camera.getCameraMatrix();
+        if (!vMatrix || !input.pMatrix)
+            return;
+        this.refreshOrder(input.fovDeg);
+        this._visibleTiles = this.resolveVisibleTiles();
+        this._coverageTiles = this.resolveCoverageTiles(this._visibleTiles);
+        this.ensureTiles(this._coverageTiles);
+        this.evictCached();
+        const gl = this._webgl;
+        const pMatrix = input.pMatrix;
+        const mMatrix = this.getModelMatrix();
+        const wasCullFace = gl.isEnabled(gl.CULL_FACE);
+        const wasDepthTest = gl.isEnabled(gl.DEPTH_TEST);
+        const wasDepthMask = gl.getParameter(gl.DEPTH_WRITEMASK);
+        const previousDepthFunc = gl.getParameter(gl.DEPTH_FUNC);
+        gl.enable(gl.DEPTH_TEST);
+        gl.depthMask(true);
+        gl.depthFunc(gl.LEQUAL);
+        gl.disable(gl.CULL_FACE);
+        const byOrder = this.groupTilesByOrder(this._coverageTiles);
+        const orders = Array.from(byOrder.keys()).sort((a, b) => a - b);
+        for (const order of orders) {
+            for (const coord of byOrder.get(order) ?? []) {
+                this._tiles.get(this.tileKey(coord))?.draw(pMatrix, vMatrix, mMatrix, this._descriptor.color, this._descriptor.wireframe);
+            }
+        }
+        if (wasCullFace)
+            gl.enable(gl.CULL_FACE);
+        if (!wasDepthTest)
+            gl.disable(gl.DEPTH_TEST);
+        gl.depthFunc(previousDepthFunc);
+        gl.depthMask(wasDepthMask);
+    }
+    getDebugStats() {
+        const tiles = Array.from(this._tiles.values());
+        return {
+            activeBaseLayer: 'meships',
+            meshHiPSName: this._descriptor.name,
+            meshHiPSUrl: this._descriptor.baseUrl,
+            currentOrder: this._currentOrder,
+            visibleTileCount: this._visibleTiles.length,
+            coverageTileCount: this._coverageTiles.length,
+            cacheSize: this._tiles.size,
+            readyTileCount: tiles.filter((tile) => tile.ready).length,
+            loadingTileCount: tiles.filter((tile) => tile.loading).length,
+            failedTileCount: tiles.filter((tile) => tile.failed).length,
+        };
+    }
+    resolveVisibleTiles() {
+        const manager = this._healpixGrid.visibleTilesManager;
+        const byOrder = manager?.visibleTilesByOrder;
+        const pixels = byOrder?.order === this._currentOrder && Array.isArray(byOrder.pixels)
+            ? byOrder.pixels
+            : [];
+        if (pixels.length > 0) {
+            return pixels.map((ipix) => ({ order: this._currentOrder, ipix }));
+        }
+        const tileCount = 12 * 4 ** this._currentOrder;
+        return Array.from({ length: tileCount }, (_, ipix) => ({ order: this._currentOrder, ipix }));
+    }
+    resolveCoverageTiles(visibleTiles) {
+        const tiles = new Map();
+        const add = (coord) => {
+            if (coord.order < this._descriptor.minOrder || coord.order > this._descriptor.maxOrder)
+                return;
+            tiles.set(this.tileKey(coord), coord);
+        };
+        for (const coord of visibleTiles) {
+            add(coord);
+            for (let order = coord.order - 1; order >= this._descriptor.minOrder; order--) {
+                const shift = 2 * (coord.order - order);
+                add({ order, ipix: coord.ipix >> shift });
+            }
+        }
+        const manager = this._healpixGrid.visibleTilesManager;
+        const ancestorsMap = manager?.ancestorsMap;
+        if (ancestorsMap) {
+            for (const [order, ipixes] of ancestorsMap) {
+                if (order < this._descriptor.minOrder || order > this._descriptor.maxOrder)
+                    continue;
+                for (const ipix of ipixes)
+                    add({ order, ipix });
+            }
+        }
+        return Array.from(tiles.values());
+    }
+    groupTilesByOrder(coords) {
+        const byOrder = new Map();
+        for (const coord of coords) {
+            const list = byOrder.get(coord.order) ?? [];
+            list.push(coord);
+            byOrder.set(coord.order, list);
+        }
+        return byOrder;
+    }
+    ensureTiles(coords) {
+        for (const coord of coords) {
+            const key = this.tileKey(coord);
+            if (this._tiles.has(key))
+                continue;
+            this._tiles.set(key, new MeshHiPSTile(coord, this._descriptor.getTileUrl(coord.order, coord.ipix), this._webgl, this._shaderProgram));
+        }
+    }
+    evictCached() {
+        const maxCached = this._descriptor.maxCachedTiles;
+        if (this._tiles.size <= maxCached)
+            return;
+        const visibleKeys = new Set(this._coverageTiles.map((coord) => this.tileKey(coord)));
+        const evictable = Array.from(this._tiles.entries())
+            .filter(([key]) => !visibleKeys.has(key))
+            .sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
+        while (this._tiles.size > maxCached && evictable.length > 0) {
+            const [key, tile] = evictable.shift();
+            tile.dispose();
+            this._tiles.delete(key);
+        }
+    }
+    tileKey(coord) {
+        return `${coord.order}/${coord.ipix}`;
+    }
+}

package/lib-esm/model/meships/MeshHiPSDescriptor.d.ts

@@ -0,0 +1,34 @@
+import type { MeshHiPSConfig } from './MeshHiPSTypes.js';
+export declare class MeshHiPSDescriptor {
+    private _name;
+    private _baseUrl;
+    private _minOrder;
+    private _maxOrder;
+    private _selectedOrder;
+    private _fixedOrder;
+    private _maxCachedTiles;
+    private _color;
+    private _wireframe;
+    private _propertiesRawText;
+    private _propertiesMap;
+    private _meshRadius;
+    constructor(config: MeshHiPSConfig, propertiesText?: string);
+    get name(): string;
+    get baseUrl(): string;
+    get minOrder(): number;
+    get maxOrder(): number;
+    get selectedOrder(): number;
+    get fixedOrder(): boolean;
+    get maxCachedTiles(): number;
+    get color(): [number, number, number, number];
+    get wireframe(): boolean;
+    get propertiesRawText(): string;
+    get properties(): ReadonlyMap<string, string>;
+    get meshRadius(): number;
+    getProperty(key: string): string | undefined;
+    getTileUrl(order: number, ipix: number): string;
+    private parseProperties;
+    private readNumber;
+    private clampOrder;
+    private normalizeBaseUrl;
+}

package/lib-esm/model/meships/MeshHiPSDescriptor.js

@@ -0,0 +1,132 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ */
+export class MeshHiPSDescriptor {
+    _name = 'MeshHiPS';
+    _baseUrl;
+    _minOrder = 0;
+    _maxOrder = 0;
+    _selectedOrder;
+    _fixedOrder = false;
+    _maxCachedTiles = 384;
+    // default neutral color (contrasts with page background)
+    _color = [0.32, 0.34, 0.36, 1.0];
+    _wireframe = false;
+    _propertiesRawText = '';
+    _propertiesMap = new Map();
+    _meshRadius = null;
+    constructor(config, propertiesText = '') {
+        this._baseUrl = this.normalizeBaseUrl(config.baseUrl);
+        this._propertiesRawText = propertiesText;
+        this.parseProperties(propertiesText);
+        this._name = config.name ?? this._propertiesMap.get('obs_collection') ?? this._propertiesMap.get('label') ?? this._name;
+        this._minOrder = config.minOrder ?? this.readNumber('hips_order_min', this._minOrder);
+        this._maxOrder = config.maxOrder ?? this.readNumber('hips_order', this.readNumber('hips_order_max', this._maxOrder));
+        this._fixedOrder = config.order !== undefined;
+        this._selectedOrder = config.order ?? this._minOrder;
+        this._maxCachedTiles = config.maxCachedTiles ?? this._maxCachedTiles;
+        // color: prefer explicit config, then properties.mesh_color, then default
+        if (config.color) {
+            this._color = config.color;
+        }
+        else if (this._propertiesMap.has('mesh_color')) {
+            const raw = this._propertiesMap.get('mesh_color') || '';
+            const parts = raw.split(/[,\s]+/).map((v) => Number(v)).filter(Number.isFinite);
+            if (parts.length >= 3) {
+                let [r, g, b, a] = parts;
+                if (r > 1 || g > 1 || b > 1) {
+                    // assume 0-255 range
+                    r = r / 255;
+                    g = g / 255;
+                    b = b / 255;
+                }
+                if (!Number.isFinite(a))
+                    a = 1;
+                this._color = [r, g, b, a];
+            }
+        }
+        else {
+            this._color = this._color;
+        }
+        this._wireframe = config.wireframe ?? this._wireframe;
+        this._selectedOrder = this.clampOrder(this._selectedOrder);
+        // mesh radius: prefer explicit value from config, otherwise read mandatory property
+        if (Number.isFinite(config.meshRadius)) {
+            this._meshRadius = config.meshRadius;
+        }
+        else {
+            const radiusFromProps = this.readNumber('mesh_radius', NaN);
+            if (!Number.isFinite(radiusFromProps)) {
+                throw new Error('Missing mandatory property "mesh_radius" in MeshHiPS properties');
+            }
+            this._meshRadius = radiusFromProps;
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    get baseUrl() {
+        return this._baseUrl;
+    }
+    get minOrder() {
+        return this._minOrder;
+    }
+    get maxOrder() {
+        return this._maxOrder;
+    }
+    get selectedOrder() {
+        return this._selectedOrder;
+    }
+    get fixedOrder() {
+        return this._fixedOrder;
+    }
+    get maxCachedTiles() {
+        return this._maxCachedTiles;
+    }
+    get color() {
+        return this._color;
+    }
+    get wireframe() {
+        return this._wireframe;
+    }
+    get propertiesRawText() {
+        return this._propertiesRawText;
+    }
+    get properties() {
+        return new Map(this._propertiesMap);
+    }
+    get meshRadius() {
+        return this._meshRadius;
+    }
+    getProperty(key) {
+        return this._propertiesMap.get(key);
+    }
+    getTileUrl(order, ipix) {
+        const dir = Math.floor(ipix / 10_000) * 10_000;
+        return `${this._baseUrl}Norder${order}/Dir${dir}/Npix${ipix}.obj`;
+    }
+    parseProperties(propertiesText) {
+        const lines = propertiesText.split(/\r\n|\n/);
+        for (const raw of lines) {
+            const line = raw.trim();
+            if (!line || line.startsWith('#'))
+                continue;
+            const idx = line.indexOf('=');
+            if (idx < 0)
+                continue;
+            this._propertiesMap.set(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+        }
+    }
+    readNumber(key, fallback) {
+        const parsed = Number(this._propertiesMap.get(key));
+        return Number.isFinite(parsed) ? parsed : fallback;
+    }
+    clampOrder(order) {
+        return Math.max(this._minOrder, Math.min(this._maxOrder, order));
+    }
+    normalizeBaseUrl(baseUrl) {
+        return baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+    }
+}

package/lib-esm/model/meships/MeshHiPSTile.d.ts

@@ -0,0 +1,29 @@
+import { MeshHiPSShaderProgram } from '../../shader/MeshHiPSShaderProgram.js';
+import type { MeshHiPSTileCoord } from './MeshHiPSTypes.js';
+type Mat4 = Float32Array;
+export declare class MeshHiPSTile {
+    readonly coord: MeshHiPSTileCoord;
+    private _url;
+    private _webgl;
+    private _shaderProgram;
+    private _gpuMesh;
+    private _ready;
+    private _loading;
+    private _failed;
+    private _lastUsedAt;
+    private _createdAt;
+    constructor(coord: MeshHiPSTileCoord, _url: string, _webgl: WebGL2RenderingContext, _shaderProgram: MeshHiPSShaderProgram);
+    get ready(): boolean;
+    get loading(): boolean;
+    get failed(): boolean;
+    get lastUsedAt(): number;
+    get createdAt(): number;
+    touch(): void;
+    draw(pMatrix: Mat4, vMatrix: Mat4, mMatrix: Mat4, color: [number, number, number, number], wireframe: boolean): boolean;
+    dispose(): void;
+    private load;
+    private uploadMesh;
+    private buildLineIndices;
+    private get key();
+}
+export {};