isard 1.2.0 → 1.3.0

package/dist/map.d.ts

@@ -5,7 +5,8 @@
  * the camera animations in animation.ts; the parts of the map with a state of their own (the drawing order of the
  * layers, the overlays and controls, the frame loop, the hover picking, the workers…) in map/.
  */
-import { type PmtilesOptions, VectorTiles, type VectorTilesOptions } from './basemap/vectortiles.ts';
+import { type PmtilesOptions } from './basemap/pmtileslayer.ts';
+import { VectorTiles, type VectorTilesOptions } from './basemap/vectortiles.ts';
 import { ExtrusionLayer, type ExtrusionOptions } from './layers/extrusions.ts';
 import { CircleLayer, type CircleOptions, FillLayer, type FillOptions, LineLayer, type LineOptions } from './layers/features.ts';
 import type { ImageOptions, Pixels } from './layers/icons.ts';
@@ -15,7 +16,7 @@ import { PointCloudLayer, type PointCloudOptions } from './layers/pointclouds.ts
 import { SymbolLayer, type SymbolOptions } from './layers/symbols.ts';
 import { type HoverPicking } from './map/hover-pick.ts';
 import { type LayerSpec } from './map/layer-spec.ts';
-import type { AnimationOptions, AtmosphereOptions, Basemap, FeatureHit, FirstPersonView, FlyToOptions, GeoMapOptions, LoadingMode, LonLat, MapEvents, NetworkOptions, Point, Projection, RasterOptions, SwipeOptions, TerrainModel, TerrainOptions, Tiles3dOptions, ViewshedOptions } from './types.ts';
+import type { AnimationOptions, AtmosphereOptions, Basemap, FeatureHit, FirstPersonView, FlyToOptions, GeoMapOptions, LoadingMode, LonLat, MapEvents, NetworkOptions, Point, Projection, RasterOptions, SunOptions, SwipeOptions, TerrainModel, TerrainOptions, Tiles3dOptions, ViewshedOptions } from './types.ts';
 import { type Control, type ControlPosition } from './ui/controls.ts';
 import type { Camera, PickHit, RasterLayerStats } from './wasm/isard.js';
 export type { LayerSpec } from './map/layer-spec.ts';
@@ -95,7 +96,8 @@ export declare class GeoMap {
     /**
      * Compares two states of a place: `layers` shown on one side of a vertical line only, at `position` CSS pixels
      * from the left of the map (left of it by default, `side: 'right'` for the other), the layers beneath them on the
-     * other side. Set again as the line moves (a slider, a drag); undefined stops
+     * other side; `other`: layers shown on the other side only (two meshes of a place, each on its side). Set again as
+     * the line moves (a slider, a drag); undefined stops
      */
     setSwipe(options: SwipeOptions | undefined): void;
     private applySwipe;
@@ -134,9 +136,10 @@ export declare class GeoMap {
         readonly elevationAt: (lonLat: LonLat) => number | undefined;
         readonly metersPerPixel: (point?: Point) => number | undefined;
     };
-    /** What is drawn over the scene, together: `viewshed` (`setViewshed`), `swipe` (`setSwipe`) */
+    /** What is drawn over the scene, together: `viewshed` (`setViewshed`), `sun` (`setSun`), `swipe` (`setSwipe`) */
     readonly effects: {
         readonly viewshed: (options: ViewshedOptions | readonly ViewshedOptions[] | undefined) => void;
+        readonly sun: (options: SunOptions | undefined) => void;
         readonly swipe: (options: SwipeOptions | undefined) => void;
     };
     getCamera(): Camera;
@@ -164,6 +167,18 @@ export declare class GeoMap {
     setSky(enabled: boolean): void;
     /** The viewshed set, set again in a new engine */
     private viewshed;
+    /** The sun set, set again in a new engine */
+    private sun;
+    /**
+     * The sun casting shadows: the buildings, trees, models, 3D Tiles and the relief shade the ground and one another,
+     * the walls turned away from it are in their own shade; the labels stay over them. The sun stands where it is at
+     * `date` over the map's center (now by default), or at `azimuth` and `altitude`. As it sets the night falls (`night`
+     * to set it by hand): the scene tinted in its blue, the windows of the buildings and the streets of `vectors()` lit,
+     * the labels light on dark.
+     * The shadows cover the ground around the view's center, fading out away from it, and cost two more depth passes
+     * of the solid scene each frame. Undefined removes them
+     */
+    setSun(options: SunOptions | undefined): void;
     /** Tints what can be seen from a point and what is hidden from it, within a range, all around or within a cone
      * (`direction`): the relief, extrusions, 3D Tiles and models hide what lies behind them (only what the map has
      * loaded for its view). Several observers (16 at most): what any of them sees is seen, what is hidden from all those
@@ -279,8 +294,8 @@ export declare class GeoMap {
     removeImage(name: string): void;
     /**
      * Vector tiles with a MapLibre style (OpenFreeMap's Positron by default): `tiles.raster(…)` draws its fills and lines
-     * (or a subset) as a raster layer, `tiles.labels(…)` its labels. `setBasemap('osm-positron')` does both for the
-     * basemap.
+     * (or a subset) as a raster layer, `tiles.vectors(…)` as geometry, `tiles.labels(…)` its labels.
+     * `setBasemap('osm-positron')` draws the basemap with a raster layer and the labels.
      */
     vectorTiles(options?: VectorTilesOptions): VectorTiles;
     /** Adds a layer, under `before` if given */

package/dist/map.js

@@ -6,9 +6,11 @@
  * layers, the overlays and controls, the frame loop, the hover picking, the workers…) in map/.
  */
 import { SEA } from "./basemap/basemaps.js";
-import { defaultWorkerUrl, pmtilesLayer, VectorTiles, } from "./basemap/vectortiles.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, loadEngine } from "./engine-loader.js";
+import { destroyedEngine, engineUrl, loadEngine, tessUrl } from "./engine-loader.js";
 import { IGN_PRESETS } from "./geoplateforme.js";
 import { ExtrusionLayer, extrusionStyle } from "./layers/extrusions.js";
 import { CircleLayer, circleStyle, FillLayer, fillStyle, LineLayer, lineStyle, } from "./layers/features.js";
@@ -16,6 +18,7 @@ import { CustomLayer, GroundLayer, ModelLayer, NetworkLayer, RasterLayer, Tiles3
 import { loadPanoramas } from "./layers/panoramas.js";
 import { PointCloudLayer } from "./layers/pointclouds.js";
 import { SymbolLayer, symbolStyle } from "./layers/symbols.js";
+import { VectorLayer } from "./layers/vectors.js";
 import { BasemapLayers } from "./map/basemap-layers.js";
 import { createCanvas, labelCanvas, watchContext, watchPixelRatio } from "./map/canvas.js";
 import { checkBasemap, report, validateNetwork } from "./map/checks.js";
@@ -37,6 +40,7 @@ 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 { sunPosition } from "./util/sun.js";
 /** 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 */
@@ -57,6 +61,8 @@ export class GeoMap {
     /** The canvas in the container, the markers and popups over it, the controls in its corners */
     overlays;
     settings;
+    /** @internal Where the basemap workers load the tessellation module from (`isard_tess_bg.wasm`) */
+    tessUrl;
     /** The WebGL context is lost: nothing is drawn until it is restored */
     lost = false;
     gone = false;
@@ -106,6 +112,7 @@ export class GeoMap {
     constructor(container, options, engineClass, tiles3dModule) {
         this.engines = new MapEngines(engineClass, tiles3dModule, options, () => this.gone);
         const workerUrl = options.basemapWorkerUrl ?? defaultWorkerUrl(options.assetsUrl);
+        this.tessUrl = tessUrl(options);
         this.workers = new MapWorkers(workerUrl, options.workers, () => this.gone, this);
         this.basemaps = new BasemapLayers(this, this.stack, workerUrl, options.basemapTileSize);
         this.container = container;
@@ -143,6 +150,8 @@ export class GeoMap {
             : { center: [0, 0], zoom: 2, pitch: 0, bearing: 0 };
         this.setCamera({ ...start, ...options });
         this.setBasemap(options.basemap ?? (this.earth ? 'osm-positron' : 'none'), options.hillshade ?? 0);
+        if (options.sun)
+            this.setSun(options.sun);
         this.resizeObserver = new ResizeObserver(() => this.resize());
         this.resizeObserver.observe(container);
         this.unwatchRatio = watchPixelRatio(() => this.resize());
@@ -220,9 +229,11 @@ export class GeoMap {
         // A street-level eye stays one in the new engine
         if (this.#firstPerson)
             this.setFirstPerson(this.#firstPerson);
-        // What the old engine drew over the scene: the viewshed, the panoramas shown
+        // What the old engine drew over the scene: the viewshed, the sun's shadows, the panoramas shown
         if (this.viewshed)
             this.setViewshed(this.viewshed);
+        if (this.sun)
+            this.setSun(this.sun);
         this.panoramaSets.forEach((set) => {
             if (set.current)
                 void set.show(set.current.index).catch(report);
@@ -262,17 +273,22 @@ export class GeoMap {
     /**
      * Compares two states of a place: `layers` shown on one side of a vertical line only, at `position` CSS pixels
      * from the left of the map (left of it by default, `side: 'right'` for the other), the layers beneath them on the
-     * other side. Set again as the line moves (a slider, a drag); undefined stops
+     * other side; `other`: layers shown on the other side only (two meshes of a place, each on its side). Set again as
+     * the line moves (a slider, a drag); undefined stops
      */
     setSwipe(options) {
-        this.swipe = options && options.layers.length > 0 ? { ...options, layers: [...options.layers] } : undefined;
+        const used = options && (options.layers.length > 0 || (options.other?.length ?? 0) > 0);
+        this.swipe = used ? { ...options, layers: [...options.layers], other: [...(options.other ?? [])] } : undefined;
         this.applySwipe();
         this.requestRender();
     }
     applySwipe() {
         const s = this.swipe;
-        const ids = Uint32Array.from((s?.layers ?? []).filter((l) => l.id >= 0), (l) => l.id);
-        this.engine.setSwipe(s && ids.length > 0 ? s.position : Number.NaN, s?.side === 'right', ids);
+        const idsOf = (layers) => Uint32Array.from((layers ?? []).filter((l) => l.id >= 0), (l) => l.id);
+        const ids = idsOf(s?.layers);
+        const others = idsOf(s?.other);
+        const shown = ids.length > 0 || others.length > 0;
+        this.engine.setSwipe(s && shown ? s.position : Number.NaN, s?.side === 'right', ids, others);
     }
     /** @internal Forgets a removed layer */
     detach(layer) {
@@ -344,9 +360,10 @@ export class GeoMap {
         elevationAt: (lonLat) => this.elevationAt(lonLat),
         metersPerPixel: (point) => this.metersPerPixel(point),
     };
-    /** What is drawn over the scene, together: `viewshed` (`setViewshed`), `swipe` (`setSwipe`) */
+    /** 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() {
@@ -423,6 +440,35 @@ export class GeoMap {
     }
     /** The viewshed set, set again in a new engine */
     viewshed;
+    /** The sun set, set again in a new engine */
+    sun;
+    /**
+     * The sun casting shadows: the buildings, trees, models, 3D Tiles and the relief shade the ground and one another,
+     * the walls turned away from it are in their own shade; the labels stay over them. The sun stands where it is at
+     * `date` over the map's center (now by default), or at `azimuth` and `altitude`. As it sets the night falls (`night`
+     * to set it by hand): the scene tinted in its blue, the windows of the buildings and the streets of `vectors()` lit,
+     * the labels light on dark.
+     * The shadows cover the ground around the view's center, fading out away from it, and cost two more depth passes
+     * of the solid scene each frame. Undefined removes them
+     */
+    setSun(options) {
+        this.sun = options;
+        if (!options) {
+            this.engine.setSun(Number.NaN, Number.NaN, 0, 0);
+            this.requestRender();
+            return;
+        }
+        const { azimuth, altitude } = options.azimuth !== undefined && options.altitude !== undefined
+            ? { azimuth: options.azimuth, altitude: options.altitude }
+            : sunPosition(options.date ?? new Date(), this.getCamera().center);
+        // The twilight: from 6° above the horizon to 6° under it, smoothly
+        const dusk = Math.min(1, Math.max(0, (6 - altitude) / 12));
+        const night = Math.min(1, Math.max(0, options.night ?? dusk * dusk * (3 - 2 * dusk)));
+        // The shadows fade with the sun's light
+        const opacity = Math.min(1, Math.max(0, options.opacity ?? 0.35)) * (1 - night);
+        this.engine.setSun(azimuth, altitude, opacity, night);
+        this.requestRender();
+    }
     /** Tints what can be seen from a point and what is hidden from it, within a range, all around or within a cone
      * (`direction`): the relief, extrusions, 3D Tiles and models hide what lies behind them (only what the map has
      * loaded for its view). Several observers (16 at most): what any of them sees is seen, what is hidden from all those
@@ -442,6 +488,10 @@ export class GeoMap {
         this.credits.changed();
         this.requestRender();
     }
+    /** @internal Whether a relief is under the basemap: the fills of vector tiles drawn as geometry need their prisms */
+    get hasRelief() {
+        return this.settings.terrain !== undefined;
+    }
     /** @internal The credits of the raster layers (the basemap first) and of the relief in use, each once */
     attributions() {
         return this.credits.of(this.layers, this.settings.terrain?.attribution);
@@ -641,7 +691,7 @@ export class GeoMap {
                 off();
                 resolve();
             });
-            this.requestRender();
+            this.frames.requestIdle();
         });
     }
     /** Lines from GeoJSON (line strings, and polygon outlines), styled per feature */
@@ -693,8 +743,8 @@ export class GeoMap {
     }
     /**
      * Vector tiles with a MapLibre style (OpenFreeMap's Positron by default): `tiles.raster(…)` draws its fills and lines
-     * (or a subset) as a raster layer, `tiles.labels(…)` its labels. `setBasemap('osm-positron')` does both for the
-     * basemap.
+     * (or a subset) as a raster layer, `tiles.vectors(…)` as geometry, `tiles.labels(…)` its labels.
+     * `setBasemap('osm-positron')` draws the basemap with a raster layer and the labels.
      */
     vectorTiles(options = {}) {
         const tiles = new VectorTiles(this, {
@@ -705,6 +755,10 @@ export class GeoMap {
         this.vectorSets.add(tiles);
         return tiles;
     }
+    /** @internal The geometry of a `VectorTiles` (`vectors`), under `before` if given */
+    addVectorLayer(before) {
+        return this.place(new VectorLayer(this), before);
+    }
     /** @internal Forgets a destroyed `VectorTiles` */
     dropVectorTiles(tiles) {
         this.vectorSets.delete(tiles);