isard 1.8.0 → 1.10.0

package/dist/map.js

@@ -9,17 +9,21 @@ import { SEA } from "./basemap/basemaps.js";
 import { pmtilesLayer } from "./basemap/pmtileslayer.js";
 import { VectorTiles } from "./basemap/vectortiles.js";
 import { defaultWorkerUrl } from "./basemap/workerpool.js";
-import { onHeaderRules } from "./engine/requests.js";
 import { destroyedEngine, engineUrl, gridUrl, loadEngine, tessUrl } from "./engine-loader.js";
 import { IGN_PRESETS } from "./geoplateforme.js";
+import { CustomLayer } from "./layers/custom.js";
 import { ExtrusionLayer, extrusionStyle } from "./layers/extrusions.js";
 import { CircleLayer, circleStyle, FillLayer, fillStyle, LineLayer, lineStyle, } from "./layers/features.js";
 import { FlowLayer } from "./layers/flow.js";
-import { CustomLayer, GroundLayer, ModelLayer, NetworkLayer, RasterLayer, Tiles3dLayer, } from "./layers/layers.js";
+import { GroundLayer } from "./layers/ground.js";
+import { ModelLayer } from "./layers/models.js";
+import { NetworkLayer } from "./layers/network.js";
 import { loadPanoramas } from "./layers/panoramas.js";
 import { addPhoto } from "./layers/photos.js";
 import { PointCloudLayer } from "./layers/pointclouds.js";
+import { RasterLayer } from "./layers/raster.js";
 import { SymbolLayer, symbolStyle } from "./layers/symbols.js";
+import { Tiles3dLayer } from "./layers/tiles3d.js";
 import { addTrees } from "./layers/trees.js";
 import { VectorLayer } from "./layers/vectors.js";
 import { BasemapLayers } from "./map/basemap-layers.js";
@@ -43,7 +47,22 @@ import { atmosphereSettings, rgb, terrainSettings } from "./settings.js";
 import { AttributionControl } from "./ui/controls.js";
 import { Interaction } from "./ui/interaction.js";
 import { easeTo, flyTo } from "./util/animation.js";
+import { RAD } from "./util/geo.js";
+import { clamp } from "./util/math.js";
+import { onHeaderRules } from "./util/requests.js";
 import { sunPosition } from "./util/sun.js";
+/** Where a map of the Earth opens without a camera given: Saint-Mandé, the IGN's home, its streets in view; of another
+ * body, all of it */
+const EARTH_START = { center: [2.4246, 48.8457], zoom: 13, pitch: 0, bearing: 0 };
+const BODY_START = { center: [0, 0], zoom: 2, pitch: 0, bearing: 0 };
+/** The eye's pitch at street level (degrees from straight down): off the vertical, where its heading means nothing */
+const FIRST_PERSON_PITCH = [1, 179];
+/** The eye's field of view at street level (degrees): from a telephoto to a wide angle, the projection still sane */
+const FIRST_PERSON_FOV = [10, 140];
+/** A network's defaults: the values past which it is unreached (half an hour of travel, in seconds), its halo's
+ * opacity at the middle of a line (a glow, not a second line) */
+const NETWORK_MAX = 1800;
+const NETWORK_HALO_OPACITY = 0.11;
 /** A layer whose picked features come back with their properties (lines, circles, fills, extrusions, 3D Tiles…) */
 const hasFeatures = (layer) => 'featureAt' in layer && typeof layer.featureAt === 'function';
 /** A map (see `GeoMap.create`); layers take it as their host */
@@ -153,10 +172,9 @@ export class GeoMap {
         this.unwatchContext = watchContext(this.canvas, () => {
             this.lost = true;
             this.frames.cancel();
+            this.dropLostEngine();
         }, () => this.restore());
-        const start = this.earth
-            ? { center: [2.4246, 48.8457], zoom: 13, pitch: 0, bearing: 0 }
-            : { center: [0, 0], zoom: 2, pitch: 0, bearing: 0 };
+        const start = this.earth ? EARTH_START : BODY_START;
         this.setCamera({ ...start, ...options });
         this.setBasemap(options.basemap ?? (this.earth ? 'osm-positron' : 'none'), options.hillshade ?? 0);
         if (options.sun)
@@ -221,6 +239,20 @@ export class GeoMap {
             });
         }
     }
+    /**
+     * The context is lost: its engine freed at once, the map's calls going to one that does nothing until `restore`
+     * builds the next. The old engine's GPU objects went with the context: deleted now, it is silent (on the context
+     * restored, each one warns); its 3D Tiles downloads stop. Its layers' updates meanwhile (a tile uploaded, labels)
+     * would fail on the lost context, whose limits read 0
+     */
+    dropLostEngine() {
+        this.hoverPick.cancel();
+        const camera = this.getCamera();
+        this.#engine.free();
+        this.#engine = destroyedEngine(camera);
+        // Glyph ranges and icons arriving meanwhile upload to it, not to the freed engine
+        this.atlases.attach(this.#engine);
+    }
     /** After a context loss: a new engine with the same camera, settings and layers (same handles, same order) */
     restore() {
         if (this.gone)
@@ -270,8 +302,8 @@ export class GeoMap {
         }
         const lonLat = [view.lonLat[0], view.lonLat[1]];
         const eye = { height: 1.7, pitch: 90, fov: 75, ...view, lonLat };
-        eye.pitch = Math.max(1, Math.min(179, eye.pitch));
-        eye.fov = Math.max(10, Math.min(140, eye.fov));
+        eye.pitch = clamp(eye.pitch, ...FIRST_PERSON_PITCH);
+        eye.fov = clamp(eye.fov, ...FIRST_PERSON_FOV);
         eye.bearing = ((eye.bearing % 360) + 360) % 360;
         this.#firstPerson = eye;
         this.engine.setFirstPerson(eye.lonLat[0], eye.lonLat[1], eye.height, eye.bearing, eye.pitch, eye.fov);
@@ -343,38 +375,6 @@ export class GeoMap {
         this.listeners.emit(type, event);
     }
     // ── Camera ──
-    /**
-     * The camera's methods together: `get`, `set`, `easeTo`, `flyTo`, `bounds`, `firstPerson` and `setFirstPerson`
-     * (street level), `project`, `unproject`; the same as the map's own (`getCamera`, `setCamera`…)
-     */
-    camera = {
-        get: () => this.getCamera(),
-        set: (camera) => this.setCamera(camera),
-        easeTo: (camera, options) => this.easeTo(camera, options),
-        flyTo: (camera, options) => this.flyTo(camera, options),
-        bounds: () => this.getBounds(),
-        firstPerson: () => this.firstPerson,
-        setFirstPerson: (view) => this.setFirstPerson(view),
-        project: (lonLat, height) => this.project(lonLat, height),
-        unproject: (point) => this.unproject(point),
-    };
-    /**
-     * What lies under a point or at a position, together: `feature` (`pickFeature`), `surface` (`pickSurface`),
-     * `surfaceAt`, `elevationAt`, `metersPerPixel`
-     */
-    query = {
-        feature: (point, options) => this.pickFeature(point, options),
-        surface: (point) => this.pickSurface(point),
-        surfaceAt: (lonLat) => this.surfaceAt(lonLat),
-        elevationAt: (lonLat) => this.elevationAt(lonLat),
-        metersPerPixel: (point) => this.metersPerPixel(point),
-    };
-    /** What is drawn over the scene, together: `viewshed` (`setViewshed`), `sun` (`setSun`), `swipe` (`setSwipe`) */
-    effects = {
-        viewshed: (options) => this.setViewshed(options),
-        sun: (options) => this.setSun(options),
-        swipe: (options) => this.setSwipe(options),
-    };
     getCamera() {
         return this.frames.camera ?? this.engine.camera();
     }
@@ -524,7 +524,7 @@ export class GeoMap {
      * offscreen picking pass, whatever the number of features, but waits for the GPU to finish the frame (a stall): for
      * clicks and one-off queries. On hover, listen to 'hoverfeature' instead, which picks without waiting.
      */
-    pick(point, radius = 0, layers) {
+    pick(point, { radius = 0, layers } = {}) {
         const only = layers && Uint32Array.from(layers.map((l) => l.id));
         return this.engine.pick(point[0], point[1], radius, only);
     }
@@ -534,7 +534,7 @@ export class GeoMap {
      * search to some layers (the others hide nothing).
      */
     pickFeature(point, options = {}) {
-        const hit = this.pick(point, options.radius ?? 0, options.layers);
+        const hit = this.pick(point, options);
         return hit && this.featureHit(hit);
     }
     /** A hit with its layer handle and feature; undefined if the layer is gone */
@@ -569,6 +569,9 @@ export class GeoMap {
         const host = panoramaHost(this, (lon, lat) => this.engines.geoidHeight(lon, lat));
         const panoramas = await loadPanoramas(host, options);
         this.panoramaSets.add(panoramas);
+        panoramas.whenRemoved.push(() => {
+            this.panoramaSets.delete(panoramas);
+        });
         return panoramas;
     }
     /** The panorama sets, their panorama shown again in a new engine */
@@ -587,9 +590,8 @@ export class GeoMap {
         if (!a || !b)
             return undefined;
         // Haversine, on the mean radius of the body
-        const rad = Math.PI / 180;
-        const [dLat, dLon] = [(b[1] - a[1]) * rad, (b[0] - a[0]) * rad];
-        const h = Math.sin(dLat / 2) ** 2 + Math.cos(a[1] * rad) * Math.cos(b[1] * rad) * Math.sin(dLon / 2) ** 2;
+        const [dLat, dLon] = [(b[1] - a[1]) * RAD, (b[0] - a[0]) * RAD];
+        const h = Math.sin(dLat / 2) ** 2 + Math.cos(a[1] * RAD) * Math.cos(b[1] * RAD) * Math.sin(dLon / 2) ** 2;
         return 2 * this.settings.body.radius * Math.asin(Math.min(1, Math.sqrt(h)));
     }
     /** Whether a double click zooms in (Shift: out), on by default: off while a drawing takes double clicks */
@@ -597,6 +599,12 @@ export class GeoMap {
         if (this.interaction)
             this.interaction.doubleClickZoom = enabled;
     }
+    /** Whether a drag that turns and tilts the map (right button, Ctrl or Shift) goes around what is under the pointer
+     * where it starts, a roof or a mesh as the relief (on by default), or around the screen center */
+    setRotateAroundPointer(enabled) {
+        if (this.interaction)
+            this.interaction.rotateAroundPointer = enabled;
+    }
     /** What is drawn under a screen point (CSS pixels), on the relief or standing on it (a roof, a wall, a mesh): its
      * position and its height above the relief, in metres; undefined where nothing was drawn. The last frame's scene is
      * drawn again and read back, waiting for the GPU (a stall): for clicks and drags */
@@ -662,16 +670,16 @@ export class GeoMap {
      * `url` with or without `pmtiles://`, relative to the page, or a `blob:` URL. `addRaster({ url: 'pmtiles://…' })` and
      * a style source `pmtiles://…` in `vectorTiles` read archives too
      */
-    addPmtiles(url, options = {}) {
-        return pmtilesLayer(this, url, options);
+    addPmtiles(options) {
+        return pmtilesLayer(this, options);
     }
     /** Line network colored by a value per node; `layer.setValues` recolors it in one texture upload */
     addNetwork(options) {
-        const { nodes, edges, lines, costs, edgeWidths, width = 2, max = 1800, contour = 0, opacity = 1 } = options;
-        const { halo = 0, haloOpacity = 0.11, ramp, unreachedColor = 'rgba(140, 140, 140, 0.25)', fade = 0 } = options;
+        const { nodes, edges, lines, costs, edgeWidths, width = 2, max = NETWORK_MAX, contour = 0, opacity = 1 } = options;
+        const { halo = 0, haloOpacity = NETWORK_HALO_OPACITY, ramp, unreachedColor = 'rgba(140, 140, 140, 0.25)', fade = 0, } = options;
         const style = { width, max, contour, opacity, halo, haloOpacity, ramp, unreachedColor, fade };
         validateNetwork(nodes, edges);
-        return this.addLayer(new NetworkLayer(this, { nodes, edges, lines }, costs, style, edgeWidths));
+        return this.place(new NetworkLayer(this, { nodes, edges, lines }, costs, style, edgeWidths), options.before);
     }
     /**
      * A layer from its description, as an application's configuration gives it: `{ type, ...options }`, the options of
@@ -803,13 +811,13 @@ export class GeoMap {
     }
     /** Textured meshes in 3D Tiles (photogrammetry, buildings), drawn with depth over the basemap */
     addTiles3d(options) {
-        const { url, maxScreenSpaceError = 16, opacity = 1, pointSize, color, geoid = false } = options;
-        return this.addLayer(new Tiles3dLayer(this, url, geoid, {
+        const { url, maxScreenSpaceError = 16, opacity = 1, pointSize, color, geoid = false, facades = false } = options;
+        return this.place(new Tiles3dLayer(this, url, geoid, {
             maxScreenSpaceError,
             opacity,
             ...(pointSize !== undefined ? { pointSize } : {}),
             ...(color !== undefined ? { color } : {}),
-        }));
+        }, facades), options.before);
     }
     /**
      * A point cloud (see `PointCloudOptions`): a COPC file read by range requests (IGN's LiDAR HD…), or 3D Tiles
@@ -900,7 +908,7 @@ export class GeoMap {
         this.hoverPick.cancel();
         this.basemaps.destroy();
         [...this.vectorSets].forEach((tiles) => {
-            tiles.destroy();
+            tiles.remove();
         });
         this.vectorSets.clear();
         this.workers.terminate();