isard 1.5.0 → 1.7.0

package/dist/wasm/isard_core.js

@@ -632,7 +632,7 @@ 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)
+     * feature style gives each its height and base height as its two sizes, metres), each polygon's roof (`Roofs`)
      *
      * # Errors
      *
@@ -645,8 +645,11 @@ export class Engine {
      * @param {Uint32Array} polygon_start
      * @param {Uint32Array} feature
      * @param {number} feature_count
+     * @param {Uint8Array} roofs
+     * @param {Float32Array} roof_heights
+     * @param {number} metres
      */
-    setExtrusionBatch(id, key, points, ring_start, polygon_start, feature, feature_count) {
+    setExtrusionBatch(id, key, points, ring_start, polygon_start, feature, feature_count, roofs, roof_heights, metres) {
         const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
@@ -655,11 +658,23 @@ export class Engine {
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArray32ToWasm0(feature, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setExtrusionBatch(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, feature_count);
+        const ptr4 = passArray8ToWasm0(roofs, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArrayF32ToWasm0(roof_heights, wasm.__wbindgen_malloc);
+        const len5 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setExtrusionBatch(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, feature_count, ptr4, len4, ptr5, len5, metres);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * Whether the buildings of an extrusion layer, or of a vector tiles layer, show their windows on their walls
+     * @param {number} id
+     * @param {boolean} on
+     */
+    setFacades(id, on) {
+        wasm.engine_setFacades(this.__wbg_ptr, id, on);
+    }
     /**
      * Layer-wide style of a feature layer: opacity as zoom stops (four zooms then four values), the zoom range it
      * shows in (`min_zoom` included, `max_zoom` excluded), whether it shows at all
@@ -1138,25 +1153,27 @@ export class Engine {
     }
     /**
      * Layer-wide style of a symbol layer: size scale and opacity as zoom stops (four zooms then four values each),
-     * zoom range, visibility
+     * zoom range, visibility, hidden by the buildings
      * @param {number} id
      * @param {Float32Array} size
      * @param {Float32Array} opacity
      * @param {number} min_zoom
      * @param {number} max_zoom
      * @param {boolean} visible
+     * @param {boolean} occluded
      */
-    setSymbolLayer(id, size, opacity, min_zoom, max_zoom, visible) {
+    setSymbolLayer(id, size, opacity, min_zoom, max_zoom, visible, occluded) {
         const ptr0 = passArrayF32ToWasm0(size, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(opacity, wasm.__wbindgen_malloc);
         const len1 = WASM_VECTOR_LEN;
-        wasm.engine_setSymbolLayer(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, min_zoom, max_zoom, visible);
+        wasm.engine_setSymbolLayer(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, min_zoom, max_zoom, visible, occluded);
     }
     /**
      * 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`)
+     * max x, max y, CSS pixels from the anchor), styles (37 floats each, see `LABEL_FLOATS`), glyph and icon quads
+     * (11 floats each, see `QUAD_FLOATS`) and the lines their curved texts follow (`paths`: for each label, its number
+     * of points, the index of its anchor among them, then the points, Mercator; 0, 0 and none for the others)
      *
      * # Errors
      *
@@ -1167,8 +1184,9 @@ export class Engine {
      * @param {Float32Array} boxes
      * @param {Float32Array} styles
      * @param {Float32Array} quads
+     * @param {Float64Array} paths
      */
-    setSymbols(id, anchors, boxes, styles, quads) {
+    setSymbols(id, anchors, boxes, styles, quads, paths) {
         const ptr0 = passArrayF64ToWasm0(anchors, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF32ToWasm0(boxes, wasm.__wbindgen_malloc);
@@ -1177,7 +1195,9 @@ export class Engine {
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArrayF32ToWasm0(quads, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setSymbols(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        const ptr4 = passArrayF64ToWasm0(paths, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setSymbols(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1210,11 +1230,15 @@ export class Engine {
         }
     }
     /**
-     * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion), its zoom range
+     * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion, 3
+     * circle), 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)
+     * lines glow at night (streets; 0 or 1), the joins of its lines (two numbers: 0 round, 1 miter, 2 bevel, then the
+     * miter limit in line widths; missing: round), the translation of its fills or lines (three numbers: x and y in CSS
+     * pixels, x right and y down, then 0 if it turns with the map, 1 if it stays on the screen; missing: none), whether its
+     * fills have patterns (0 or 1)
      * @param {number} id
      * @param {Uint8Array} kinds
      * @param {Float64Array} zooms
@@ -1223,8 +1247,11 @@ export class Engine {
      * @param {Float32Array} opacities
      * @param {Uint8Array} caps
      * @param {Uint8Array} lit
+     * @param {Float32Array} joins
+     * @param {Float32Array} translates
+     * @param {Uint8Array} patterned
      */
-    setVectorSublayers(id, kinds, zooms, visible, dashes, opacities, caps, lit) {
+    setVectorSublayers(id, kinds, zooms, visible, dashes, opacities, caps, lit, joins, translates, patterned) {
         const ptr0 = passArray8ToWasm0(kinds, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArrayF64ToWasm0(zooms, wasm.__wbindgen_malloc);
@@ -1239,7 +1266,13 @@ export class Engine {
         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);
+        const ptr7 = passArrayF32ToWasm0(joins, wasm.__wbindgen_malloc);
+        const len7 = WASM_VECTOR_LEN;
+        const ptr8 = passArrayF32ToWasm0(translates, wasm.__wbindgen_malloc);
+        const len8 = WASM_VECTOR_LEN;
+        const ptr9 = passArray8ToWasm0(patterned, wasm.__wbindgen_malloc);
+        const len9 = WASM_VECTOR_LEN;
+        wasm.engine_setVectorSublayers(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9);
     }
     /**
      * Adds or replaces tile `key` of a vector tile layer ready for the GPU, as the basemap workers make it (the
@@ -1311,13 +1344,36 @@ export class Engine {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * The points of tile `key` of a vector tile layer, after the tile itself (`setVectorTile`, `setVectorTileMesh`):
+     * Mercator, interleaved, each with its feature (styled as a circle's: a color, a radius and a stroke width, then the
+     * stroke's color), `start` the first point of each sublayer and the end; the circle sublayers draw theirs
+     * @param {number} id
+     * @param {number} key
+     * @param {Float64Array} points
+     * @param {Uint32Array} feature
+     * @param {Uint32Array} start
+     */
+    setVectorTilePoints(id, key, points, feature, start) {
+        const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(feature, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(start, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.engine_setVectorTilePoints(this.__wbg_ptr, id, key, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
     /**
      * 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
+     * wall of a block rises; `roofs` and `roof_heights`: per polygon, the shape and height of its block's roof
+     * (`shapes::Roofs`: 0 flat, 1 to 5 `RoofShape::number`, 255 generated from its outline; metres, not a number: as
+     * its slopes make it; empty: flat), the whole outlines of the buildings the tile cuts (`roof_outlines`, interleaved
+     * Mercator points, `roof_outline_start`: where each polygon's starts, and the end), `roof_metres` the metres per
+     * Mercator unit at the tile
      *
      * # Errors
      *
@@ -1336,8 +1392,13 @@ export class Engine {
      * @param {Uint32Array} line_start
      * @param {number} feature_count
      * @param {Float64Array} tile
+     * @param {Uint8Array} roofs
+     * @param {Float32Array} roof_heights
+     * @param {Float64Array} roof_outlines
+     * @param {Uint32Array} roof_outline_start
+     * @param {number} roof_metres
      */
-    setVectorTile(id, key, points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, feature_count, tile) {
+    setVectorTile(id, key, points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, feature_count, tile, roofs, roof_heights, roof_outlines, roof_outline_start, roof_metres) {
         const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
@@ -1358,7 +1419,15 @@ export class Engine {
         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);
+        const ptr10 = passArray8ToWasm0(roofs, wasm.__wbindgen_malloc);
+        const len10 = WASM_VECTOR_LEN;
+        const ptr11 = passArrayF32ToWasm0(roof_heights, wasm.__wbindgen_malloc);
+        const len11 = WASM_VECTOR_LEN;
+        const ptr12 = passArrayF64ToWasm0(roof_outlines, wasm.__wbindgen_malloc);
+        const len12 = WASM_VECTOR_LEN;
+        const ptr13 = passArray32ToWasm0(roof_outline_start, wasm.__wbindgen_malloc);
+        const len13 = 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, ptr10, len10, ptr11, len11, ptr12, len12, ptr13, len13, roof_metres);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
@@ -1511,6 +1580,17 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
     }
+    /**
+     * Uploads a part more of the blocks of tile `key` of a vector tile layer (a large tile's, a part at a time over
+     * several frames); whether some are left. Its blocks are drawn once they are all there
+     * @param {number} id
+     * @param {number} key
+     * @returns {boolean}
+     */
+    uploadVectorTile(id, key) {
+        const ret = wasm.engine_uploadVectorTile(this.__wbg_ptr, id, key);
+        return ret !== 0;
+    }
     /**
      * 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
@@ -1682,6 +1762,12 @@ function __wbg_get_imports() {
         __wbg_bufferData_bad7ce562b6a9eac: function(arg0, arg1, arg2, arg3) {
             arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
         },
+        __wbg_bufferSubData_22c4c420e0f67cda: function(arg0, arg1, arg2, arg3) {
+            arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
+        },
+        __wbg_bufferSubData_8609cd8a2c013181: function(arg0, arg1, arg2, arg3) {
+            arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
+        },
         __wbg_byteLength_27689b065d089962: function(arg0) {
             const ret = arg0.byteLength;
             return ret;
@@ -2550,7 +2636,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: 110, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 116, 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;
         },

package/dist/wasm/isard_tess.d.ts

@@ -58,17 +58,20 @@ export class TessellatedTile {
  * (interleaved points, `ring_start`, `polygon_start`, the feature of each, `fill_start`: the first polygon of each
  * sublayer and the end), its lines (interleaved points, `line_first`: the first point of each, the feature of each,
  * `line_start`: the first line of each sublayer and the end); `raised`: per sublayer, whether its polygons are extruded
- * into blocks rather than filled; `prism`: with the prisms the fills need over the relief; `tile`: the corners of the
+ * into blocks rather than filled; `roofs` and `roof_heights`: per polygon, the shape and height of its block's roof
+ * (`shapes::Roofs`; empty: flat), the whole outlines of the buildings the tile cuts (`roof_outlines`, interleaved
+ * Mercator points, `roof_outline_start`: where each polygon's starts, and the end), `roof_metres` the metres per
+ * Mercator unit at the tile; `prism`: with the prisms the fills need over the relief; `tile`: the corners of the
  * tile they are cut to (west, north, east, south, Mercator; empty: none), along whose edges no wall of a block rises
  */
-export function tessellateVectorTile(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, raised: Uint8Array, prism: boolean, tile: Float64Array): TessellatedTile;
+export function tessellateVectorTile(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, raised: Uint8Array, roofs: Uint8Array, roof_heights: Float32Array, roof_outlines: Float64Array, roof_outline_start: Uint32Array, roof_metres: number, prism: boolean, tile: Float64Array): TessellatedTile;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_tessellatedtile_free: (a: number, b: number) => void;
-    readonly tessellateVectorTile: (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) => number;
+    readonly tessellateVectorTile: (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) => number;
     readonly tessellatedtile_blockIndices: (a: number) => any;
     readonly tessellatedtile_blockRanges: (a: number) => [number, number];
     readonly tessellatedtile_blocks: (a: number) => any;

package/dist/wasm/isard_tess.js

@@ -124,7 +124,10 @@ if (Symbol.dispose) TessellatedTile.prototype[Symbol.dispose] = TessellatedTile.
  * (interleaved points, `ring_start`, `polygon_start`, the feature of each, `fill_start`: the first polygon of each
  * sublayer and the end), its lines (interleaved points, `line_first`: the first point of each, the feature of each,
  * `line_start`: the first line of each sublayer and the end); `raised`: per sublayer, whether its polygons are extruded
- * into blocks rather than filled; `prism`: with the prisms the fills need over the relief; `tile`: the corners of the
+ * into blocks rather than filled; `roofs` and `roof_heights`: per polygon, the shape and height of its block's roof
+ * (`shapes::Roofs`; empty: flat), the whole outlines of the buildings the tile cuts (`roof_outlines`, interleaved
+ * Mercator points, `roof_outline_start`: where each polygon's starts, and the end), `roof_metres` the metres per
+ * Mercator unit at the tile; `prism`: with the prisms the fills need over the relief; `tile`: the corners of the
  * tile they are cut to (west, north, east, south, Mercator; empty: none), along whose edges no wall of a block rises
  * @param {Float64Array} points
  * @param {Uint32Array} ring_start
@@ -136,11 +139,16 @@ if (Symbol.dispose) TessellatedTile.prototype[Symbol.dispose] = TessellatedTile.
  * @param {Uint32Array} line_feature
  * @param {Uint32Array} line_start
  * @param {Uint8Array} raised
+ * @param {Uint8Array} roofs
+ * @param {Float32Array} roof_heights
+ * @param {Float64Array} roof_outlines
+ * @param {Uint32Array} roof_outline_start
+ * @param {number} roof_metres
  * @param {boolean} prism
  * @param {Float64Array} tile
  * @returns {TessellatedTile}
  */
-export function tessellateVectorTile(points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, raised, prism, tile) {
+export function tessellateVectorTile(points, ring_start, polygon_start, polygon_feature, fill_start, line_points, line_first, line_feature, line_start, raised, roofs, roof_heights, roof_outlines, roof_outline_start, roof_metres, prism, tile) {
     const ptr0 = passArrayF64ToWasm0(points, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     const ptr1 = passArray32ToWasm0(ring_start, wasm.__wbindgen_malloc);
@@ -161,9 +169,17 @@ export function tessellateVectorTile(points, ring_start, polygon_start, polygon_
     const len8 = WASM_VECTOR_LEN;
     const ptr9 = passArray8ToWasm0(raised, wasm.__wbindgen_malloc);
     const len9 = WASM_VECTOR_LEN;
-    const ptr10 = passArrayF64ToWasm0(tile, wasm.__wbindgen_malloc);
+    const ptr10 = passArray8ToWasm0(roofs, wasm.__wbindgen_malloc);
     const len10 = WASM_VECTOR_LEN;
-    const ret = wasm.tessellateVectorTile(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, prism, ptr10, len10);
+    const ptr11 = passArrayF32ToWasm0(roof_heights, wasm.__wbindgen_malloc);
+    const len11 = WASM_VECTOR_LEN;
+    const ptr12 = passArrayF64ToWasm0(roof_outlines, wasm.__wbindgen_malloc);
+    const len12 = WASM_VECTOR_LEN;
+    const ptr13 = passArray32ToWasm0(roof_outline_start, wasm.__wbindgen_malloc);
+    const len13 = WASM_VECTOR_LEN;
+    const ptr14 = passArrayF64ToWasm0(tile, wasm.__wbindgen_malloc);
+    const len14 = WASM_VECTOR_LEN;
+    const ret = wasm.tessellateVectorTile(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, ptr11, len11, ptr12, len12, ptr13, len13, roof_metres, prism, ptr14, len14);
     return TessellatedTile.__wrap(ret);
 }
 function __wbg_get_imports() {
@@ -274,6 +290,13 @@ function passArray8ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArrayF64ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 8, 8) >>> 0;
     getFloat64ArrayMemory0().set(arg, ptr / 8);

package/dist/workers/basemap/furniture.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The street furniture of a tile, from OpenMapTiles' layers: its points of interest of the street where they stand
+ * (bus stops' shelters, waste baskets, post boxes, drinking fountains, bicycle racks), each facing the nearest street;
+ * benches along the pedestrian streets and the paths of the parks and gardens. The same each time the tile is cut
+ */
+import type { Priority } from '../basemap.worker.ts';
+import { type Renderer } from './tiles.ts';
+/**
+ * The street furniture of a tile: longitude, latitude, scale, heading (degrees, facing its street or path), rank (in
+ * [0, 1): the page keeps the lowest far from the view) and kind (`FURNITURE`' index) of each, as things placed
+ * (`PLACED_NUMBERS`); past `maxObjects`, thinned evenly
+ */
+export declare const furniture: (r: Renderer, z: number, x: number, y: number, id: number, maxObjects: number, priority?: Priority) => Promise<Float64Array<ArrayBufferLike> | undefined>;

package/dist/workers/basemap/geometry.d.ts

@@ -1,7 +1,9 @@
 /** A vector tile cut into geometry for the engine: the polygons of the extrusions, the fills, lines and buildings of
  * `vectors()` with their style per feature, made ready for the GPU by the tessellation module */
-import type { Value } from '../../basemap/mvt.ts';
-import type { Priority, TileMesh, TileVectors } from '../basemap.worker.ts';
+import type { TileFeature, Value } from '../../basemap/mvt.ts';
+import { type StyleLayer } from '../../basemap/vectorstyle.ts';
+import { type RoofMode } from '../../util/roofs.ts';
+import type { Priority, TileMesh, TileStyles, TileVectors } from '../basemap.worker.ts';
 import { type Renderer } from './tiles.ts';
 /**
  * The polygons of a tile's features in the renderer's fill layers (each feature once, whichever layers keep it), in
@@ -17,11 +19,39 @@ export declare const polygons: (r: Renderer, z: number, x: number, y: number, id
     };
     properties: Record<string, Value>[];
 } | undefined>;
+/** The landmarks of a tile: its points of interest of `LANDMARKS` (x, y interleaved, tile units) */
+export declare const landmarksOf: (layers: Map<string, {
+    features: TileFeature[];
+}> | undefined) => number[];
+/** Whether a building's rings (tile units) hold one of the landmarks' points */
+export declare const holdsLandmark: (rings: readonly (readonly number[])[], points: readonly number[]) => boolean;
+/**
+ * The buildings of a layer that are landmarks: those holding a landmark's point (`holdsLandmark`), and the parts of
+ * those (a building whose middle is inside one of them, or that holds one's middle: the stage tower, the dome). Their
+ * walls along each other drawn alike, not one floodlit fighting a dark one as the view moves; a neighbour against a
+ * landmark's wall, its middle outside, is none
+ */
+export declare const landmarkBuildings: (features: readonly TileFeature[], points: readonly number[]) => Set<TileFeature>;
+/** A building's roof for the engine: its shape's number (`roofShapeOf`; 0 none) and height (`roofHeightOf`) */
+export declare const roofOf: (properties: Record<string, Value>, mode: RoofMode) => [number, number];
+/**
+ * The zooms a feature shows over by its layer's filter, as MapLibre evaluates a filter (at the whole zoom under the
+ * camera's): its filter at each whole zoom of the range a tile of level `z` is drawn over (`z - 1` to `last`), from
+ * the first where it holds to past the last (open at the ends of the range, `[0, 0]` for a filter that does not read
+ * the zoom); undefined if it holds at none
+ */
+export declare const filterZooms: (layer: StyleLayer, feature: TileFeature, z: number, last: number) => [number, number] | undefined;
 /**
  * A ring cut to the square [0, `extent`] (Sutherland–Hodgman), its points interleaved, unclosed: a polygon lying
  * across the tile's edge keeps its part in the tile, along the edge
  */
 export declare const clipRing: (ring: readonly number[], extent: number) => number[];
+/**
+ * A line with the points dropped that lie within `tolerance` of the line through their neighbours kept (Douglas–
+ * Peucker): a sequence of photos every few metres (Panoramax's) drawn as many pieces under a pixel, each as wide as the
+ * line, covered a pixel ten times over
+ */
+export declare const simplifyLine: (line: readonly number[], tolerance: number) => number[];
 /** A line cut to the square [0, `extent`] (Liang–Barsky per segment): its runs inside, each two points at least */
 export declare const clipLine: (line: readonly number[], extent: number) => number[][];
 /**
@@ -36,30 +66,13 @@ export declare const overzoomed: (geometry: readonly (readonly number[])[], exte
  * zooms over the range the tile is drawn at); with `stylesOnly`, the styles alone. Patterns, outlines and circles are
  * left to the raster path
  */
-export declare const vectors: (r: Renderer, { z, x, y, deepest }: {
+export declare const vectors: (r: Renderer, { z, x, y, deepest, roofs: roofMode, }: {
     z: number;
     x: number;
     y: number;
     deepest?: number;
-}, id: number, stylesOnly: boolean, priority?: Priority) => Promise<Float32Array<ArrayBuffer> | {
-    fills: {
-        points: Float64Array<ArrayBuffer>;
-        ringStart: Uint32Array<ArrayBuffer>;
-        polygonStart: Uint32Array<ArrayBuffer>;
-        feature: Uint32Array<ArrayBuffer>;
-        fillStart: Uint32Array<ArrayBuffer>;
-    };
-    lines: {
-        points: Float64Array<ArrayBuffer>;
-        start: Uint32Array<ArrayBuffer>;
-        feature: Uint32Array<ArrayBuffer>;
-        lineStart: Uint32Array<ArrayBuffer>;
-    };
-    styles: Float32Array<ArrayBuffer>;
-    tile: Float64Array<ArrayBuffer>;
-    properties: Record<string, Value>[];
-    sublayer: Uint16Array<ArrayBuffer>;
-} | undefined>;
+    roofs?: RoofMode;
+}, id: number, stylesOnly: boolean, priority?: Priority) => Promise<TileVectors | TileStyles | undefined>;
 /** The tessellation module: where it is, and once loaded whether it works (false: the main thread does its work) */
 export declare const tess: {
     url?: string;

package/dist/workers/basemap/labels.d.ts

@@ -1,8 +1,24 @@
 /** The label candidates of a tile: the texts and icons of the style's symbol layers, for the page to shape and place */
+import type { TileFeature } from '../../basemap/mvt.ts';
 import { type LabelCandidate } from '../../basemap/vectorstyle.ts';
 import type { Priority } from '../basemap.worker.ts';
 import { type Renderer } from './tiles.ts';
 /** Points every `spacing` along a line (tile units, x and y interleaved), the first half a spacing in (the middle of a
- * shorter line): each point and the segment it lies on (x, y, x0, y0, x1, y1) */
+ * shorter line): each point, the segment it lies on and how far along the line it is (x, y, x0, y0, x1, y1, the
+ * distance) */
 export declare const lineAnchors: (line: readonly number[], spacing: number) => number[][];
-export declare const labels: (r: Renderer, z: number, x: number, y: number, id: number, priority?: Priority, zoom?: number) => Promise<LabelCandidate[]>;
+/** The point `offset` (tile units) beside a line's anchor (`lineAnchors`), the `k`th anchor's on one side of the line,
+ * the next one's on the other: x, y and its heading facing the line (degrees; y towards the south in the tile) */
+export declare const besideLine: (anchor: readonly number[], k: number, offset: number) => [x: number, y: number, heading: number];
+/** The part of a line (tile units, interleaved) from `from` to `to` along it (distances from its start) */
+export declare const lineBetween: (line: readonly number[], from: number, to: number) => number[];
+/**
+ * The height of the building under a point of a tile (its units), the highest if several: the buildings of the
+ * style's `fill-extrusion` layers shown at `zoom`, at their `fill-extrusion-height`; undefined outside them. A label
+ * there stands on its roof, not hidden by its walls. The buildings found through a grid of the tile's squares
+ */
+export declare const roofsOf: (r: Renderer, layers: Map<string, {
+    extent: number;
+    features: TileFeature[];
+}>, zoom: number) => ((px: number, py: number) => number | undefined);
+export declare const labels: (r: Renderer, z: number, x: number, y: number, id: number, priority?: Priority, zoom?: number, roofs?: boolean) => Promise<LabelCandidate[]>;

package/dist/workers/basemap/lamps.d.ts

@@ -0,0 +1,10 @@
+/** The street lamps of a tile: points along its streets, on one side then the other, the same each time the tile is cut */
+import type { Priority } from '../basemap.worker.ts';
+import { type Renderer } from './tiles.ts';
+/**
+ * Lamps along the lines of the renderer's layers in a tile, `spacing` metres apart along each street, every other
+ * one on its other side, as far from its middle as its class says (`SIDE_METRES`): longitude, latitude, scale, heading
+ * (degrees, facing the street) and rank (in [0, 1): the page keeps the lowest far from the view) of each, as things
+ * placed (`PLACED_NUMBERS`, the kind 0); past `maxLamps`, thinned evenly. A street in several layers has its lamps once
+ */
+export declare const lamps: (r: Renderer, z: number, x: number, y: number, id: number, spacing: number, maxLamps: number, priority?: Priority) => Promise<Float64Array<ArrayBufferLike> | undefined>;

package/dist/workers/basemap/tiles.d.ts

@@ -47,6 +47,8 @@ export declare const aborted: Set<number>;
 export declare const image: (url: string, priority?: Priority) => Promise<ImageBitmap | undefined>;
 /** A vector tile, decoded (shared by every renderer of its URL); the first request's priority fetches it */
 export declare const tile: (url: string, priority?: Priority) => Promise<Map<string, TileLayer> | undefined>;
+/** A tile's URL from its source's template */
+export declare const tileUrl: (template: string, z: number, x: number, y: number) => string;
 /** The vector tile to draw a raster tile from, and where the raster tile lies in it (tile units) */
 export declare const source: (r: Renderer, z: number, x: number, y: number) => {
     url: string;

package/dist/workers/basemap/trees.d.ts

@@ -1,6 +1,9 @@
 /** The trees of a tile: points scattered over the woods of its polygons, the same each time the tile is cut */
 import type { Priority } from '../basemap.worker.ts';
 import { type Renderer } from './tiles.ts';
+/** Things placed (`PLACED_NUMBERS` each), past `max` thinned evenly by their rank: one in so many kept, the
+ * same ones each time */
+export declare const thinned: (found: readonly number[], max: number) => Float64Array;
 /** A number in [0, 1) from four integers, the same for the same ones: where a tree stands in its cell, its size */
 export declare const treeHash: (a: number, b: number, c: number, d: number) => number;
 /** Whether a point lies in rings (interleaved points, unclosed or closed), even-odd: the holes cut out */
@@ -14,6 +17,8 @@ export declare const inRings: (rings: readonly (readonly number[])[], px: number
 export declare const scatter: (rings: readonly (readonly number[])[], extent: number, spacing: number, seed: [number, number, number], maxCells?: number) => [x: number, y: number, k: number][];
 /**
  * Trees over the polygons of the renderer's layers in a tile: longitude, latitude, scale (0.75 to 1.25), heading
- * (degrees) and rank (in [0, 1): the page keeps the lowest far from the view) of each, `spacing[s]` metres apart in layer `s` on a jittered grid; past `maxTrees`, thinned evenly
+ * (degrees), rank (in [0, 1): the page keeps the lowest far from the view) and kind (1 a conifer, as many as its wood's
+ * `coniferShare`, else 0) of each, `spacing[s]` metres apart in layer `s` on a jittered grid; past `maxTrees`, thinned
+ * evenly
  */
 export declare const trees: (r: Renderer, z: number, x: number, y: number, id: number, spacing: number[], maxTrees: number, priority?: Priority) => Promise<Float64Array<ArrayBuffer> | undefined>;

package/dist/workers/basemap.worker.d.ts

@@ -20,6 +20,7 @@ import { type PngEncoding } from '../basemap/terrain.ts';
 import { type LabelCandidate, type RasterSource, type StyleLayer } from '../basemap/vectorstyle.ts';
 import { type HeaderRules } from '../engine/requests.ts';
 import { type GridDescription, type StreetFlows } from '../grid-module.ts';
+import type { RoofMode } from '../util/roofs.ts';
 import { type StreetWork } from './basemap/street.ts';
 import { type Sprite } from './basemap/tiles.ts';
 export type { LabelCandidate, RasterSource, Sprite };
@@ -44,6 +45,8 @@ export type BasemapWork = {
     x: number;
     y: number;
     zoom?: number;
+    /** The labels in a building given its height (they stand on its roof) */
+    roofs?: boolean;
     priority?: Priority;
 }
 /** The polygons of the renderer's layers (buildings), for extrusions */
@@ -67,6 +70,29 @@ export type BasemapWork = {
     maxTrees: number;
     priority?: Priority;
 }
+/** The street furniture of the tile (OpenMapTiles' points of interest of the street, benches along the pedestrian
+ * streets and the parks' paths), at most `maxObjects` */
+ | {
+    type: 'furniture';
+    key: string;
+    z: number;
+    x: number;
+    y: number;
+    maxObjects: number;
+    priority?: Priority;
+}
+/** Street lamps along the lines of the renderer's layers, `spacing` metres apart along each street, at most
+ * `maxLamps` */
+ | {
+    type: 'lamps';
+    key: string;
+    z: number;
+    x: number;
+    y: number;
+    spacing: number;
+    maxLamps: number;
+    priority?: Priority;
+}
 /** The fills and lines of the renderer's layers cut to the tile, for the engine to draw as geometry; `styles`: their
  * style only, the layers' paint changed (the same features, in the same order). A tile past the source's deepest
  * level is cut from its tile of that level (overzoom); `deepest`, the deepest level asked for (default the
@@ -78,6 +104,8 @@ export type BasemapWork = {
     x: number;
     y: number;
     deepest?: number;
+    /** How the buildings' roofs are made (`RoofMode`) */
+    roofs?: RoofMode;
     styles?: boolean;
     /** With the prisms of the fills (a relief under them) */
     prism?: boolean;
@@ -158,11 +186,16 @@ export type BasemapResponse = {
     trees: Float64Array;
 } | {
     id: number;
-    vectors: TileVectors;
+    lamps: Float64Array;
 } | {
     id: number;
-    styles: Float32Array;
+    furniture: Float64Array;
 } | {
+    id: number;
+    vectors: TileVectors;
+} | ({
+    id: number;
+} & TileStyles) | {
     id: number;
     heights: Float32Array;
 } | {
@@ -196,6 +229,15 @@ export interface TileVectors {
         polygonStart: Uint32Array;
         feature: Uint32Array;
         fillStart: Uint32Array;
+        /** Per polygon, its block's roof: its shape's number (`RoofShape::number`, 255 generated) and height (metres) */
+        roofs?: Uint8Array;
+        roofHeights?: Float32Array;
+        /** The whole outlines of the buildings the tile cuts (Mercator, interleaved), where each polygon's starts (and the
+         * end; an empty one: whole) */
+        roofOutlines?: Float64Array;
+        roofOutlineStart?: Uint32Array;
+        /** Metres per Mercator unit at the tile */
+        roofMetres?: number;
     };
     lines: {
         points: Float64Array;
@@ -203,8 +245,17 @@ export interface TileVectors {
         feature: Uint32Array;
         lineStart: Uint32Array;
     };
+    /** The points of the circle sublayers (Mercator), each with its styled feature, and the first of each sublayer (and
+     * the end) */
+    circles?: {
+        points: Float64Array;
+        feature: Uint32Array;
+        circleStart: Uint32Array;
+    };
     /** The style of each styled feature, `FLOATS` (32) each, as the engine's line layers take it */
     styles: Float32Array;
+    /** The names of the fills' patterns its styles point at (`resolvePatterns`) */
+    patterns?: string[];
     /** The tile's corners (west, north, east, south, Mercator): no wall of a building along its edges, where one cut
      * there goes on in the next tile */
     tile?: Float64Array;
@@ -215,6 +266,11 @@ export interface TileVectors {
      * the engine does that on the main thread */
     mesh?: TileMesh;
 }
+/** The styles alone of a vector tile's features, restyled (as `TileVectors`'s) */
+export interface TileStyles {
+    styles: Float32Array;
+    patterns: string[];
+}
 /** A vector tile ready for the GPU, as the tessellation module makes it (`TessellatedTile`) */
 export interface TileMesh {
     /** Fill vertices, as bytes */