isard 0.3.0 → 0.5.0

package/dist/wasm/isard.js

@@ -29,6 +29,18 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * A layer drawn by the page: `render()` is called at its place in every frame (`customMatrix` gives the
+     * matrices of that frame meanwhile); `depth`: with the depth buffer of the 3D layers (`3d` mode), else over
+     * what is drawn before it
+     * @param {() => void} render
+     * @param {boolean} depth
+     * @returns {number}
+     */
+    addCustomLayer(render, depth) {
+        const ret = wasm.engine_addCustomLayer(this.__wbg_ptr, render, depth);
+        return ret >>> 0;
+    }
     /**
      * An empty extrusion layer: its blocks come in batches (`setExtrusionBatch`)
      * @returns {number}
@@ -110,6 +122,26 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * 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
+     * @param {string} url
+     * @param {Float64Array} instances
+     * @param {boolean} ground
+     * @returns {number}
+     */
+    addModels(url, instances, ground) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(instances, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_addModels(this.__wbg_ptr, ptr0, len0, ptr1, len1, ground);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * Network of `mercator.length / 2` nodes (Mercator [0, 1], y towards the south, interleaved: converted by the
      * JavaScript side, where `Math.tan` and `Math.log` are much faster than in WebAssembly) and `edges.length / 2`
@@ -143,6 +175,23 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * 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
+     * @param {string} url
+     * @param {(wkt: string | undefined) => PointCloudCrs} resolve
+     * @returns {number}
+     */
+    addPointCloud(url, resolve) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_addPointCloud(this.__wbg_ptr, ptr0, len0, resolve);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * 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 |
@@ -213,6 +262,24 @@ export class Engine {
     clearPreload() {
         wasm.engine_clearPreload(this.__wbg_ptr);
     }
+    /**
+     * Model-view-projection matrix (16 numbers, column-major, for `uniformMatrix4fv`) of the local frame at a
+     * longitude, latitude (degrees) and altitude (metres): x east, y north, z up, in metres. Undefined outside the
+     * callback of a custom layer. Static: the engine is borrowed while it draws
+     * @param {number} lon
+     * @param {number} lat
+     * @param {number} altitude
+     * @returns {Float32Array | undefined}
+     */
+    static customMatrix(lon, lat, altitude) {
+        const ret = wasm.engine_customMatrix(lon, lat, altitude);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself
      * @param {number} x
@@ -294,6 +361,35 @@ export class Engine {
         const ret = wasm.engine_pick(this.__wbg_ptr, x, y, !isLikeNone(radius), isLikeNone(radius) ? 0 : radius, ptr0, len0);
         return ret;
     }
+    /**
+     * What a point cloud says of itself, undefined before its head is read
+     * @param {number} id
+     * @returns {PointCloudInfo | undefined}
+     */
+    pointCloudInfo(id) {
+        const ret = wasm.engine_pointCloudInfo(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * The point of a point cloud picked by `pick` or `pollPick` (its index there), read back from the GPU; undefined
+     * once it is no longer drawn
+     * @param {number} id
+     * @param {number} index
+     * @returns {PointCloudPoint | undefined}
+     */
+    pointCloudPoint(id, index) {
+        const ret = wasm.engine_pointCloudPoint(this.__wbg_ptr, id, index);
+        return ret;
+    }
+    /**
+     * Counters of a point cloud layer, undefined if there is none with this id
+     * @param {number} id
+     * @returns {PointCloudStats | undefined}
+     */
+    pointCloudStats(id) {
+        const ret = wasm.engine_pointCloudStats(this.__wbg_ptr, id);
+        return ret;
+    }
     /**
      * The answer to the last `requestPick` once the GPU has delivered it (then forgotten), undefined while it is not
      * there yet (or nothing was asked, or the context was lost)
@@ -667,6 +763,18 @@ export class Engine {
     setGroundVisible(id, visible) {
         wasm.engine_setGroundVisible(this.__wbg_ptr, id, visible);
     }
+    /**
+     * The icon atlas shared by the symbol layers: `width` × `height` RGBA texels, premultiplied, allocated again
+     * and empty (`updateIconAtlas` fills it)
+     * @param {number} width
+     * @param {number} height
+     */
+    setIconAtlas(width, height) {
+        const ret = wasm.engine_setIconAtlas(this.__wbg_ptr, width, height);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * How tiles load and show: `true`, immediately (everything visible loads, no fade, the default); `false`,
      * smoothly (levels skipped during flights, off-center tiles waiting while the camera moves, fade-in)
@@ -710,6 +818,17 @@ export class Engine {
     setMaxPitch(max) {
         wasm.engine_setMaxPitch(this.__wbg_ptr, max);
     }
+    /**
+     * Replaces the instances of a model layer (as for `addModels`) and the reference of their altitudes
+     * @param {number} id
+     * @param {Float64Array} instances
+     * @param {boolean} ground
+     */
+    setModelInstances(id, instances, ground) {
+        const ptr0 = passArrayF64ToWasm0(instances, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.engine_setModelInstances(this.__wbg_ptr, id, ptr0, len0, ground);
+    }
     /**
      * Costs of a network's edges (see `addNetwork`), when the way it is travelled changes; null: interpolated values
      * @param {number} id
@@ -762,6 +881,23 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_setNetworkValues(this.__wbg_ptr, id, ptr0, len0);
     }
+    /**
+     * The style of a point cloud: 14 numbers (see `Style::parse`), the colors of the 256 classes (RGBA,
+     * alpha 0 hides a class) and the ramp of the altitudes (256 RGBA texels)
+     * @param {number} id
+     * @param {Float64Array} style
+     * @param {Uint8Array} palette
+     * @param {Uint8Array} ramp
+     */
+    setPointCloudStyle(id, style, palette, ramp) {
+        const ptr0 = passArrayF64ToWasm0(style, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(palette, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray8ToWasm0(ramp, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        wasm.engine_setPointCloudStyle(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, ptr2, len2);
+    }
     /**
      * @param {number} id
      * @param {number} opacity
@@ -795,9 +931,9 @@ export class Engine {
         wasm.engine_setSymbolLayer(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, min_zoom, max_zoom, visible);
     }
     /**
-     * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), boxes (min x, min y, max x, max y,
-     * CSS pixels from the anchor), styles (20 floats each, see `LABEL_FLOATS`) and glyph quads (10 floats each: label, x, y, width, height from the anchor, atlas u0, v0, u1, v1 in
-     * texels, font scale)
+     * 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`)
      * @param {number} id
      * @param {Float64Array} anchors
      * @param {Float32Array} boxes
@@ -851,13 +987,14 @@ export class Engine {
         wasm.engine_setTileLoader(this.__wbg_ptr, loader);
     }
     /**
-     * Screen-space error threshold and opacity of a 3D Tiles layer
+     * Screen-space error threshold, opacity and size of the points (CSS pixels, 2 if not given) of a 3D Tiles layer
      * @param {number} id
      * @param {number} max_error
      * @param {number} opacity
+     * @param {number | null} [point_size]
      */
-    setTiles3dStyle(id, max_error, opacity) {
-        wasm.engine_setTiles3dStyle(this.__wbg_ptr, id, max_error, opacity);
+    setTiles3dStyle(id, max_error, opacity, point_size) {
+        wasm.engine_setTiles3dStyle(this.__wbg_ptr, id, max_error, opacity, !isLikeNone(point_size), isLikeNone(point_size) ? 0 : point_size);
     }
     /**
      * @param {number} min
@@ -939,6 +1076,19 @@ export class Engine {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * A region of the icon atlas: `width` × `height` RGBA texels (premultiplied) at (`x`, `y`)
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {Uint8Array} data
+     */
+    updateIconAtlas(x, y, width, height, data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
+    }
     /**
      * @param {number} delta
      * @param {number} x
@@ -951,8 +1101,9 @@ export class Engine {
 if (Symbol.dispose) Engine.prototype[Symbol.dispose] = Engine.prototype.free;
 
 /**
- * Decodes a `.b3dm` / `.glb` tile: `{ anchor: Float64Array(3), primitives: [{ vertices: Float32Array (x, y, z, u,
- * v per vertex, relative to the anchor), indices: Uint32Array, image?: Uint8Array, mime?: string }] }`.
+ * Decodes a `.b3dm` / `.pnts` / `.glb` tile: `{ anchor: Float64Array(3), primitives: [{ vertices: Float32Array (x,
+ * y, z, u, v per vertex, relative to the anchor), indices: Uint32Array, image?: Uint8Array, mime?: string, color?:
+ * Float32Array (the material's base color, when not white) }], points: [Uint8Array] (the points' vertices) }`.
  * `transform`: the tile's world transform (16 numbers, column-major).
  * `draco`: the decoded geometries of its Draco primitives (`dracoRequests`), if any.
  * @param {Uint8Array} bytes
@@ -1002,6 +1153,10 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_is_falsy_16bd49b68658263e: function(arg0) {
+            const ret = !arg0;
+            return ret;
+        },
         __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
@@ -1096,6 +1251,12 @@ function __wbg_get_imports() {
         __wbg_bindVertexArray_f58af0a346185ec5: function(arg0, arg1) {
             arg0.bindVertexArray(arg1);
         },
+        __wbg_blendEquation_5fb8aee6a55cf900: function(arg0, arg1) {
+            arg0.blendEquation(arg1 >>> 0);
+        },
+        __wbg_blendEquation_d21914e937b14896: function(arg0, arg1) {
+            arg0.blendEquation(arg1 >>> 0);
+        },
         __wbg_blendFuncSeparate_28abe082febb1a26: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
         },
@@ -1158,6 +1319,12 @@ function __wbg_get_imports() {
         __wbg_clearColor_796427e8ac60fe14: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.clearColor(arg1, arg2, arg3, arg4);
         },
+        __wbg_clearDepth_4840a5497ae51286: function(arg0, arg1) {
+            arg0.clearDepth(arg1);
+        },
+        __wbg_clearDepth_5a119c24c5d193bc: function(arg0, arg1) {
+            arg0.clearDepth(arg1);
+        },
         __wbg_clearStencil_1b8b8c727f598eec: function(arg0, arg1) {
             arg0.clearStencil(arg1);
         },
@@ -1252,6 +1419,12 @@ function __wbg_get_imports() {
             const ret = arg0.createVertexArray();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_cullFace_12123c1c97f1ba2c: function(arg0, arg1) {
+            arg0.cullFace(arg1 >>> 0);
+        },
+        __wbg_cullFace_1a01f0b6d5aeb687: function(arg0, arg1) {
+            arg0.cullFace(arg1 >>> 0);
+        },
         __wbg_deleteBuffer_070e58aaaf2a7a8b: function(arg0, arg1) {
             arg0.deleteBuffer(arg1);
         },
@@ -1309,6 +1482,12 @@ function __wbg_get_imports() {
         __wbg_depthMask_0d7c3dec3b8405ee: function(arg0, arg1) {
             arg0.depthMask(arg1 !== 0);
         },
+        __wbg_depthRange_24c7969249461e8e: function(arg0, arg1, arg2) {
+            arg0.depthRange(arg1, arg2);
+        },
+        __wbg_depthRange_6a4e169ccf314148: function(arg0, arg1, arg2) {
+            arg0.depthRange(arg1, arg2);
+        },
         __wbg_detachShader_1ed15fc2d289cf15: function(arg0, arg1, arg2) {
             arg0.detachShader(arg1, arg2);
         },
@@ -1493,6 +1672,13 @@ function __wbg_get_imports() {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
+        __wbg_get_f75619e20cb68514: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg1.get(getStringFromWasm0(arg2, arg3));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
         __wbg_get_index_f4750150bb3083b3: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -1501,6 +1687,10 @@ function __wbg_get_imports() {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
+        __wbg_headers_eba93595f8944c2f: function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        },
         __wbg_height_9dca4d43c3e4b84b: function(arg0) {
             const ret = arg0.height;
             return ret;
@@ -1525,6 +1715,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Error_80a725f81f2e102d: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Error;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Float32Array_595afb0f28b828c9: function(arg0) {
             let result;
             try {
@@ -1653,6 +1853,10 @@ function __wbg_get_imports() {
         __wbg_linkProgram_acdc299c43d734a0: function(arg0, arg1) {
             arg0.linkProgram(arg1);
         },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = arg0.message;
+            return ret;
+        },
         __wbg_name_91a697e9ff1634bf: function(arg0, arg1) {
             const ret = arg1.name;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -1690,6 +1894,10 @@ function __wbg_get_imports() {
             const ret = new Object();
             return ret;
         },
+        __wbg_new_83ca405eae412a62: function() { return handleError(function () {
+            const ret = new Headers();
+            return ret;
+        }, arguments); },
         __wbg_new_ee2291f50781bf1d: function() {
             const ret = new Array();
             return ret;
@@ -1738,6 +1946,10 @@ function __wbg_get_imports() {
             const ret = Array.of(arg0);
             return ret;
         },
+        __wbg_of_dde0b9d3265685ee: function(arg0, arg1, arg2) {
+            const ret = Array.of(arg0, arg1, arg2);
+            return ret;
+        },
         __wbg_of_fea2613674ee0d0f: function(arg0, arg1, arg2, arg3, arg4) {
             const ret = Array.of(arg0, arg1, arg2, arg3, arg4);
             return ret;
@@ -1765,6 +1977,9 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_prototypesetcall_d49a4fab5ca427bc: function(arg0, arg1, arg2) {
+            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+        },
         __wbg_push_2baf45db356cf468: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
@@ -1809,6 +2024,9 @@ function __wbg_get_imports() {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_set_af5932e3f78b5648: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
         __wbg_set_alpha_6dea851a46253adf: function(arg0, arg1) {
             arg0.alpha = arg1 !== 0;
         },
@@ -1824,6 +2042,9 @@ function __wbg_get_imports() {
         __wbg_set_depth_8b49de49803d4e60: function(arg0, arg1) {
             arg0.depth = arg1 !== 0;
         },
+        __wbg_set_headers_40ad33dcf016613f: function(arg0, arg1) {
+            arg0.headers = arg1;
+        },
         __wbg_set_power_preference_6ef22d4c8baf517f: function(arg0, arg1) {
             arg0.powerPreference = __wbindgen_enum_WebGlPowerPreference[arg1];
         },
@@ -1903,6 +2124,10 @@ function __wbg_get_imports() {
         __wbg_stencilOp_2697194654fee819: function(arg0, arg1, arg2, arg3) {
             arg0.stencilOp(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0);
         },
+        __wbg_subarray_002b94d5e13d1411: function(arg0, arg1, arg2) {
+            const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
         __wbg_texImage2D_1b3349107ad0faae: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4 >>> 0, arg5 >>> 0, arg6);
         }, arguments); },
@@ -2100,7 +2325,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: 149, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 190, 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_core.d.ts

@@ -68,6 +68,12 @@ export class Engine {
      * Circle layer of `feature_count` features: points (Mercator [0, 1], interleaved) and the feature of each
      */
     addCircles(points: Float64Array, feature: Uint32Array, feature_count: number): number;
+    /**
+     * A layer drawn by the page: `render()` is called at its place in every frame (`customMatrix` gives the
+     * matrices of that frame meanwhile); `depth`: with the depth buffer of the 3D layers (`3d` mode), else over
+     * what is drawn before it
+     */
+    addCustomLayer(render: () => void, depth: boolean): number;
     /**
      * An empty extrusion layer: its blocks come in batches (`setExtrusionBatch`)
      */
@@ -114,6 +120,12 @@ export class Engine {
     bounds(): Float64Array;
     camera(): Camera;
     clearPreload(): void;
+    /**
+     * Model-view-projection matrix (16 numbers, column-major, for `uniformMatrix4fv`) of the local frame at a
+     * longitude, latitude (degrees) and altitude (metres): x east, y north, z up, in metres. Undefined outside the
+     * callback of a custom layer. Static: the engine is borrowed while it draws
+     */
+    static customMatrix(lon: number, lat: number, altitude: number): Float32Array | undefined;
     /**
      * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself
      */
@@ -273,6 +285,11 @@ export class Engine {
      */
     setGroundUniform(id: number, name: string, values: Float64Array): void;
     setGroundVisible(id: number, visible: boolean): void;
+    /**
+     * The icon atlas shared by the symbol layers: `width` × `height` RGBA texels, premultiplied, allocated again
+     * and empty (`updateIconAtlas` fills it)
+     */
+    setIconAtlas(width: number, height: number): void;
     /**
      * How tiles load and show: `true`, immediately (everything visible loads, no fade, the default); `false`,
      * smoothly (levels skipped during flights, off-center tiles waiting while the camera moves, fade-in)
@@ -323,9 +340,9 @@ export class Engine {
      */
     setSymbolLayer(id: number, size: Float32Array, opacity: Float32Array, min_zoom: number, max_zoom: number, visible: boolean): void;
     /**
-     * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), boxes (min x, min y, max x, max y,
-     * CSS pixels from the anchor), styles (20 floats each, see `LABEL_FLOATS`) and glyph quads (10 floats each: label, x, y, width, height from the anchor, atlas u0, v0, u1, v1 in
-     * texels, font scale)
+     * 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`)
      */
     setSymbols(id: number, anchors: Float64Array, boxes: Float32Array, styles: Float32Array, quads: Float32Array): void;
     /**
@@ -356,6 +373,10 @@ export class Engine {
      * Replaces a region of a ground layer's texture (one layer of a 2D array)
      */
     updateGroundTexture(id: number, name: string, x: number, y: number, layer: number, width: number, height: number, data: Uint8Array): void;
+    /**
+     * 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;
     zoomAt(delta: number, x: number, y: number): void;
 }
 
@@ -365,6 +386,7 @@ export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_engine_free: (a: number, b: number) => void;
     readonly engine_addCircles: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
+    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_addGround: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
@@ -375,6 +397,7 @@ export interface InitOutput {
     readonly engine_bounds: (a: number) => [number, number];
     readonly engine_camera: (a: number) => any;
     readonly engine_clearPreload: (a: number) => void;
+    readonly engine_customMatrix: (a: number, b: number, c: number) => [number, number];
     readonly engine_ground: (a: number, b: number, c: number) => any;
     readonly engine_linkExtrusionNetwork: (a: number, b: number, c: number, d: number) => void;
     readonly engine_moveLayer: (a: number, b: number, c: number) => void;
@@ -413,6 +436,7 @@ export interface InitOutput {
     readonly engine_setGroundTexture: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number) => [number, number];
     readonly engine_setGroundUniform: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
     readonly engine_setGroundVisible: (a: number, b: number, c: number) => void;
+    readonly engine_setIconAtlas: (a: number, b: number, c: number) => [number, number];
     readonly engine_setImmediateLoading: (a: number, b: number) => void;
     readonly engine_setLineDash: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
@@ -432,6 +456,7 @@ export interface InitOutput {
     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_zoomAt: (a: number, b: number, c: number, d: number) => void;
     readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined___js_sys_b1e1c29ba6b0e6b3___Function_fn_wasm_bindgen_2e566c63402fe7fa___JsValue_____wasm_bindgen_2e566c63402fe7fa___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
     readonly wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_: (a: number, b: number, c: any) => [number, number];

package/dist/wasm/isard_core.js

@@ -29,6 +29,18 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * A layer drawn by the page: `render()` is called at its place in every frame (`customMatrix` gives the
+     * matrices of that frame meanwhile); `depth`: with the depth buffer of the 3D layers (`3d` mode), else over
+     * what is drawn before it
+     * @param {() => void} render
+     * @param {boolean} depth
+     * @returns {number}
+     */
+    addCustomLayer(render, depth) {
+        const ret = wasm.engine_addCustomLayer(this.__wbg_ptr, render, depth);
+        return ret >>> 0;
+    }
     /**
      * An empty extrusion layer: its blocks come in batches (`setExtrusionBatch`)
      * @returns {number}
@@ -197,6 +209,24 @@ export class Engine {
     clearPreload() {
         wasm.engine_clearPreload(this.__wbg_ptr);
     }
+    /**
+     * Model-view-projection matrix (16 numbers, column-major, for `uniformMatrix4fv`) of the local frame at a
+     * longitude, latitude (degrees) and altitude (metres): x east, y north, z up, in metres. Undefined outside the
+     * callback of a custom layer. Static: the engine is borrowed while it draws
+     * @param {number} lon
+     * @param {number} lat
+     * @param {number} altitude
+     * @returns {Float32Array | undefined}
+     */
+    static customMatrix(lon, lat, altitude) {
+        const ret = wasm.engine_customMatrix(lon, lat, altitude);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
     /**
      * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself
      * @param {number} x
@@ -651,6 +681,18 @@ export class Engine {
     setGroundVisible(id, visible) {
         wasm.engine_setGroundVisible(this.__wbg_ptr, id, visible);
     }
+    /**
+     * The icon atlas shared by the symbol layers: `width` × `height` RGBA texels, premultiplied, allocated again
+     * and empty (`updateIconAtlas` fills it)
+     * @param {number} width
+     * @param {number} height
+     */
+    setIconAtlas(width, height) {
+        const ret = wasm.engine_setIconAtlas(this.__wbg_ptr, width, height);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * How tiles load and show: `true`, immediately (everything visible loads, no fade, the default); `false`,
      * smoothly (levels skipped during flights, off-center tiles waiting while the camera moves, fade-in)
@@ -779,9 +821,9 @@ export class Engine {
         wasm.engine_setSymbolLayer(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, min_zoom, max_zoom, visible);
     }
     /**
-     * Labels of a symbol layer, shaped by the page: anchors (Mercator, interleaved), boxes (min x, min y, max x, max y,
-     * CSS pixels from the anchor), styles (20 floats each, see `LABEL_FLOATS`) and glyph quads (10 floats each: label, x, y, width, height from the anchor, atlas u0, v0, u1, v1 in
-     * texels, font scale)
+     * 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`)
      * @param {number} id
      * @param {Float64Array} anchors
      * @param {Float32Array} boxes
@@ -888,6 +930,19 @@ export class Engine {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
+    /**
+     * A region of the icon atlas: `width` × `height` RGBA texels (premultiplied) at (`x`, `y`)
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {Uint8Array} data
+     */
+    updateIconAtlas(x, y, width, height, data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.engine_updateIconAtlas(this.__wbg_ptr, x, y, width, height, ptr0, len0);
+    }
     /**
      * @param {number} delta
      * @param {number} x
@@ -998,6 +1053,12 @@ function __wbg_get_imports() {
         __wbg_bindVertexArray_f58af0a346185ec5: function(arg0, arg1) {
             arg0.bindVertexArray(arg1);
         },
+        __wbg_blendEquation_5fb8aee6a55cf900: function(arg0, arg1) {
+            arg0.blendEquation(arg1 >>> 0);
+        },
+        __wbg_blendEquation_d21914e937b14896: function(arg0, arg1) {
+            arg0.blendEquation(arg1 >>> 0);
+        },
         __wbg_blendFuncSeparate_28abe082febb1a26: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
         },
@@ -1135,6 +1196,12 @@ function __wbg_get_imports() {
             const ret = arg0.createVertexArray();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_cullFace_12123c1c97f1ba2c: function(arg0, arg1) {
+            arg0.cullFace(arg1 >>> 0);
+        },
+        __wbg_cullFace_1a01f0b6d5aeb687: function(arg0, arg1) {
+            arg0.cullFace(arg1 >>> 0);
+        },
         __wbg_deleteBuffer_070e58aaaf2a7a8b: function(arg0, arg1) {
             arg0.deleteBuffer(arg1);
         },
@@ -1192,6 +1259,12 @@ function __wbg_get_imports() {
         __wbg_depthMask_0d7c3dec3b8405ee: function(arg0, arg1) {
             arg0.depthMask(arg1 !== 0);
         },
+        __wbg_depthRange_24c7969249461e8e: function(arg0, arg1, arg2) {
+            arg0.depthRange(arg1, arg2);
+        },
+        __wbg_depthRange_6a4e169ccf314148: function(arg0, arg1, arg2) {
+            arg0.depthRange(arg1, arg2);
+        },
         __wbg_detachShader_1ed15fc2d289cf15: function(arg0, arg1, arg2) {
             arg0.detachShader(arg1, arg2);
         },
@@ -1862,7 +1935,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: 78, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 87, 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;
         },