isard 0.6.1 → 0.8.0

package/dist/wasm/isard.d.ts

@@ -12,6 +12,8 @@ export interface EncodedPrimitive {
     mime?: string;
     /** Base color factor of its material (RGBA 0-1), when not white */
     color?: Float32Array<ArrayBuffer>;
+    /** The feature of each vertex (`EncodedTile.properties` index them), when the tile has features */
+    features?: Float32Array<ArrayBuffer>;
 }
 
 /** A tile decoded by `decodeTile` */
@@ -21,6 +23,8 @@ export interface EncodedTile {
     primitives: EncodedPrimitive[];
     /** Its points (`.pnts`, glTF points), 20 bytes a vertex: x, y, z (f32) around the anchor, RGB, a normal */
     points: Uint8Array<ArrayBuffer>[];
+    /** The properties of its features, one object per feature */
+    properties?: Record<string, unknown>[];
 }
 
 /** A texture transcoded for the GPU (KTX2 / Basis Universal): a WebGL internal format and its mip levels */
@@ -41,6 +45,8 @@ export interface DecodedPrimitive {
     texture?: CompressedTexture;
     /** Base color factor of its material (RGBA 0-1), when not white */
     color?: Float32Array<ArrayBuffer>;
+    /** The feature of each vertex, when the tile has features */
+    features?: Float32Array<ArrayBuffer>;
 }
 
 /**
@@ -85,6 +91,8 @@ export interface DecodedTile {
     primitives: DecodedPrimitive[];
     /** Its points' vertices (`EncodedTile.points`) */
     points?: Uint8Array<ArrayBuffer>[];
+    /** The properties of its features (`EncodedTile.properties`) */
+    properties?: Record<string, unknown>[];
 }
 
 /** What the engine expects from a pool of decoding workers (`Engine.setTileLoader`) */
@@ -324,14 +332,19 @@ export class Engine {
     /**
      * 3D Tiles (b3dm / glb textured meshes, external tilesets) from the URL of a `tileset.json`. `max_error`:
      * screen-space error (CSS pixels) above which a tile is refined; 16 is the usual value, lower is finer.
+     * `geoid`: its heights are altitudes (NGF-IGN69), each tile raised by the RAF20 geoid onto the relief.
      */
-    addTiles3d(url: string, max_error: number): number;
+    addTiles3d(url: string, max_error: number, geoid?: boolean | null): number;
     /**
      * Longitudes and latitudes the view covers on the ground, `[west, south, east, north]` (degrees): the screen's
      * border cast on the ground, or on the far plane where it passes the horizon
      */
     bounds(): Float64Array;
     camera(): Camera;
+    /**
+     * Removes the panorama
+     */
+    clearPanorama(): void;
     clearPreload(): void;
     /**
      * Removes the viewshed
@@ -343,6 +356,16 @@ export class Engine {
      * callback of a custom layer. Static: the engine is borrowed while it draws
      */
     static customMatrix(lon: number, lat: number, altitude: number): Float32Array | undefined;
+    /**
+     * Altitude of the relief at a position (metres, exaggeration included), from the copy of its tiles kept on the
+     * CPU (as coarse as the tiles loaded there); undefined without relief or where none is loaded
+     */
+    elevationAt(lon: number, lat: number): number | undefined;
+    /**
+     * Height of the RAF20 geoid above the ellipsoid at a position (metres; 0 away from mainland France): what raises
+     * the altitudes (NGF-IGN69) of a source onto the IGN relief
+     */
+    static geoidHeight(lon: number, lat: number): number;
     /**
      * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself
      */
@@ -353,6 +376,12 @@ export class Engine {
      * through the layer's ramp, up to `max` (above: its own color)
      */
     linkExtrusionNetwork(id: number, network: number | null | undefined, max: number): void;
+    /**
+     * Model-view-projection matrix (16 numbers, column-major) of the local frame at a longitude, latitude (degrees)
+     * and altitude (metres), x east, y north, z up, in metres, for the last frame drawn (else the camera): the 3D
+     * overlays of the page (`Panel`) placed with it after each frame
+     */
+    localMatrix(lon: number, lat: number, altitude: number): Float32Array;
     /**
      * Moves a layer to a drawing position (0 = bottom)
      */
@@ -401,9 +430,9 @@ export class Engine {
      */
     preload(lon: number, lat: number, zoom: number, pitch: number, bearing: number): void;
     /**
-     * Screen point (CSS pixels) of a ground position, undefined behind the camera
+     * Screen point (CSS pixels) of a ground position, or `height` metres above it, undefined behind the camera
      */
-    project(lon: number, lat: number): [x: number, y: number] | undefined;
+    project(lon: number, lat: number, height?: number | null): [x: number, y: number] | undefined;
     removeExtrusionBatch(id: number, key: number): void;
     removeLayer(id: number): void;
     render(): boolean;
@@ -481,6 +510,12 @@ export class Engine {
      * New polygons for a fill layer (same arguments as `addFills`, the same features)
      */
     setFills(id: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array): void;
+    /**
+     * A street-level view: the eye `height` metres above the ground at `lon`, `lat` (degrees), looking `bearing`
+     * (degrees clockwise from north) and `pitch` (0 straight down, 90 level, 180 straight up), with a vertical field
+     * of view of `fov` degrees. A camera set with `setCamera` turns around a point again
+     */
+    setFirstPerson(lon: number, lat: number, height: number, bearing: number, pitch: number, fov: number): void;
     /**
      * Color of the globe under the tiles (polar caps)
      */
@@ -560,16 +595,38 @@ export class Engine {
      * One value per node; negative = unreached
      */
     setNetworkValues(id: number, values: Float32Array): void;
+    /**
+     * The image of camera `index` of the panorama (the images sharing the size of the first)
+     */
+    setPanoramaImage(index: number, image: ImageBitmap): void;
+    /**
+     * Shows a panorama: at `lon`, `lat` (degrees) and `height` (metres above the ellipsoid), turned by `rotation`
+     * (9 numbers, row-major: its frame to east, north, up), its `cameras` (25 numbers each: rotation from the panorama
+     * frame, row-major, 9; position in it, 3; focal x, y; center x, y; skew; image width, height; principal point of
+     * the distortion x, y; its coefficients r³, r⁵, r⁷; its limit, pixels), a backdrop sphere of `radius` metres, at
+     * `opacity`. Its images come after (`setPanoramaImage`)
+     */
+    setPanorama(lon: number, lat: number, height: number, rotation: Float64Array, cameras: Float64Array, radius: number, opacity: number): void;
     /**
      * The style of a point cloud: 14 numbers (see `Style::parse`), the colors of the 256 classes (RGBA,
      * alpha 0 hides a class) and the ramp of the altitudes (256 RGBA texels)
      */
     setPointCloudStyle(id: number, style: Float64Array, palette: Uint8Array, ramp: Uint8Array): void;
     setRasterStyle(id: number, opacity: number, saturation: number): void;
+    /**
+     * The headers added to the engine's requests by URL prefix (`setRequestHeaders`, the same for every map of the
+     * page): `prefixes[i]` with `counts[i]` name and value pairs, in order, flattened into `pairs`
+     */
+    setRequestHeaders(prefixes: string[], counts: Uint32Array, pairs: string[]): void;
     /**
      * Space behind the globe (stars, atmosphere halo), in the globe projection
      */
     setSky(enabled: boolean): void;
+    /**
+     * Shows `layers` on one side of a vertical line only, the others beneath on the other side (comparing two states
+     * of a place): left of `x` (CSS pixels from the left of the canvas), or right of it; a non-finite `x` stops
+     */
+    setSwipe(x: number, right: boolean, layers: Uint32Array): void;
     /**
      * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
      * zoom range, visibility
@@ -599,26 +656,45 @@ export class Engine {
      */
     setTileLoader(loader: TileLoaderLike | null): void;
     /**
-     * Screen-space error threshold, opacity and size of the points (CSS pixels, 2 if not given) of a 3D Tiles layer
+     * Screen-space error threshold, opacity, size of the points (CSS pixels, 2 if not given) and color (RGB 0-1, empty
+     * for none: it tints the textures and colors the untextured meshes) of a 3D Tiles layer
      */
-    setTiles3dStyle(id: number, max_error: number, opacity: number, point_size?: number | null): void;
+    setTiles3dStyle(id: number, max_error: number, opacity: number, point_size: number | null | undefined, color: Float32Array): void;
     /**
      * Shows what can be seen from points, each within its range: `observers` holds 8 numbers per observer
      * (16 at most): longitude, latitude (degrees), metres above the ground, range (metres), then to look one way
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
-     * at `opacity`
+     * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
      */
-    setViewshed(observers: Float64Array, visible: Float32Array, hidden: Float32Array, opacity: number): void;
+    setViewshed(observers: Float64Array, visible: Float32Array, hidden: Float32Array, opacity: number, outline: Float32Array): void;
     setZoomRange(min: number, max: number): void;
     /**
      * Tile counters of the raster layers, for diagnostics
      */
     stats(): RasterLayerStats[];
+    /**
+     * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
+     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
+     * pixel and read back (a stall, cheap: one pixel to fill)
+     */
+    surfaceAt(lon: number, lat: number): any;
+    /**
+     * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
+     * read back (a stall): for clicks and drags
+     */
+    surface(x: number, y: number): [lon: number, lat: number, height: number] | undefined;
     /**
      * Compressed texture formats of the GPU (their WebGL extensions get enabled), for the KTX2 transcoding
      */
     textureFormats(): TextureFormats;
+    /**
+     * The feature of a picked handle (`pick`'s index on a 3D Tiles layer): `[properties, feature]`, its properties
+     * (undefined when its tile has none) and its index in its tile; undefined if the handle is not of the last picking
+     * pass
+     */
+    tiles3dFeature(id: number, index: number): [properties: Record<string, unknown> | undefined, feature: number] | undefined;
     /**
      * Counters of a 3D Tiles layer, undefined if there is none with this id
      */
@@ -639,6 +715,11 @@ export class Engine {
      * A region of the icon atlas: `width` × `height` RGBA texels (premultiplied) at (`x`, `y`)
      */
     updateIconAtlas(x: number, y: number, width: number, height: number, data: Uint8Array): void;
+    /**
+     * Tiles a raster layer wants for the view of the last frame, three numbers per tile (z, x, y), the nearest to
+     * the eye first: the level each area of the ground is drawn at, for the labels of a vector style to follow it
+     */
+    wantedTiles(id: number): Uint32Array;
     zoomAt(delta: number, x: number, y: number): void;
 }
 
@@ -674,14 +755,18 @@ export interface InitOutput {
     readonly engine_addPointCloud: (a: number, b: number, c: number, d: any) => [number, number, number];
     readonly engine_addRaster: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly engine_addSymbols: (a: number) => [number, number, number];
-    readonly engine_addTiles3d: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly engine_addTiles3d: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
     readonly engine_bounds: (a: number) => [number, number];
     readonly engine_camera: (a: number) => any;
+    readonly engine_clearPanorama: (a: number) => void;
     readonly engine_clearPreload: (a: number) => void;
     readonly engine_clearViewshed: (a: number) => void;
     readonly engine_customMatrix: (a: number, b: number, c: number) => [number, number];
+    readonly engine_elevationAt: (a: number, b: number, c: number) => [number, number];
+    readonly engine_geoidHeight: (a: number, b: number) => number;
     readonly engine_ground: (a: number, b: number, c: number) => any;
     readonly engine_linkExtrusionNetwork: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_localMatrix: (a: number, b: number, c: number, d: number) => [number, number];
     readonly engine_moveLayer: (a: number, b: number, c: number) => void;
     readonly engine_networkStats: (a: number, b: number) => any;
     readonly engine_new: (a: any, b: any) => [number, number, number];
@@ -692,7 +777,7 @@ export interface InitOutput {
     readonly engine_pointCloudStats: (a: number, b: number) => any;
     readonly engine_pollPick: (a: number) => any;
     readonly engine_preload: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly engine_project: (a: number, b: number, c: number) => any;
+    readonly engine_project: (a: number, b: number, c: number, d: number, e: number) => any;
     readonly engine_removeExtrusionBatch: (a: number, b: number, c: number) => void;
     readonly engine_removeLayer: (a: number, b: number) => void;
     readonly engine_render: (a: number) => number;
@@ -713,6 +798,7 @@ export interface InitOutput {
     readonly engine_setFeatureStyle: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setFeatureValues: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setFills: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly engine_setFirstPerson: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_setGlobe: (a: number, b: number) => void;
     readonly engine_setGlobeColor: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setGlyphAtlas: (a: number, b: number, c: number, d: number, e: number) => [number, number];
@@ -732,23 +818,31 @@ export interface InitOutput {
     readonly engine_setNetworkScales: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkStyle: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkValues: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setPanorama: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
+    readonly engine_setPanoramaImage: (a: number, b: number, c: any) => [number, number];
     readonly engine_setPointCloudStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_setRasterStyle: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setRequestHeaders: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_setSky: (a: number, b: number) => void;
+    readonly engine_setSwipe: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_setSymbolLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly engine_setSymbols: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly engine_setTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly engine_setTileLoader: (a: number, b: any) => void;
-    readonly engine_setTiles3dStyle: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly engine_setViewshed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
+    readonly engine_setTiles3dStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly engine_setViewshed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly engine_setZoomRange: (a: number, b: number, c: number) => void;
     readonly engine_stats: (a: number) => any;
+    readonly engine_surface: (a: number, b: number, c: number) => any;
+    readonly engine_surfaceAt: (a: number, b: number, c: number) => any;
     readonly engine_textureFormats: (a: number) => any;
+    readonly engine_tiles3dFeature: (a: number, b: number, c: number) => any;
     readonly engine_tiles3dStats: (a: number, b: number) => any;
     readonly engine_updateGlyphAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly engine_updateGlyphPage: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_updateGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => [number, number];
     readonly engine_updateIconAtlas: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly engine_wantedTiles: (a: number, b: number) => [number, number];
     readonly engine_zoomAt: (a: number, b: number, c: number, d: number) => void;
     readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
     readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_: (a: number, b: number, c: any) => [number, number];

package/dist/wasm/isard.js

@@ -228,14 +228,16 @@ export class Engine {
     /**
      * 3D Tiles (b3dm / glb textured meshes, external tilesets) from the URL of a `tileset.json`. `max_error`:
      * screen-space error (CSS pixels) above which a tile is refined; 16 is the usual value, lower is finer.
+     * `geoid`: its heights are altitudes (NGF-IGN69), each tile raised by the RAF20 geoid onto the relief.
      * @param {string} url
      * @param {number} max_error
+     * @param {boolean | null} [geoid]
      * @returns {number}
      */
-    addTiles3d(url, max_error) {
+    addTiles3d(url, max_error, geoid) {
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_addTiles3d(this.__wbg_ptr, ptr0, len0, max_error);
+        const ret = wasm.engine_addTiles3d(this.__wbg_ptr, ptr0, len0, max_error, isLikeNone(geoid) ? 0xFFFFFF : geoid ? 1 : 0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -259,6 +261,12 @@ export class Engine {
         const ret = wasm.engine_camera(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Removes the panorama
+     */
+    clearPanorama() {
+        wasm.engine_clearPanorama(this.__wbg_ptr);
+    }
     clearPreload() {
         wasm.engine_clearPreload(this.__wbg_ptr);
     }
@@ -286,6 +294,28 @@ export class Engine {
         }
         return v1;
     }
+    /**
+     * Altitude of the relief at a position (metres, exaggeration included), from the copy of its tiles kept on the
+     * CPU (as coarse as the tiles loaded there); undefined without relief or where none is loaded
+     * @param {number} lon
+     * @param {number} lat
+     * @returns {number | undefined}
+     */
+    elevationAt(lon, lat) {
+        const ret = wasm.engine_elevationAt(this.__wbg_ptr, lon, lat);
+        return ret[0] === 0 ? undefined : ret[1];
+    }
+    /**
+     * Height of the RAF20 geoid above the ellipsoid at a position (metres; 0 away from mainland France): what raises
+     * the altitudes (NGF-IGN69) of a source onto the IGN relief
+     * @param {number} lon
+     * @param {number} lat
+     * @returns {number}
+     */
+    static geoidHeight(lon, lat) {
+        const ret = wasm.engine_geoidHeight(lon, lat);
+        return ret;
+    }
     /**
      * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself
      * @param {number} x
@@ -307,6 +337,21 @@ export class Engine {
     linkExtrusionNetwork(id, network, max) {
         wasm.engine_linkExtrusionNetwork(this.__wbg_ptr, id, isLikeNone(network) ? Number.MAX_SAFE_INTEGER : (network) >>> 0, max);
     }
+    /**
+     * Model-view-projection matrix (16 numbers, column-major) of the local frame at a longitude, latitude (degrees)
+     * and altitude (metres), x east, y north, z up, in metres, for the last frame drawn (else the camera): the 3D
+     * overlays of the page (`Panel`) placed with it after each frame
+     * @param {number} lon
+     * @param {number} lat
+     * @param {number} altitude
+     * @returns {Float32Array}
+     */
+    localMatrix(lon, lat, altitude) {
+        const ret = wasm.engine_localMatrix(this.__wbg_ptr, lon, lat, altitude);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * Moves a layer to a drawing position (0 = bottom)
      * @param {number} id
@@ -417,13 +462,14 @@ export class Engine {
         wasm.engine_preload(this.__wbg_ptr, lon, lat, zoom, pitch, bearing);
     }
     /**
-     * Screen point (CSS pixels) of a ground position, undefined behind the camera
+     * Screen point (CSS pixels) of a ground position, or `height` metres above it, undefined behind the camera
      * @param {number} lon
      * @param {number} lat
+     * @param {number | null} [height]
      * @returns {[x: number, y: number] | undefined}
      */
-    project(lon, lat) {
-        const ret = wasm.engine_project(this.__wbg_ptr, lon, lat);
+    project(lon, lat, height) {
+        const ret = wasm.engine_project(this.__wbg_ptr, lon, lat, !isLikeNone(height), isLikeNone(height) ? 0 : height);
         return ret;
     }
     /**
@@ -665,6 +711,20 @@ export class Engine {
         const len3 = WASM_VECTOR_LEN;
         wasm.engine_setFills(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
     }
+    /**
+     * A street-level view: the eye `height` metres above the ground at `lon`, `lat` (degrees), looking `bearing`
+     * (degrees clockwise from north) and `pitch` (0 straight down, 90 level, 180 straight up), with a vertical field
+     * of view of `fov` degrees. A camera set with `setCamera` turns around a point again
+     * @param {number} lon
+     * @param {number} lat
+     * @param {number} height
+     * @param {number} bearing
+     * @param {number} pitch
+     * @param {number} fov
+     */
+    setFirstPerson(lon, lat, height, bearing, pitch, fov) {
+        wasm.engine_setFirstPerson(this.__wbg_ptr, lon, lat, height, bearing, pitch, fov);
+    }
     /**
      * Color of the globe under the tiles (polar caps)
      * @param {number} r
@@ -886,6 +946,41 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_setNetworkValues(this.__wbg_ptr, id, ptr0, len0);
     }
+    /**
+     * The image of camera `index` of the panorama (the images sharing the size of the first)
+     * @param {number} index
+     * @param {ImageBitmap} image
+     */
+    setPanoramaImage(index, image) {
+        const ret = wasm.engine_setPanoramaImage(this.__wbg_ptr, index, image);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Shows a panorama: at `lon`, `lat` (degrees) and `height` (metres above the ellipsoid), turned by `rotation`
+     * (9 numbers, row-major: its frame to east, north, up), its `cameras` (25 numbers each: rotation from the panorama
+     * frame, row-major, 9; position in it, 3; focal x, y; center x, y; skew; image width, height; principal point of
+     * the distortion x, y; its coefficients r³, r⁵, r⁷; its limit, pixels), a backdrop sphere of `radius` metres, at
+     * `opacity`. Its images come after (`setPanoramaImage`)
+     * @param {number} lon
+     * @param {number} lat
+     * @param {number} height
+     * @param {Float64Array} rotation
+     * @param {Float64Array} cameras
+     * @param {number} radius
+     * @param {number} opacity
+     */
+    setPanorama(lon, lat, height, rotation, cameras, radius, opacity) {
+        const ptr0 = passArrayF64ToWasm0(rotation, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(cameras, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setPanorama(this.__wbg_ptr, lon, lat, height, ptr0, len0, ptr1, len1, radius, opacity);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * The style of a point cloud: 14 numbers (see `Style::parse`), the colors of the 256 classes (RGBA,
      * alpha 0 hides a class) and the ramp of the altitudes (256 RGBA texels)
@@ -911,6 +1006,22 @@ export class Engine {
     setRasterStyle(id, opacity, saturation) {
         wasm.engine_setRasterStyle(this.__wbg_ptr, id, opacity, saturation);
     }
+    /**
+     * The headers added to the engine's requests by URL prefix (`setRequestHeaders`, the same for every map of the
+     * page): `prefixes[i]` with `counts[i]` name and value pairs, in order, flattened into `pairs`
+     * @param {string[]} prefixes
+     * @param {Uint32Array} counts
+     * @param {string[]} pairs
+     */
+    setRequestHeaders(prefixes, counts, pairs) {
+        const ptr0 = passArrayJsValueToWasm0(prefixes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(counts, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayJsValueToWasm0(pairs, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.engine_setRequestHeaders(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
     /**
      * Space behind the globe (stars, atmosphere halo), in the globe projection
      * @param {boolean} enabled
@@ -918,6 +1029,18 @@ export class Engine {
     setSky(enabled) {
         wasm.engine_setSky(this.__wbg_ptr, enabled);
     }
+    /**
+     * Shows `layers` on one side of a vertical line only, the others beneath on the other side (comparing two states
+     * of a place): left of `x` (CSS pixels from the left of the canvas), or right of it; a non-finite `x` stops
+     * @param {number} x
+     * @param {boolean} right
+     * @param {Uint32Array} layers
+     */
+    setSwipe(x, right, layers) {
+        const ptr0 = passArray32ToWasm0(layers, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.engine_setSwipe(this.__wbg_ptr, x, right, ptr0, len0);
+    }
     /**
      * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
      * zoom range, visibility
@@ -992,34 +1115,41 @@ export class Engine {
         wasm.engine_setTileLoader(this.__wbg_ptr, loader);
     }
     /**
-     * Screen-space error threshold, opacity and size of the points (CSS pixels, 2 if not given) of a 3D Tiles layer
+     * Screen-space error threshold, opacity, size of the points (CSS pixels, 2 if not given) and color (RGB 0-1, empty
+     * for none: it tints the textures and colors the untextured meshes) of a 3D Tiles layer
      * @param {number} id
      * @param {number} max_error
      * @param {number} opacity
-     * @param {number | null} [point_size]
+     * @param {number | null | undefined} point_size
+     * @param {Float32Array} color
      */
-    setTiles3dStyle(id, max_error, opacity, point_size) {
-        wasm.engine_setTiles3dStyle(this.__wbg_ptr, id, max_error, opacity, !isLikeNone(point_size), isLikeNone(point_size) ? 0 : point_size);
+    setTiles3dStyle(id, max_error, opacity, point_size, color) {
+        const ptr0 = passArrayF32ToWasm0(color, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.engine_setTiles3dStyle(this.__wbg_ptr, id, max_error, opacity, !isLikeNone(point_size), isLikeNone(point_size) ? 0 : point_size, ptr0, len0);
     }
     /**
      * Shows what can be seen from points, each within its range: `observers` holds 8 numbers per observer
      * (16 at most): longitude, latitude (degrees), metres above the ground, range (metres), then to look one way
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
-     * at `opacity`
+     * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
      * @param {Float64Array} observers
      * @param {Float32Array} visible
      * @param {Float32Array} hidden
      * @param {number} opacity
+     * @param {Float32Array} outline
      */
-    setViewshed(observers, visible, hidden, opacity) {
+    setViewshed(observers, visible, hidden, opacity, outline) {
         const ptr0 = passArrayF64ToWasm0(observers, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(visible, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
         const ptr2 = passArrayF32ToWasm0(hidden, wasm.__wbindgen_malloc);
         const len2 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity);
+        const ptr3 = passArrayF32ToWasm0(outline, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity, ptr3, len3);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1039,6 +1169,30 @@ export class Engine {
         const ret = wasm.engine_stats(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
+     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
+     * pixel and read back (a stall, cheap: one pixel to fill)
+     * @param {number} lon
+     * @param {number} lat
+     * @returns {any}
+     */
+    surfaceAt(lon, lat) {
+        const ret = wasm.engine_surfaceAt(this.__wbg_ptr, lon, lat);
+        return ret;
+    }
+    /**
+     * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
+     * read back (a stall): for clicks and drags
+     * @param {number} x
+     * @param {number} y
+     * @returns {[lon: number, lat: number, height: number] | undefined}
+     */
+    surface(x, y) {
+        const ret = wasm.engine_surface(this.__wbg_ptr, x, y);
+        return ret;
+    }
     /**
      * Compressed texture formats of the GPU (their WebGL extensions get enabled), for the KTX2 transcoding
      * @returns {TextureFormats}
@@ -1047,6 +1201,18 @@ export class Engine {
         const ret = wasm.engine_textureFormats(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * The feature of a picked handle (`pick`'s index on a 3D Tiles layer): `[properties, feature]`, its properties
+     * (undefined when its tile has none) and its index in its tile; undefined if the handle is not of the last picking
+     * pass
+     * @param {number} id
+     * @param {number} index
+     * @returns {[properties: Record<string, unknown> | undefined, feature: number] | undefined}
+     */
+    tiles3dFeature(id, index) {
+        const ret = wasm.engine_tiles3dFeature(this.__wbg_ptr, id, index);
+        return ret;
+    }
     /**
      * Counters of a 3D Tiles layer, undefined if there is none with this id
      * @param {number} id
@@ -1117,6 +1283,18 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
     }
+    /**
+     * Tiles a raster layer wants for the view of the last frame, three numbers per tile (z, x, y), the nearest to
+     * the eye first: the level each area of the ground is drawn at, for the labels of a vector style to follow it
+     * @param {number} id
+     * @returns {Uint32Array}
+     */
+    wantedTiles(id) {
+        const ret = wasm.engine_wantedTiles(this.__wbg_ptr, id);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * @param {number} delta
      * @param {number} x
@@ -1700,6 +1878,10 @@ function __wbg_get_imports() {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
+        __wbg_get_806853698d9fc227: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1 >>> 0);
+            return ret;
+        }, arguments); },
         __wbg_get_f75619e20cb68514: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             const ret = arg1.get(getStringFromWasm0(arg2, arg3));
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2324,6 +2506,12 @@ function __wbg_get_imports() {
         __wbg_useProgram_e075c2902e420761: function(arg0, arg1) {
             arg0.useProgram(arg1);
         },
+        __wbg_vertexAttrib1f_37ce0547e8fa5f36: function(arg0, arg1, arg2) {
+            arg0.vertexAttrib1f(arg1 >>> 0, arg2);
+        },
+        __wbg_vertexAttrib1f_470b2556c148483a: function(arg0, arg1, arg2) {
+            arg0.vertexAttrib1f(arg1 >>> 0, arg2);
+        },
         __wbg_vertexAttribDivisorANGLE_659fb027198a47c3: function(arg0, arg1, arg2) {
             arg0.vertexAttribDivisorANGLE(arg1 >>> 0, arg2 >>> 0);
         },
@@ -2353,7 +2541,7 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 197, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 198, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_);
             return ret;
         },
@@ -2704,6 +2892,16 @@ function passArrayF64ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);