isard 1.1.0 → 1.3.0

package/dist/wasm/isard.js

@@ -1,5 +1,9 @@
 /* @ts-self-types="./isard.d.ts" */
 
+/**
+ * A map on one canvas: its WebGL2 context, camera, ground (raster layers over the relief) and the layers over it.
+ * Draws only when `render` is called (the JavaScript side calls it after `redraw` asks for a frame)
+ */
 export class Engine {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -13,6 +17,11 @@ export class Engine {
     }
     /**
      * Circle layer of `feature_count` features: points (Mercator [0, 1], interleaved) and the feature of each
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
      * @param {Float64Array} points
      * @param {Uint32Array} feature
      * @param {number} feature_count
@@ -43,6 +52,11 @@ export class Engine {
     }
     /**
      * An empty extrusion layer: its blocks come in batches (`setExtrusionBatch`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log)
      * @returns {number}
      */
     addExtrusions() {
@@ -56,6 +70,11 @@ export class Engine {
      * Fill layer of `feature_count` features: polygons given by their points (Mercator [0, 1], interleaved), the first
      * point of each ring (`ring_start`, one more entry than rings), the first ring of each polygon (`polygon_start`,
      * one more entry than polygons; the first ring is the outer one, the others holes) and the feature of each polygon
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
      * @param {Float64Array} points
      * @param {Uint32Array} ring_start
      * @param {Uint32Array} polygon_start
@@ -82,6 +101,10 @@ export class Engine {
      * 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
      * come back with the shader's info log (line numbers of `code`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `code` does not compile or link, with the shader's info log
      * @param {string} code
      * @param {number} anchor_x
      * @param {number} anchor_y
@@ -103,6 +126,11 @@ export class Engine {
     /**
      * Line layer of `feature_count` features: polylines given by their points (Mercator [0, 1], interleaved), the
      * first point of each (`start`, one more entry than lines) and the feature each one belongs to
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log), or when the features or the lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
      * @param {Float64Array} points
      * @param {Uint32Array} start
      * @param {Uint32Array} feature
@@ -126,6 +154,11 @@ export class Engine {
      * A glTF / GLB model (its URL, a `blob:` one for data of the page) drawn at each instance of `instances`
      * (`INSTANCE_NUMBERS` numbers each: longitude, latitude, altitude, heading, pitch, roll in degrees, scale);
      * `ground`: altitudes above the relief, else above the ellipsoid
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log). A model that fails to load or decode does not throw: the layer stays empty
      * @param {string} url
      * @param {Float64Array} instances
      * @param {boolean} ground
@@ -148,6 +181,12 @@ export class Engine {
      * edges (node index pairs, interleaved). `line_start` and `line_points`: the line of each edge from A to B, points
      * `line_start[e] .. line_start[e + 1]` of `line_points` (Mercator, interleaved; straight if fewer than two). `costs`: per edge, the
      * cost of travelling it from A to B then from B to A; without, values are interpolated along the edges.
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `style` is not 25 numbers, `edges` is not node pairs or names a node past
+     * those of `mercator`, the nodes or edges need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or when
+     * a WebGL object cannot be created or a shader fails to compile (the error carries its info log)
      * @param {Float64Array} mercator
      * @param {Uint32Array} edges
      * @param {Uint32Array | null | undefined} line_start
@@ -179,6 +218,11 @@ export class Engine {
      * A COPC point cloud from its URL (HTTP range requests). `resolve(wkt)` gives the CRS of the file from its WKT
      * (undefined if it has none): its inverse projection, whether its altitudes are above the geoid, the metres of
      * a unit of z; it may throw (an unknown CRS), the layer then stays empty
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log). The file itself is read later: a bad file, or a `resolve` that throws, leaves the layer empty
      * @param {string} url
      * @param {(wkt: string | undefined) => PointCloudCrs} resolve
      * @returns {number}
@@ -196,6 +240,10 @@ export class Engine {
      * Raster tiles in Web Mercator; `url` holds {z}, {x} and {y}. `size`: side of the tiles' textures (256 by
      * default); `loader`: draws each tile instead of fetching `url`, `(z, x, y, signal) => Promise<ImageBitmap |
      * null>`, an image of `size` × `size` (null: nothing there)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the texture holding the layer's tiles cannot be created
      * @param {string} url
      * @param {number} min_z
      * @param {number} max_z
@@ -216,6 +264,11 @@ export class Engine {
     }
     /**
      * An empty symbol layer
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
+     * info log)
      * @returns {number}
      */
     addSymbols() {
@@ -229,6 +282,11 @@ 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.
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when one of the layer's programs fails to compile or link (the error carries
+     * its info log). The tileset itself is read later: a bad one leaves the layer empty, it does not throw
      * @param {string} url
      * @param {number} max_error
      * @param {boolean | null} [geoid]
@@ -243,6 +301,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
@@ -255,6 +329,7 @@ export class Engine {
         return v1;
     }
     /**
+     * The camera as set or moved: center (degrees), zoom, pitch and bearing (degrees)
      * @returns {Camera}
      */
     camera() {
@@ -267,6 +342,9 @@ export class Engine {
     clearPanorama() {
         wasm.engine_clearPanorama(this.__wbg_ptr);
     }
+    /**
+     * Stops loading the tiles of the flight's destination (`preload`)
+     */
     clearPreload() {
         wasm.engine_clearPreload(this.__wbg_ptr);
     }
@@ -371,6 +449,11 @@ export class Engine {
     }
     /**
      * `redraw` is called when the engine needs a new frame (a tile arrived)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the canvas gives no WebGL2 context ("WebGL2 is not available"), or when a WebGL
+     * object of the globe, the sky or the raster pass cannot be created or one of their shaders fails to compile
      * @param {HTMLCanvasElement} canvas
      * @param {() => void} redraw
      */
@@ -473,6 +556,7 @@ export class Engine {
         return ret;
     }
     /**
+     * Removes batch `key` of an extrusion layer (nothing if there is none)
      * @param {number} id
      * @param {number} key
      */
@@ -480,12 +564,23 @@ export class Engine {
         wasm.engine_removeExtrusionBatch(this.__wbg_ptr, id, key);
     }
     /**
+     * Removes a layer and frees its GPU objects; the other layers forget it (a layer that referred to it)
      * @param {number} id
      */
     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`)
      * @returns {boolean}
      */
     render() {
@@ -536,6 +631,7 @@ export class Engine {
         wasm.engine_setAtmosphere(this.__wbg_ptr, ptr0, len0);
     }
     /**
+     * Color the canvas is cleared to (RGB 0-1), where neither ground nor sky is drawn
      * @param {number} r
      * @param {number} g
      * @param {number} b
@@ -561,6 +657,8 @@ export class Engine {
         wasm.engine_setBody(this.__wbg_ptr, radius, flattening, ptr0, len0, lowest, highest);
     }
     /**
+     * Sets the camera (degrees, the conventions of `MapLibre`): leaves a street-level view, and the camera keeps this
+     * center as the relief comes in
      * @param {number} lon
      * @param {number} lat
      * @param {number} zoom
@@ -593,6 +691,11 @@ export class Engine {
     }
     /**
      * Anchors of batch `key` on the linked network: per feature, node A, node B, cost from A, cost from B
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the batch's features need an anchor texture past the GPU's
+     * `MAX_TEXTURE_SIZE`, or when it cannot be created
      * @param {number} id
      * @param {number} key
      * @param {Float32Array} anchors
@@ -608,6 +711,11 @@ export class Engine {
     /**
      * Adds or replaces batch `key` of an extrusion layer: polygons as for `addFills`, `feature_count` features (the
      * feature style gives each its height and base height as its two sizes, metres)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when a WebGL buffer or vertex array of the batch cannot be created, or when
+     * `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
      * @param {number} id
      * @param {number} key
      * @param {Float64Array} points
@@ -668,10 +776,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]
@@ -744,6 +852,10 @@ export class Engine {
     /**
      * The glyph atlas shared by the symbol layers, one page: `width` × `height` bytes of signed distances
      * (allocated again, filled with `data` if given)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) as `setGlyphPages` does: a size that is not positive, or the texture not created
      * @param {number} width
      * @param {number} height
      * @param {Uint8Array | null} [data]
@@ -760,6 +872,11 @@ export class Engine {
      * The glyph atlas shared by the symbol layers, `pages` pages of `width` × `height` bytes of signed distances,
      * allocated again and empty (`updateGlyphPage` fills them). A glyph on page `p` at row `v` has the atlas
      * coordinate `v + p × height`
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), `pages`
+     * is not 1 to 256, or the atlas texture cannot be created
      * @param {number} width
      * @param {number} height
      * @param {number} pages
@@ -771,6 +888,7 @@ export class Engine {
         }
     }
     /**
+     * Moves the Mercator box (0-1) a ground layer shows in
      * @param {number} id
      * @param {number} min_x
      * @param {number} min_y
@@ -784,6 +902,11 @@ export class Engine {
      * Creates the texture of sampler `name` (`format`: r8, r8ui, r16ui, r16i, r32ui, r32f, rg16ui, rg32f, rgba8,
      * rgba8ui, rgba16ui, rgba32f; `depth` 0 for 2D, else a 2D array of that many layers; `linear` filtering for the
      * non-integer formats); `data`: its texels as bytes, or undefined for an empty texture
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) on an unknown `format`, a size not positive (or overflowing), `data` shorter
+     * than the texels, more textures than the layer takes, or a texture WebGL cannot create
      * @param {number} id
      * @param {string} name
      * @param {string} format
@@ -807,6 +930,11 @@ export class Engine {
     }
     /**
      * A uniform of a ground layer's code, as numbers
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the shader has no uniform `name` (one its code does not use is removed
+     * by the compiler)
      * @param {number} id
      * @param {string} name
      * @param {Float64Array} values
@@ -822,6 +950,7 @@ export class Engine {
         }
     }
     /**
+     * Shows or hides a ground layer (kept, with its uniforms and textures)
      * @param {number} id
      * @param {boolean} visible
      */
@@ -831,6 +960,11 @@ export class Engine {
     /**
      * The icon atlas shared by the symbol layers: `width` × `height` RGBA texels, premultiplied, allocated again
      * and empty (`updateIconAtlas` fills it)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), or the
+     * atlas texture cannot be created
      * @param {number} width
      * @param {number} height
      */
@@ -859,6 +993,11 @@ export class Engine {
     }
     /**
      * New lines for a line layer (same arguments as `addLines`, the same features)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or
+     * when it cannot be created; the layer then keeps its lines
      * @param {number} id
      * @param {Float64Array} points
      * @param {Uint32Array} start
@@ -948,6 +1087,10 @@ export class Engine {
     }
     /**
      * The image of camera `index` of the panorama (the images sharing the size of the first)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when WebGL refuses the upload of `image` into the panorama's texture
      * @param {number} index
      * @param {ImageBitmap} image
      */
@@ -963,6 +1106,11 @@ export class Engine {
      * 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`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `rotation` holds fewer than 9 numbers, or when a WebGL object cannot be created or a
+     * shader fails to compile (the error carries its info log)
      * @param {number} lon
      * @param {number} lat
      * @param {number} height
@@ -999,6 +1147,7 @@ export class Engine {
         wasm.engine_setPointCloudStyle(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2);
     }
     /**
+     * Opacity and saturation (0-1) of a raster layer; nothing for another id
      * @param {number} id
      * @param {number} opacity
      * @param {number} saturation
@@ -1029,17 +1178,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 +1234,11 @@ export class Engine {
      * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), their texts' boxes (min x, min y,
      * max x, max y, CSS pixels from the anchor), styles (36 floats each, see `LABEL_FLOATS`) and glyph and icon quads
      * (11 floats each, see `QUAD_FLOATS`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the labels need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or
+     * when it cannot be created; the layer then keeps its labels
      * @param {number} id
      * @param {Float64Array} anchors
      * @param {Float32Array} boxes
@@ -1091,6 +1268,10 @@ export class Engine {
      * above the ellipsoid, those of 3D Tiles; over France, on the Earth only), else left as served (the default);
      * `loader`: gives the
      * altitudes of each tile instead of fetching `url` (an encoding decoded by the page: Terrarium, Terrain-RGB)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the texture holding the relief's tiles cannot be created
      * @param {string | null | undefined} url
      * @param {number} exaggeration
      * @param {number | null | undefined} max_z
@@ -1128,12 +1309,171 @@ export class Engine {
         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);
     }
+    /**
+     * 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
      * 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`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when, on the first call, a WebGL object cannot be created or a shader fails to compile
+     * (the error carries its info log)
      * @param {Float64Array} observers
      * @param {Float32Array} visible
      * @param {Float32Array} hidden
@@ -1155,6 +1495,7 @@ export class Engine {
         }
     }
     /**
+     * Lowest and highest zoom levels the camera accepts
      * @param {number} min
      * @param {number} max
      */
@@ -1251,6 +1592,11 @@ export class Engine {
     }
     /**
      * Replaces a region of a ground layer's texture (one layer of a 2D array)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when there is no texture `name`, or when the region is out of its bounds or
+     * `data` holds too few bytes
      * @param {number} id
      * @param {string} name
      * @param {number} x
@@ -1283,6 +1629,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
@@ -1296,6 +1656,7 @@ export class Engine {
         return v1;
     }
     /**
+     * Zooms by `delta` levels around a screen point (CSS pixels), which keeps the same ground point under it
      * @param {number} delta
      * @param {number} x
      * @param {number} y
@@ -2178,6 +2539,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_06eb15da165dee8f: function(arg0, arg1, arg2) {
             Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), arg2);
         },
@@ -2541,7 +2908,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: 198, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 214, 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;
         },