astro-viewer 3.12.0 → 3.13.0

package/dist/astroviewer.cjs

@@ -3657,6 +3657,7 @@ class AstroSphere {
     lockedNorthSouthDecDeg = null;
     keepCameraNorthUp = true;
     gridLabelContainers;
+    fovAnimationResolve = null;
     constructor(canvas, webgl, options = {}) {
         console.log("[AstroSphere] new instance for canvas", canvas.id);
         // Keep global GL context (as in original JS)
@@ -3901,6 +3902,7 @@ class AstroSphere {
             canvas.setPointerCapture(event.pointerId);
             this.mouseDown = true;
             this._camera.cancelFlyTo();
+            this.cancelFoVAnimation();
             const rect = canvas.getBoundingClientRect();
             this.lastMouseX = event.clientX - rect.left; // locale al canvas
             this.lastMouseY = event.clientY - rect.top; // locale al canvas
@@ -4031,6 +4033,7 @@ class AstroSphere {
             const currentFov = this._healpixGrid.getMinFoV();
             const zoomStep = this.computeZoomStep(currentFov, event.deltaY);
             this._camera.cancelFlyTo();
+            this.cancelFoVAnimation();
             // Apply wheel zoom immediately and discard any queued inertia so reversing
             // direction feels responsive instead of "buffered".
             this.zoomInertia = 0;
@@ -4488,25 +4491,128 @@ class AstroSphere {
             throw new Error(`healpixGrid is ${this.healpixGrid}`);
         return FoVUtils_js_1.FoVUtils.getFoVPolygon(this._camera, this.canvas, this._healpixGrid, this._healpixGrid, this._webgl, this._perspectiveMatrixManager.pMatrix);
     }
-    changeFoV(deg) {
-        const distance = this._healpixGrid.getFoV().computeDistanceFromAngle(deg);
-        this._camera.translate(distance);
+    validateFoV(deg) {
+        if (!Number.isFinite(deg) || deg <= 0 || deg >= 180) {
+            throw new RangeError(`FoV must be > 0 and < 180 degrees. Received ${deg}.`);
+        }
+        if (Global_js_1.default.insideSphere) {
+            throw new Error("FoV navigation is currently supported only outside the sphere.");
+        }
+    }
+    /**
+     * Resolve the radial camera distance that produces the requested minimum FoV.
+     *
+     * The search temporarily samples radial distances, then restores the original
+     * camera distance before returning. Callers can therefore either apply the
+     * result immediately or animate toward it.
+     */
+    findRadialDistanceForFoV(deg) {
+        this.validateFoV(deg);
+        const originalDistance = this._camera.getRadialDistance();
+        const minDistance = 1.000001;
+        const maxDistance = 4.0;
+        const tolerance = Math.max(1e-5, deg * 0.001);
+        const maxIterations = 40;
+        let low = minDistance;
+        let high = maxDistance;
+        let bestDistance = originalDistance;
+        let bestError = Number.POSITIVE_INFINITY;
+        for (let iteration = 0; iteration < maxIterations; iteration += 1) {
+            const candidateDistance = (low + high) / 2;
+            this._camera.setRadialDistance(candidateDistance);
+            this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, Global_js_1.default.insideSphere);
+            const candidateFoV = this._healpixGrid.refreshFoV(this._camera, this._perspectiveMatrixManager.pMatrix);
+            const measuredFoV = candidateFoV.minFoV;
+            const error = Math.abs(measuredFoV - deg);
+            if (error < bestError) {
+                bestError = error;
+                bestDistance = candidateDistance;
+            }
+            if (error <= tolerance) {
+                break;
+            }
+            if (measuredFoV >= deg || measuredFoV >= 179.999) {
+                high = candidateDistance;
+            }
+            else {
+                low = candidateDistance;
+            }
+        }
+        this._camera.setRadialDistance(originalDistance);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, Global_js_1.default.insideSphere);
         this.fov = this._healpixGrid.refreshFoV(this._camera, this._perspectiveMatrixManager.pMatrix);
         this._camera.refreshFoV(this.fov.minFoV);
+        return bestDistance;
+    }
+    finishFoVAnimation() {
+        const resolve = this.fovAnimationResolve;
+        this.fovAnimationResolve = null;
+        resolve?.();
+    }
+    cancelFoVAnimation() {
+        this._camera.cancelRadialAnimation();
+        this.finishFoVAnimation();
+    }
+    /** Set the minimum angular field of view immediately, in degrees. */
+    setFoV(deg) {
+        this.validateFoV(deg);
+        this.cancelFoVAnimation();
+        this._camera.cancelFlyTo();
+        this.zoomInertia = 0;
+        const targetDistance = this.findRadialDistanceForFoV(deg);
+        this._camera.setRadialDistance(targetDistance);
+        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, Global_js_1.default.insideSphere);
+        this.fov = this._healpixGrid.refreshFoV(this._camera, this._perspectiveMatrixManager.pMatrix);
+        this._camera.refreshFoV(this.fov.minFoV);
+        this.lastCameraMotionAt = performance.now();
+        this._cameraStatusChanged = true;
+        this.emitCameraChanged("set-fov");
     }
+    async flyToFoV(deg, durationMs = 1200) {
+        this.validateFoV(deg);
+        if (!Number.isFinite(durationMs) || durationMs < 0) {
+            throw new RangeError(`FoV animation duration must be >= 0 ms. Received ${durationMs}.`);
+        }
+        if (durationMs === 0) {
+            this.setFoV(deg);
+            return;
+        }
+        this.cancelFoVAnimation();
+        this.zoomInertia = 0;
+        const targetDistance = this.findRadialDistanceForFoV(deg);
+        this._camera.flyToRadialDistance(targetDistance, durationMs);
+        this.lastCameraMotionAt = performance.now();
+        this._cameraStatusChanged = true;
+        return new Promise((resolve) => {
+            this.fovAnimationResolve = resolve;
+        });
+    }
+    async zoomIn(steps = 1, durationMs = 500) {
+        this.validateZoomSteps(steps);
+        const targetFoV = this.getFoV().minFoV / Math.pow(2, steps);
+        return this.flyToFoV(targetFoV, durationMs);
+    }
+    async zoomOut(steps = 1, durationMs = 500) {
+        this.validateZoomSteps(steps);
+        const targetFoV = this.getFoV().minFoV * Math.pow(2, steps);
+        return this.flyToFoV(targetFoV, durationMs);
+    }
+    validateZoomSteps(steps) {
+        if (!Number.isInteger(steps) || steps < 1) {
+            throw new RangeError(`Zoom steps must be a positive integer. Received ${steps}.`);
+        }
+    }
+    /** @deprecated Use setFoV(). */
+    changeFoV(deg) {
+        this.setFoV(deg);
+    }
+    /** @deprecated Use setFoV(). */
     changeFoV2(deg) {
-        const newCameraPos = this._healpixGrid
-            .getFoV()
-            .computeCameraPositionForFoV(deg);
-        this._camera.setCameraPosition(newCameraPos);
+        this.setFoV(deg);
     }
+    /** @deprecated Use setFoV(). */
     changeFoV3(deg) {
-        const newPos = this._healpixGrid
-            .getFoV()
-            .computeCameraPositionForAngularDiameter(deg);
-        this._camera.setCameraPosition(newPos);
-        // Recompute projection after moving the camera
-        this._perspectiveMatrixManager.computePerspectiveMatrix(this.canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, false);
+        this.setFoV(deg);
     }
     getInsideSphere() {
         return Global_js_1.default.insideSphere;
@@ -4516,6 +4622,7 @@ class AstroSphere {
         this.inertiaX = 0;
         this.inertiaY = 0;
         this.zoomInertia = 0;
+        this.cancelFoVAnimation();
         Global_js_1.default.insideSphere = !Global_js_1.default.insideSphere;
         // console.log(global.insideSphere)
         this._camera.toggleInsideSphere();
@@ -4691,6 +4798,14 @@ class AstroSphere {
             this.updateCentralPoint();
             this._perspectiveMatrixManager.computePerspectiveMatrix(canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, Global_js_1.default.insideSphere);
         }
+        const fovFlying = this._camera.updateRadialAnimation(now);
+        const fovAnimationFinished = fovFlying && !this._camera.isRadialAnimationActive();
+        if (fovFlying) {
+            this.zoomInertia = 0;
+            this.lastCameraMotionAt = now;
+            this._cameraStatusChanged = true;
+            this._perspectiveMatrixManager.computePerspectiveMatrix(canvas, this._camera, Config_js_1.bootSetup.camera_fov_deg, Config_js_1.bootSetup.camera_near_plane, Global_js_1.default.insideSphere);
+        }
         // Zoom inertia
         if (this.zoomInertia !== 0) {
             if (Math.abs(this.zoomInertia) > 0.0001) {
@@ -4739,6 +4854,9 @@ class AstroSphere {
             this._camera.refreshFoV(this.fov.minFoV);
             this.prevFov = this.fov.minFoV;
         }
+        if (fovAnimationFinished) {
+            this.finishFoVAnimation();
+        }
         // Se la camera è ruotata (anche solo per inerzia), aggiorna punto centrale + emetti cameraChanged
         if (cameraRotated) {
             // Ricalcola il punto centrale
@@ -4780,6 +4898,10 @@ class AstroSphere {
         this._webgl.cullFace(Global_js_1.default.insideSphere ? this._webgl.FRONT : this._webgl.BACK);
         this._webgl.blendFunc(this._webgl.SRC_ALPHA, this._webgl.ONE_MINUS_SRC_ALPHA);
         if (this._activeBaseLayer === "hips" && this._activeHiPS) {
+            // During directional flyTo navigation, keep visibility current but render
+            // only HiPS tiles that are already available. Final-view refinement
+            // resumes automatically on the first frame after the flight.
+            this._healpixGrid.visibleTilesManager.tileBuffer.setTileAcquisitionEnabled(!cameraFlying);
             const maxHiPSOrder = this._activeHiPSLayers.length > 0
                 ? Math.max(...this._activeHiPSLayers.map((hips) => hips.maxOrder))
                 : this._activeHiPS.maxOrder;
@@ -4797,6 +4919,7 @@ class AstroSphere {
             Math.abs(this.zoomInertia) > 0.0001 ||
             Math.abs(this.inertiaX) > 0.02 ||
             Math.abs(this.inertiaY) > 0.02 ||
+            this._camera.isRadialAnimationActive() ||
             nowForGrid - this.lastCameraMotionAt < 220;
         const skyEntityDrawInput = {
             fovDeg: stableFovDeg,
@@ -5331,14 +5454,29 @@ class AstroViewer {
     getFoVPolygon() {
         return this.astroSphere.getFoVPolygon();
     }
+    setFoV(deg) {
+        this.astroSphere.setFoV(deg);
+    }
+    flyToFoV(deg, durationMs = 1200) {
+        return this.astroSphere.flyToFoV(deg, durationMs);
+    }
+    zoomIn(steps = 1, durationMs = 500) {
+        return this.astroSphere.zoomIn(steps, durationMs);
+    }
+    zoomOut(steps = 1, durationMs = 500) {
+        return this.astroSphere.zoomOut(steps, durationMs);
+    }
+    /** @deprecated Use setFoV(). */
     changeFoV(deg) {
-        (this, this.astroSphere.changeFoV(deg));
+        this.setFoV(deg);
     }
+    /** @deprecated Use setFoV(). */
     changeFoV2(deg) {
-        (this, this.astroSphere.changeFoV2(deg));
+        this.setFoV(deg);
     }
+    /** @deprecated Use setFoV(). */
     changeFoV3(deg) {
-        (this, this.astroSphere.changeFoV3(deg));
+        this.setFoV(deg);
     }
     getInsideSphere() {
         return this.astroSphere.getInsideSphere();
@@ -5590,6 +5728,7 @@ class Camera {
     lockRotY = false;
     lockRotZ = false;
     flyToAnimation = null;
+    radialAnimation = null;
     constructor(in_position, in_sphere) {
         this.init(in_position, in_sphere);
     }
@@ -5724,6 +5863,42 @@ class Camera {
     cancelFlyTo() {
         this.flyToAnimation = null;
     }
+    flyToRadialDistance(distance, durationMs = 1200) {
+        if (!Number.isFinite(distance) || distance <= 1) {
+            throw new RangeError(`Camera radial distance must be > 1. Received ${distance}.`);
+        }
+        this.radialAnimation = {
+            startDistance: this.cam_pos[2],
+            targetDistance: distance,
+            startTime: performance.now(),
+            durationMs: Math.max(1, durationMs),
+        };
+    }
+    updateRadialAnimation(now) {
+        const animation = this.radialAnimation;
+        if (!animation) {
+            return false;
+        }
+        const elapsed = now - animation.startTime;
+        const progress = Math.min(1, elapsed / animation.durationMs);
+        const easedProgress = progress < 0.5
+            ? 4 * progress * progress * progress
+            : 1 - Math.pow(-2 * progress + 2, 3) / 2;
+        const distance = animation.startDistance +
+            (animation.targetDistance - animation.startDistance) * easedProgress;
+        this.setRadialDistance(distance);
+        if (progress >= 1) {
+            this.setRadialDistance(animation.targetDistance);
+            this.radialAnimation = null;
+        }
+        return true;
+    }
+    isRadialAnimationActive() {
+        return this.radialAnimation !== null;
+    }
+    cancelRadialAnimation() {
+        this.radialAnimation = null;
+    }
     toggleInsideSphere() {
         // if (inside !== global.insideSphere) {
         //   global.insideSphere = inside;
@@ -5973,6 +6148,24 @@ class Camera {
         // Recompute view: vMatrix = inv(T) * inv(R)
         this.refreshViewMatrix();
     }
+    /**
+     * Set the radial camera distance while preserving the current pointing.
+     *
+     * Outside-sphere navigation stores the camera radius in cam_pos[2];
+     * changing only that component is the same radial motion used by zoom(),
+     * without changing the current rotation matrix.
+     */
+    setRadialDistance(distance) {
+        if (!Number.isFinite(distance) || distance <= 1) {
+            throw new RangeError(`Camera radial distance must be > 1. Received ${distance}.`);
+        }
+        this.cam_pos[2] = distance;
+        gl_matrix_1.mat4.translate(this.T, gl_matrix_1.mat4.create(), this.cam_pos);
+        this.refreshViewMatrix();
+    }
+    getRadialDistance() {
+        return this.cam_pos[2];
+    }
     getCameraAngle() {
         const [x, y, z] = this.getCameraPosition();
         const posVec = gl_matrix_1.vec3.fromValues(x, y, z);
@@ -12961,8 +13154,10 @@ class AllSky {
                 continue;
             }
             const childTile = this._isGalacticHips
-                ? this._tileBuffer.getGalTile(tileno, childrenOrder, this._hips)
-                : this._tileBuffer.getTile(tileno, childrenOrder, this._hips);
+                ? this._tileBuffer.getRenderableGalTile(tileno, childrenOrder, this._hips)
+                : this._tileBuffer.getRenderableTile(tileno, childrenOrder, this._hips);
+            if (!childTile)
+                continue;
             childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, this._hipsShaderProgram);
             if (childTile.getReadyState()) {
                 allSkyTiles2Skip.push(tileno);
@@ -13250,8 +13445,10 @@ class AncestorTile {
                     continue;
                 }
                 const childTile = this._isGalacticHips
-                    ? this._tileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
-                    : this._tileBuffer.getTile(childTileNo, childrenOrder, this._hips);
+                    ? this._tileBuffer.getRenderableGalTile(childTileNo, childrenOrder, this._hips)
+                    : this._tileBuffer.getRenderableTile(childTileNo, childrenOrder, this._hips);
+                if (!childTile)
+                    continue;
                 childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, this._hipsShaderProgram);
                 if (childTile.getReadyState()) {
                     quadrantsToDraw.delete(c);
@@ -14769,8 +14966,10 @@ class Tile {
                     continue;
                 }
                 const childTile = this._isGalacticHips
-                    ? this._tileBuffer.getGalTile(childTileNo, childrenOrder, this._hips)
-                    : this._tileBuffer.getTile(childTileNo, childrenOrder, this._hips);
+                    ? this._tileBuffer.getRenderableGalTile(childTileNo, childrenOrder, this._hips)
+                    : this._tileBuffer.getRenderableTile(childTileNo, childrenOrder, this._hips);
+                if (!childTile)
+                    continue;
                 childTile.draw(visibleOrder, visibleTilesMap, pMatrix, vMatrix, mMatrix, colorMapIdx, hipsShaderProgram);
                 if (childTile.getReadyState()) {
                     quadrantsToDraw.delete(c);
@@ -14821,6 +15020,7 @@ class TileBuffer {
     _webgl;
     _visibleTileManager;
     _hipsShaderProgram;
+    _tileAcquisitionEnabled = true;
     constructor(minutesToLiveInCache = 1, webgl, hipsShaderProgram, visibleTileManager) {
         this._hipsShaderProgram = hipsShaderProgram;
         this._visibleTileManager = visibleTileManager;
@@ -14852,8 +15052,14 @@ class TileBuffer {
         }
         this._galActiveHiPS.set(hips, new Map());
     }
+    /** Enable or suspend creation of missing HiPS tiles. */
+    setTileAcquisitionEnabled(enabled) {
+        this._tileAcquisitionEnabled = enabled;
+    }
     /** Preload/add tile for every registered equatorial HiPS. */
     addTile(order, tileno) {
+        if (!this._tileAcquisitionEnabled)
+            return;
         for (const hips of this._activeHiPS.keys()) {
             if (order > hips.maxOrder) {
                 continue;
@@ -14866,6 +15072,8 @@ class TileBuffer {
     }
     /** Preload/add tile for every registered galactic HiPS. */
     addGalTile(order, tileno) {
+        if (!this._tileAcquisitionEnabled)
+            return;
         for (const hips of this._galActiveHiPS.keys()) {
             if (order > hips.maxOrder) {
                 continue;
@@ -14912,6 +15120,44 @@ class TileBuffer {
         }
         return this._galTiles.get(tileKey);
     }
+    /**
+     * Return an equatorial tile for rendering. While acquisition is suspended,
+     * only tiles already active or cached are returned; missing tiles are not
+     * created.
+     */
+    getRenderableTile(tileno, order, hips) {
+        if (this._tileAcquisitionEnabled) {
+            return this.getTile(tileno, order, hips);
+        }
+        const tileKey = this.key(order, tileno, hips);
+        const activeTile = this._tiles.get(tileKey);
+        if (activeTile)
+            return activeTile;
+        const cachedTile = this._cachedTiles.get(tileKey);
+        if (!cachedTile)
+            return undefined;
+        this._tiles.set(tileKey, cachedTile);
+        this._cachedTiles.delete(tileKey);
+        cachedTile.resetCacheTime0();
+        return cachedTile;
+    }
+    /** Galactic counterpart of getRenderableTile(). */
+    getRenderableGalTile(tileno, order, hips) {
+        if (this._tileAcquisitionEnabled) {
+            return this.getGalTile(tileno, order, hips);
+        }
+        const tileKey = this.key(order, tileno, hips);
+        const activeTile = this._galTiles.get(tileKey);
+        if (activeTile)
+            return activeTile;
+        const cachedTile = this._galCachedTiles.get(tileKey);
+        if (!cachedTile)
+            return undefined;
+        this._galTiles.set(tileKey, cachedTile);
+        this._galCachedTiles.delete(tileKey);
+        cachedTile.resetCacheTime0();
+        return cachedTile;
+    }
     /** Move a tile (equatorial or galactic) into cache. */
     moveTileToCache(tileno, order, hips) {
         const tileKey = this.key(order, tileno, hips);
@@ -15119,6 +15365,10 @@ class VisibleTilesManager {
         if (Global_js_1.default.insideSphere && order < 3) {
             order = 3;
         }
+        // Visibility state is frame-local. Do not retain ancestors from previous
+        // camera positions, otherwise a flyTo accumulates the whole travelled path.
+        this._ancestorsMap.clear();
+        this._galAncestorsMap.clear();
         this._ancestorsMap.set(order, []);
         this._galAncestorsMap.set(order, []);
         let pixels = [];
@@ -15135,8 +15385,10 @@ class VisibleTilesManager {
         }
         else {
             const geomhealpix = Global_js_1.default.getHealpix(order);
-            const maxX = webgl.canvas.width;
-            const maxY = webgl.canvas.height;
+            const canvas = webgl.canvas;
+            const canvasRect = canvas.getBoundingClientRect();
+            const maxX = canvasRect.width;
+            const maxY = canvasRect.height;
             // Sample a grid of screen points, project to the sphere, then to galactic
             for (let i = 0; i <= maxX; i += maxX / 30) {
                 for (let j = 0; j <= maxY; j += maxY / 30) {