isard 1.2.0 → 1.4.0

package/dist/wasm/isard_core.d.ts

@@ -103,6 +103,16 @@ export class Engine {
      * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
      */
     addFills(points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, feature: Uint32Array, feature_count: number): number;
+    /**
+     * A flow layer of `particles` particles (rounded up to a multiple of 4096) with trails of `trail` positions; its
+     * field comes with `setFlowField`
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created, a shader fails to compile or the trails need a
+     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     */
+    addFlow(particles: number, trail: number): number;
     /**
      * Ground layer running `code` (GLSL ES 3.0 defining `vec4 ground(vec2 offset)`, see `render::ground`) over the
      * ground; `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors
@@ -156,6 +166,15 @@ export class Engine {
      * info log)
      */
     addSymbols(): number;
+    /**
+     * An empty layer of vector tiles drawn as geometry: its style layers come with `setVectorSublayers`, its tiles
+     * with `setVectorTile`
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a shader fails to compile (the error carries its info log)
+     */
+    addVectorTiles(): 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
@@ -256,6 +275,10 @@ export class Engine {
      * Removes a layer and frees its GPU objects; the other layers forget it (a layer that referred to it)
      */
     removeLayer(id: number): void;
+    /**
+     * Removes tile `key` of a vector tile layer (nothing if there is none)
+     */
+    removeVectorTile(id: number, key: number): void;
     /**
      * Draws a frame: the backdrop, the ground and the layers over it bottom to top, then the panorama and the
      * viewshed; returns true while tiles are still loading (a new frame will be asked through `redraw`)
@@ -338,10 +361,10 @@ export class Engine {
      */
     setFeatureRamp(id: number, rgba: Uint8Array | null | undefined, min: number, max: number): void;
     /**
-     * Style of the features of a line, circle, fill or extrusion layer (batch `key` of the latter): 32 floats per
-     * feature, its color (RGBA 0-1), its second color (a circle's stroke), then two sizes as zoom stops (four zooms,
-     * four values each): a line's width; a circle's radius and stroke width, CSS pixels; a block's height and base
-     * height, metres
+     * Style of the features of a line, circle, fill, extrusion or vector tile layer (batch or tile `key` of the last
+     * two): 32 floats per feature, its color (RGBA 0-1), its second color (a circle's stroke), then two sizes as zoom
+     * stops (four zooms, four values each): a line's width; a circle's radius and stroke width, CSS pixels; a block's
+     * height and base height, metres
      */
     setFeatureStyle(id: number, style: Float32Array, key?: number | null): void;
     /**
@@ -358,6 +381,28 @@ export class Engine {
      * 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;
+    /**
+     * How far a flow layer's field has gone towards its next one, 0 to 1 (the time between the model's two hours)
+     */
+    setFlowBlend(id: number, blend: number): void;
+    /**
+     * The field of a flow layer: `width` × `height` points over `bounds` (west, south, east, north, degrees: the
+     * longitudes and latitudes of the corner points; a last column one step short of 360° round the world), their
+     * east and north components (m/s, row after row from the north; not a number: none there). On the grid of the
+     * field before, the particles go on (its next field and blend kept); on another one, they start again
+     */
+    setFlowField(id: number, width: number, height: number, u: Float32Array, v: Float32Array, bounds: Float64Array): void;
+    /**
+     * The field a flow layer's goes towards, on its grid (the model's next hour: east and north components, row after
+     * row; empty: none), mixed in by `setFlowBlend`
+     */
+    setFlowNext(id: number, u: Float32Array, v: Float32Array): void;
+    /**
+     * The look of a flow layer's trails: speeds (m/s) and their colors (RGBA 0-1, four numbers each), up to 8;
+     * width (CSS pixels), opacity, height over the ground (metres), speed on screen (pixels a second for 10 m/s),
+     * particles moving for each 100 × 100 CSS pixels of the view (at most the layer's)
+     */
+    setFlowStyle(id: number, speeds: Float32Array, colors: Float32Array, width: number, opacity: number, height: number, speed: number, density: number): void;
     /**
      * Color of the globe under the tiles (polar caps)
      */
@@ -481,11 +526,22 @@ export class Engine {
      * Space behind the globe (stars, atmosphere halo), in the globe projection
      */
     setSky(enabled: boolean): void;
+    /**
+     * The sun casting shadows and the night: its azimuth (degrees clockwise from north) and altitude (degrees above
+     * the horizon), the shadows' opacity (0 to 1; none under the horizon or not a number), how dark the night is (0 to
+     * 1: the frame tinted, the lights of the layers on). Neither shadows nor night: nothing drawn
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or the pass fails to compile
+     */
+    setSun(azimuth: number, altitude: number, opacity: number, night: number): 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
+     * of a place): left of `x` (CSS pixels from the left of the canvas), or right of it; `others` on the other side
+     * only (two meshes of the same place, each on its side, never drawn over each other); a non-finite `x` stops
      */
-    setSwipe(x: number, right: boolean, layers: Uint32Array): void;
+    setSwipe(x: number, right: boolean, layers: Uint32Array, others: 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
@@ -517,6 +573,44 @@ export class Engine {
      * Throws (to JavaScript) when the texture holding the relief's tiles cannot be created
      */
     setTerrain(url: string | null | undefined, exaggeration: number, max_z: number | null | undefined, geoid: boolean | null | undefined, loader: ((z: number, x: number, y: number, signal: AbortSignal) => Promise<Float32Array | null>) | undefined): void;
+    /**
+     * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion), its zoom range
+     * (two numbers: shown from the first, included, to the second, excluded), whether it shows (0 or 1), its dashes
+     * (four numbers: dash, gap, dash, gap, in line widths; 0: solid), its opacity as zoom stops (four zooms then four
+     * values; missing: opaque), the caps of its lines' ends (0 butt, 1 round, 2 square; missing: round), whether its
+     * lines glow at night (streets; 0 or 1)
+     */
+    setVectorSublayers(id: number, kinds: Uint8Array, zooms: Float64Array, visible: Uint8Array, dashes: Float32Array, opacities: Float32Array, caps: Uint8Array, lit: Uint8Array): void;
+    /**
+     * Adds or replaces tile `key` of a vector tile layer ready for the GPU, as the basemap workers make it (the
+     * tessellation module): its polygons as for `setVectorTile` (picked here; their prisms built here if drawn in
+     * relief while `prism` is false), the vertices of its fills (`shapes::Vertex` as bytes, each with its feature),
+     * their triangles, per sublayer its top cap and the rest of its prism (`fill_ranges`: four numbers, first and
+     * end of each), its line pieces (`pieces::Piece` as bytes), the line table (feature and length of each line),
+     * per sublayer its pieces (`line_ranges`: first, end), the blocks of its extrusion sublayers (`shapes::Block` as
+     * bytes), their triangles, per sublayer its blocks' triangles (`block_ranges`: first, end), the extent of its
+     * points (`bounds`: min x, min y, max x, max y), `feature_count` features
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the vertices, pieces or blocks are cut short, when a WebGL object of the tile cannot be
+     * created, or when its features or lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     */
+    setVectorTileMesh(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, polygon_feature: Uint32Array, fill_start: Uint32Array, vertices: Uint8Array, indices: Uint32Array, fill_ranges: Uint32Array, prism: boolean, pieces: Uint8Array, line_table: Float32Array, line_ranges: Uint32Array, blocks: Uint8Array, block_indices: Uint32Array, block_ranges: Uint32Array, bounds: Float64Array, feature_count: number): void;
+    /**
+     * Adds or replaces tile `key` of a vector tile layer: its polygons as for `addFills` (`fill_start`: the first
+     * polygon of each sublayer, and the end; those of an extrusion sublayer raised into blocks), its lines as for
+     * `addLines` (`line_start`: the first line of each sublayer, and the end), `feature_count` features, styled as an
+     * extrusion layer's (`setFeatureStyle` with the key: a color, then a line's width or a block's height and base);
+     * `tile`: the corners of the tile they are cut to (west, north, east, south; empty: none), along whose edges no
+     * wall of a block rises
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object of the tile cannot be created, or when its features or lines need a
+     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     */
+    setVectorTile(id: number, key: number, points: Float64Array, ring_start: Uint32Array, polygon_start: Uint32Array, polygon_feature: Uint32Array, fill_start: Uint32Array, line_points: Float64Array, line_first: Uint32Array, line_feature: Uint32Array, line_start: Uint32Array, feature_count: number, tile: Float64Array): 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
@@ -538,6 +632,10 @@ export class Engine {
      * Tile counters of the raster layers, for diagnostics
      */
     stats(): RasterLayerStats[];
+    /**
+     * Moves a flow layer's particles by `seconds` of the page's time (one animation frame), in the current view
+     */
+    stepFlow(id: number, seconds: number): void;
     /**
      * 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
@@ -571,6 +669,12 @@ 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;
+    /**
+     * Vector tiles (512 CSS pixels across at their level, as `MapLibre`'s) for the view of the last frame (else the
+     * camera's), levels `min_z` to `max_z`, three numbers per tile (z, x, y), the nearest to the eye first: what a
+     * vector tile layer draws (`addVectorTiles`), coarser far away in a tilted view as the raster layers
+     */
+    vectorTilesInView(min_z: number, max_z: number): Uint32Array;
     /**
      * 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
@@ -591,11 +695,13 @@ export interface InitOutput {
     readonly engine_addCustomLayer: (a: number, b: any, c: number) => number;
     readonly engine_addExtrusions: (a: number) => [number, number, number];
     readonly engine_addFills: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number, number];
+    readonly engine_addFlow: (a: number, b: number, c: number) => [number, number, number];
     readonly engine_addGround: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly engine_addLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
     readonly engine_addNetwork: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => [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_addVectorTiles: (a: number) => [number, number, number];
     readonly engine_bounds: (a: number) => [number, number];
     readonly engine_camera: (a: number) => any;
     readonly engine_clearPreload: (a: number) => void;
@@ -616,6 +722,7 @@ export interface InitOutput {
     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_removeVectorTile: (a: number, b: number, c: number) => void;
     readonly engine_render: (a: number) => number;
     readonly engine_requestPick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => number;
     readonly engine_resize: (a: number, b: number, c: number, d: number) => void;
@@ -635,6 +742,10 @@ export interface InitOutput {
     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_setFlowBlend: (a: number, b: number, c: number) => void;
+    readonly engine_setFlowField: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
+    readonly engine_setFlowNext: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly engine_setFlowStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: 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];
@@ -656,19 +767,25 @@ export interface InitOutput {
     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_setSun: (a: number, b: number, c: number, d: number, e: number) => [number, number];
+    readonly engine_setSwipe: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_setVectorSublayers: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number) => void;
+    readonly engine_setVectorTile: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number) => [number, number];
+    readonly engine_setVectorTileMesh: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number, d1: number, e1: number, f1: number, g1: number, h1: number, i1: number) => [number, number];
     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_stepFlow: (a: number, b: number, c: number) => void;
     readonly engine_surface: (a: number, b: number, c: number) => any;
     readonly engine_surfaceAt: (a: number, b: number, c: 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_vectorTilesInView: (a: number, b: number, c: number) => [number, number];
     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;

package/dist/wasm/isard_core.js

@@ -97,6 +97,25 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * A flow layer of `particles` particles (rounded up to a multiple of 4096) with trails of `trail` positions; its
+     * field comes with `setFlowField`
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created, a shader fails to compile or the trails need a
+     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * @param {number} particles
+     * @param {number} trail
+     * @returns {number}
+     */
+    addFlow(particles, trail) {
+        const ret = wasm.engine_addFlow(this.__wbg_ptr, particles, trail);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Ground layer running `code` (GLSL ES 3.0 defining `vec4 ground(vec2 offset)`, see `render::ground`) over the
      * ground; `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors
@@ -231,6 +250,22 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * An empty layer of vector tiles drawn as geometry: its style layers come with `setVectorSublayers`, its tiles
+     * with `setVectorTile`
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a shader fails to compile (the error carries its info log)
+     * @returns {number}
+     */
+    addVectorTiles() {
+        const ret = wasm.engine_addVectorTiles(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * 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
@@ -449,6 +484,14 @@ export class Engine {
     removeLayer(id) {
         wasm.engine_removeLayer(this.__wbg_ptr, id);
     }
+    /**
+     * Removes tile `key` of a vector tile layer (nothing if there is none)
+     * @param {number} id
+     * @param {number} key
+     */
+    removeVectorTile(id, key) {
+        wasm.engine_removeVectorTile(this.__wbg_ptr, id, key);
+    }
     /**
      * Draws a frame: the backdrop, the ground and the layers over it bottom to top, then the panorama and the
      * viewshed; returns true while tiles are still loading (a new frame will be asked through `redraw`)
@@ -647,10 +690,10 @@ export class Engine {
         wasm.engine_setFeatureRamp(this.__wbg_ptr, id, ptr0, len0, min, max);
     }
     /**
-     * Style of the features of a line, circle, fill or extrusion layer (batch `key` of the latter): 32 floats per
-     * feature, its color (RGBA 0-1), its second color (a circle's stroke), then two sizes as zoom stops (four zooms,
-     * four values each): a line's width; a circle's radius and stroke width, CSS pixels; a block's height and base
-     * height, metres
+     * Style of the features of a line, circle, fill, extrusion or vector tile layer (batch or tile `key` of the last
+     * two): 32 floats per feature, its color (RGBA 0-1), its second color (a circle's stroke), then two sizes as zoom
+     * stops (four zooms, four values each): a line's width; a circle's radius and stroke width, CSS pixels; a block's
+     * height and base height, metres
      * @param {number} id
      * @param {Float32Array} style
      * @param {number | null} [key]
@@ -704,6 +747,69 @@ export class Engine {
     setFirstPerson(lon, lat, height, bearing, pitch, fov) {
         wasm.engine_setFirstPerson(this.__wbg_ptr, lon, lat, height, bearing, pitch, fov);
     }
+    /**
+     * How far a flow layer's field has gone towards its next one, 0 to 1 (the time between the model's two hours)
+     * @param {number} id
+     * @param {number} blend
+     */
+    setFlowBlend(id, blend) {
+        wasm.engine_setFlowBlend(this.__wbg_ptr, id, blend);
+    }
+    /**
+     * The field of a flow layer: `width` × `height` points over `bounds` (west, south, east, north, degrees: the
+     * longitudes and latitudes of the corner points; a last column one step short of 360° round the world), their
+     * east and north components (m/s, row after row from the north; not a number: none there). On the grid of the
+     * field before, the particles go on (its next field and blend kept); on another one, they start again
+     * @param {number} id
+     * @param {number} width
+     * @param {number} height
+     * @param {Float32Array} u
+     * @param {Float32Array} v
+     * @param {Float64Array} bounds
+     */
+    setFlowField(id, width, height, u, v, bounds) {
+        const ptr0 = passArrayF32ToWasm0(u, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(v, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayF64ToWasm0(bounds, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.engine_setFlowField(this.__wbg_ptr, id, width, height, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
+    /**
+     * The field a flow layer's goes towards, on its grid (the model's next hour: east and north components, row after
+     * row; empty: none), mixed in by `setFlowBlend`
+     * @param {number} id
+     * @param {Float32Array} u
+     * @param {Float32Array} v
+     */
+    setFlowNext(id, u, v) {
+        const ptr0 = passArrayF32ToWasm0(u, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(v, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.engine_setFlowNext(this.__wbg_ptr, id, ptr0, len0, ptr1, len1);
+    }
+    /**
+     * The look of a flow layer's trails: speeds (m/s) and their colors (RGBA 0-1, four numbers each), up to 8;
+     * width (CSS pixels), opacity, height over the ground (metres), speed on screen (pixels a second for 10 m/s),
+     * particles moving for each 100 × 100 CSS pixels of the view (at most the layer's)
+     * @param {number} id
+     * @param {Float32Array} speeds
+     * @param {Float32Array} colors
+     * @param {number} width
+     * @param {number} opacity
+     * @param {number} height
+     * @param {number} speed
+     * @param {number} density
+     */
+    setFlowStyle(id, speeds, colors, width, opacity, height, speed, density) {
+        const ptr0 = passArrayF32ToWasm0(speeds, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(colors, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.engine_setFlowStyle(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, width, opacity, height, speed, density);
+    }
     /**
      * Color of the globe under the tiles (polar caps)
      * @param {number} r
@@ -977,17 +1083,40 @@ export class Engine {
     setSky(enabled) {
         wasm.engine_setSky(this.__wbg_ptr, enabled);
     }
+    /**
+     * The sun casting shadows and the night: its azimuth (degrees clockwise from north) and altitude (degrees above
+     * the horizon), the shadows' opacity (0 to 1; none under the horizon or not a number), how dark the night is (0 to
+     * 1: the frame tinted, the lights of the layers on). Neither shadows nor night: nothing drawn
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or the pass fails to compile
+     * @param {number} azimuth
+     * @param {number} altitude
+     * @param {number} opacity
+     * @param {number} night
+     */
+    setSun(azimuth, altitude, opacity, night) {
+        const ret = wasm.engine_setSun(this.__wbg_ptr, azimuth, altitude, opacity, night);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * 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
+     * of a place): left of `x` (CSS pixels from the left of the canvas), or right of it; `others` on the other side
+     * only (two meshes of the same place, each on its side, never drawn over each other); a non-finite `x` stops
      * @param {number} x
      * @param {boolean} right
      * @param {Uint32Array} layers
+     * @param {Uint32Array} others
      */
-    setSwipe(x, right, layers) {
+    setSwipe(x, right, layers, others) {
         const ptr0 = passArray32ToWasm0(layers, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.engine_setSwipe(this.__wbg_ptr, x, right, ptr0, len0);
+        const ptr1 = passArray32ToWasm0(others, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.engine_setSwipe(this.__wbg_ptr, x, right, ptr0, len0, ptr1, len1);
     }
     /**
      * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
@@ -1062,6 +1191,160 @@ export class Engine {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion), its zoom range
+     * (two numbers: shown from the first, included, to the second, excluded), whether it shows (0 or 1), its dashes
+     * (four numbers: dash, gap, dash, gap, in line widths; 0: solid), its opacity as zoom stops (four zooms then four
+     * values; missing: opaque), the caps of its lines' ends (0 butt, 1 round, 2 square; missing: round), whether its
+     * lines glow at night (streets; 0 or 1)
+     * @param {number} id
+     * @param {Uint8Array} kinds
+     * @param {Float64Array} zooms
+     * @param {Uint8Array} visible
+     * @param {Float32Array} dashes
+     * @param {Float32Array} opacities
+     * @param {Uint8Array} caps
+     * @param {Uint8Array} lit
+     */
+    setVectorSublayers(id, kinds, zooms, visible, dashes, opacities, caps, lit) {
+        const ptr0 = passArray8ToWasm0(kinds, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(zooms, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(visible, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayF32ToWasm0(dashes, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArrayF32ToWasm0(opacities, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray8ToWasm0(caps, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray8ToWasm0(lit, wasm.__wbindgen_malloc);
+        const len6 = WASM_VECTOR_LEN;
+        wasm.engine_setVectorSublayers(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
+    }
+    /**
+     * Adds or replaces tile `key` of a vector tile layer ready for the GPU, as the basemap workers make it (the
+     * tessellation module): its polygons as for `setVectorTile` (picked here; their prisms built here if drawn in
+     * relief while `prism` is false), the vertices of its fills (`shapes::Vertex` as bytes, each with its feature),
+     * their triangles, per sublayer its top cap and the rest of its prism (`fill_ranges`: four numbers, first and
+     * end of each), its line pieces (`pieces::Piece` as bytes), the line table (feature and length of each line),
+     * per sublayer its pieces (`line_ranges`: first, end), the blocks of its extrusion sublayers (`shapes::Block` as
+     * bytes), their triangles, per sublayer its blocks' triangles (`block_ranges`: first, end), the extent of its
+     * points (`bounds`: min x, min y, max x, max y), `feature_count` features
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the vertices, pieces or blocks are cut short, when a WebGL object of the tile cannot be
+     * created, or when its features or lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * @param {number} id
+     * @param {number} key
+     * @param {Float64Array} points
+     * @param {Uint32Array} ring_start
+     * @param {Uint32Array} polygon_start
+     * @param {Uint32Array} polygon_feature
+     * @param {Uint32Array} fill_start
+     * @param {Uint8Array} vertices
+     * @param {Uint32Array} indices
+     * @param {Uint32Array} fill_ranges
+     * @param {boolean} prism
+     * @param {Uint8Array} pieces
+     * @param {Float32Array} line_table
+     * @param {Uint32Array} line_ranges
+     * @param {Uint8Array} blocks
+     * @param {Uint32Array} block_indices
+     * @param {Uint32Array} block_ranges
+     * @param {Float64Array} bounds
+     * @param {number} feature_count
+     */
+    setVectorTileMesh(id, key, points, ring_start, polygon_start, polygon_feature, fill_start, vertices, indices, fill_ranges, prism, pieces, line_table, line_ranges, blocks, block_indices, block_ranges, bounds, feature_count) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(polygon_start, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(polygon_feature, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(fill_start, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray8ToWasm0(vertices, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray32ToWasm0(indices, wasm.__wbindgen_malloc);
+        const len6 = WASM_VECTOR_LEN;
+        const ptr7 = passArray32ToWasm0(fill_ranges, wasm.__wbindgen_malloc);
+        const len7 = WASM_VECTOR_LEN;
+        const ptr8 = passArray8ToWasm0(pieces, wasm.__wbindgen_malloc);
+        const len8 = WASM_VECTOR_LEN;
+        const ptr9 = passArrayF32ToWasm0(line_table, wasm.__wbindgen_malloc);
+        const len9 = WASM_VECTOR_LEN;
+        const ptr10 = passArray32ToWasm0(line_ranges, wasm.__wbindgen_malloc);
+        const len10 = WASM_VECTOR_LEN;
+        const ptr11 = passArray8ToWasm0(blocks, wasm.__wbindgen_malloc);
+        const len11 = WASM_VECTOR_LEN;
+        const ptr12 = passArray32ToWasm0(block_indices, wasm.__wbindgen_malloc);
+        const len12 = WASM_VECTOR_LEN;
+        const ptr13 = passArray32ToWasm0(block_ranges, wasm.__wbindgen_malloc);
+        const len13 = WASM_VECTOR_LEN;
+        const ptr14 = passArrayF64ToWasm0(bounds, wasm.__wbindgen_malloc);
+        const len14 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setVectorTileMesh(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, prism, ptr8, len8, ptr9, len9, ptr10, len10, ptr11, len11, ptr12, len12, ptr13, len13, ptr14, len14, feature_count);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Adds or replaces tile `key` of a vector tile layer: its polygons as for `addFills` (`fill_start`: the first
+     * polygon of each sublayer, and the end; those of an extrusion sublayer raised into blocks), its lines as for
+     * `addLines` (`line_start`: the first line of each sublayer, and the end), `feature_count` features, styled as an
+     * extrusion layer's (`setFeatureStyle` with the key: a color, then a line's width or a block's height and base);
+     * `tile`: the corners of the tile they are cut to (west, north, east, south; empty: none), along whose edges no
+     * wall of a block rises
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object of the tile cannot be created, or when its features or lines need a
+     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * @param {number} id
+     * @param {number} key
+     * @param {Float64Array} points
+     * @param {Uint32Array} ring_start
+     * @param {Uint32Array} polygon_start
+     * @param {Uint32Array} polygon_feature
+     * @param {Uint32Array} fill_start
+     * @param {Float64Array} line_points
+     * @param {Uint32Array} line_first
+     * @param {Uint32Array} line_feature
+     * @param {Uint32Array} line_start
+     * @param {number} feature_count
+     * @param {Float64Array} tile
+     */
+    setVectorTile(id, key, points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, feature_count, tile) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(polygon_start, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(polygon_feature, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(fill_start, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArrayF64ToWasm0(line_points, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray32ToWasm0(line_first, wasm.__wbindgen_malloc);
+        const len6 = WASM_VECTOR_LEN;
+        const ptr7 = passArray32ToWasm0(line_feature, wasm.__wbindgen_malloc);
+        const len7 = WASM_VECTOR_LEN;
+        const ptr8 = passArray32ToWasm0(line_start, wasm.__wbindgen_malloc);
+        const len8 = WASM_VECTOR_LEN;
+        const ptr9 = passArrayF64ToWasm0(tile, wasm.__wbindgen_malloc);
+        const len9 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setVectorTile(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, feature_count, ptr9, len9);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * 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
@@ -1109,6 +1392,14 @@ export class Engine {
         const ret = wasm.engine_stats(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Moves a flow layer's particles by `seconds` of the page's time (one animation frame), in the current view
+     * @param {number} id
+     * @param {number} seconds
+     */
+    stepFlow(id, seconds) {
+        wasm.engine_stepFlow(this.__wbg_ptr, id, seconds);
+    }
     /**
      * 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
@@ -1199,6 +1490,20 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
     }
+    /**
+     * Vector tiles (512 CSS pixels across at their level, as `MapLibre`'s) for the view of the last frame (else the
+     * camera's), levels `min_z` to `max_z`, three numbers per tile (z, x, y), the nearest to the eye first: what a
+     * vector tile layer draws (`addVectorTiles`), coarser far away in a tilted view as the raster layers
+     * @param {number} min_z
+     * @param {number} max_z
+     * @returns {Uint32Array}
+     */
+    vectorTilesInView(min_z, max_z) {
+        const ret = wasm.engine_vectorTilesInView(this.__wbg_ptr, min_z, max_z);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
     /**
      * 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
@@ -1880,6 +2185,12 @@ function __wbg_get_imports() {
         __wbg_pixelStorei_cb4e43466f5b8703: function(arg0, arg1, arg2) {
             arg0.pixelStorei(arg1 >>> 0, arg2);
         },
+        __wbg_polygonOffset_81dc8ca84e29572b: function(arg0, arg1, arg2) {
+            arg0.polygonOffset(arg1, arg2);
+        },
+        __wbg_polygonOffset_8f922d9173d8849d: function(arg0, arg1, arg2) {
+            arg0.polygonOffset(arg1, arg2);
+        },
         __wbg_prototypesetcall_8b03c01e2c0f8066: function(arg0, arg1, arg2) {
             Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
         },
@@ -2218,7 +2529,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: 92, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 110, 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;
         },