isard 0.4.0 → 0.5.1

package/dist/wasm/isard.d.ts

@@ -19,6 +19,8 @@ export interface EncodedTile {
     /** ECEF origin of the vertices (metres) */
     anchor: Float64Array<ArrayBuffer>;
     primitives: EncodedPrimitive[];
+    /** Its points (`.pnts`, glTF points), 20 bytes a vertex: x, y, z (f32) around the anchor, RGB, a normal */
+    points: Uint8Array<ArrayBuffer>[];
 }
 
 /** A texture transcoded for the GPU (KTX2 / Basis Universal): a WebGL internal format and its mip levels */
@@ -41,7 +43,10 @@ export interface DecodedPrimitive {
     color?: Float32Array<ArrayBuffer>;
 }
 
-/** A Draco-compressed primitive of a tile (`KHR_draco_mesh_compression`), to decode with the Draco module */
+/**
+ * A Draco-compressed primitive of a tile (`KHR_draco_mesh_compression`), or its points
+ * (`3DTILES_draco_point_compression`), to decode with the Draco module
+ */
 export interface DracoRequest {
     mesh: number;
     primitive: number;
@@ -49,15 +54,21 @@ export interface DracoRequest {
     /** Draco attribute ids */
     position: number;
     uv?: number;
+    color?: number;
+    normal?: number;
+    /** A point cloud: no triangles */
+    points?: boolean;
 }
 
-/** The Draco module's output for a request: positions and uv as stored, triangles */
+/** The Draco module's output for a request: positions, uv, colors and normals as stored, triangles (not for points) */
 export interface DracoGeometry {
     mesh: number;
     primitive: number;
     positions: Float32Array;
     uvs?: Float32Array;
-    indices: Uint32Array;
+    indices?: Uint32Array;
+    colors?: Float32Array;
+    normals?: Float32Array;
 }
 
 /** Compressed texture formats supported by the GPU */
@@ -72,6 +83,8 @@ export interface TextureFormats {
 export interface DecodedTile {
     anchor: Float64Array<ArrayBuffer>;
     primitives: DecodedPrimitive[];
+    /** Its points' vertices (`EncodedTile.points`) */
+    points?: Uint8Array<ArrayBuffer>[];
 }
 
 /** What the engine expects from a pool of decoding workers (`Engine.setTileLoader`) */
@@ -89,6 +102,22 @@ export interface TileLoaderLike {
     priority?: 'high' | 'low',
     ): Promise<DecodedTile>;
     abort(id: number): void;
+    /**
+     * The points of a COPC node: its LAZ chunk (`size` bytes at `offset` of the file at `url`, a range request), the
+     * data of the file's LAZ VLR, its layout (format, record length, scale, offset), the grid positioning its points
+     * and its point count; resolves with its vertices (20 bytes each, see `EncodedTile.points`)
+     */
+    loadPoints?(
+    id: number,
+    url: string,
+    offset: number,
+    size: number,
+    laz: Uint8Array,
+    layout: Float64Array,
+    grid: Float64Array,
+    count: number,
+    priority?: 'high' | 'low',
+    ): Promise<Uint8Array<ArrayBuffer>>;
 }
 
 
@@ -150,6 +179,63 @@ export interface Tiles3dStats {
 
 
 
+/** Counters of a point cloud layer */
+export interface PointCloudStats {
+    /** Points drawn in the last frame */
+    points: number;
+    /** Nodes drawn in the last frame */
+    nodes: number;
+    /** Nodes held on the GPU */
+    loaded: number;
+    /** Downloads under way */
+    inFlight: number;
+    /** GPU memory of the points, MB */
+    gpuMb: number;
+    /** Nodes known in the hierarchy (its pages loaded so far) */
+    known: number;
+}
+
+/** What a point cloud says of itself once its head is read */
+export interface PointCloudInfo {
+    /** Points in the file */
+    points: number;
+    /** LAS point format (6 to 8: 7 and 8 with colors) */
+    format: number;
+    /** The WKT of its CRS, if the file has one */
+    wkt?: string;
+    /** The center of its cube: longitude, latitude */
+    center: [lon: number, lat: number];
+    /** Its altitudes, lowest and highest (metres) */
+    altitudes: [min: number, max: number];
+}
+
+/** A point picked in a point cloud */
+export interface PointCloudPoint {
+    lonLat: [lon: number, lat: number];
+    /** Metres above the ellipsoid */
+    height: number;
+    /** Its z in the file's vertical datum (metres) */
+    altitude: number;
+    classification: number;
+    intensity: number;
+    returnNumber: number;
+    numberOfReturns: number;
+    /** 8-bit color, files with colors only */
+    rgb?: [r: number, g: number, b: number];
+}
+
+/** The CRS of a point cloud, as the page resolves it from the file's WKT (`addPointCloud`) */
+export interface PointCloudCrs {
+    /** x, y pairs of the CRS to longitudes, latitudes (degrees) */
+    inverse(xy: Float64Array): Float64Array;
+    /** The altitudes are above the geoid (IGN69): raised by the RAF20 geoid height */
+    geoid: boolean;
+    /** Metres of a unit of z */
+    verticalScale: number;
+}
+
+
+
 /** Pieces of a network layer: its edges cut along their lines, sorted by square; only the squares in view are drawn */
 export interface NetworkStats {
     pieces: number;
@@ -219,6 +305,12 @@ export class Engine {
      * cost of travelling it from A to B then from B to A; without, values are interpolated along the edges.
      */
     addNetwork(mercator: Float64Array, edges: Uint32Array, line_start: Uint32Array | null | undefined, line_points: Float64Array | null | undefined, costs: Float32Array | null | undefined, style: Float32Array): number;
+    /**
+     * 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
+     */
+    addPointCloud(url: string, resolve: (wkt: string | undefined) => PointCloudCrs): number;
     /**
      * 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 |
@@ -282,6 +374,19 @@ export class Engine {
      * Reads the pixels back at once (the GPU finishes its work first): for clicks; `requestPick` for the hover
      */
     pick(x: number, y: number, radius?: number | null, only?: Uint32Array | null): PickHit | undefined;
+    /**
+     * What a point cloud says of itself, undefined before its head is read
+     */
+    pointCloudInfo(id: number): PointCloudInfo | undefined;
+    /**
+     * 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
+     */
+    pointCloudPoint(id: number, index: number): PointCloudPoint | undefined;
+    /**
+     * Counters of a point cloud layer, undefined if there is none with this id
+     */
+    pointCloudStats(id: number): PointCloudStats | undefined;
     /**
      * 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)
@@ -297,9 +402,6 @@ export class Engine {
     project(lon: number, lat: number): [x: number, y: number] | undefined;
     removeExtrusionBatch(id: number, key: number): void;
     removeLayer(id: number): void;
-    /**
-     * Draws a frame; returns true while tiles are still loading (a new frame will be asked through `redraw`)
-     */
     render(): boolean;
     /**
      * Asks what is under a screen point without waiting for the GPU (as `pick`, with the position there): the
@@ -454,6 +556,11 @@ export class Engine {
      * One value per node; negative = unreached
      */
     setNetworkValues(id: number, values: Float32Array): void;
+    /**
+     * The style of a point cloud: 14 numbers (see `Style::parse`), the colors of the 256 classes (RGBA,
+     * alpha 0 hides a class) and the ramp of the altitudes (256 RGBA texels)
+     */
+    setPointCloudStyle(id: number, style: Float64Array, palette: Uint8Array, ramp: Uint8Array): void;
     setRasterStyle(id: number, opacity: number, saturation: number): void;
     /**
      * Space behind the globe (stars, atmosphere halo), in the globe projection
@@ -488,9 +595,9 @@ export class Engine {
      */
     setTileLoader(loader: TileLoaderLike | null): void;
     /**
-     * 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
      */
-    setTiles3dStyle(id: number, max_error: number, opacity: number): void;
+    setTiles3dStyle(id: number, max_error: number, opacity: number, point_size?: number | null): void;
     setZoomRange(min: number, max: number): void;
     /**
      * Tile counters of the raster layers, for diagnostics
@@ -524,9 +631,9 @@ export class Engine {
 }
 
 /**
- * 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, color?:
- * Float32Array (the material's base color, when not white) }] }`.
+ * 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.
  */
@@ -552,6 +659,7 @@ export interface InitOutput {
     readonly engine_addLines: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number];
     readonly engine_addModels: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number, number];
     readonly engine_addNetwork: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => [number, number, number];
+    readonly engine_addPointCloud: (a: number, b: number, c: number, d: any) => [number, number, number];
     readonly engine_addRaster: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number];
     readonly engine_addSymbols: (a: number) => [number, number, number];
     readonly engine_addTiles3d: (a: number, b: number, c: number, d: number) => [number, number, number];
@@ -566,6 +674,9 @@ export interface InitOutput {
     readonly engine_new: (a: any, b: any) => [number, number, number];
     readonly engine_pan: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly engine_pick: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
+    readonly engine_pointCloudInfo: (a: number, b: number) => any;
+    readonly engine_pointCloudPoint: (a: number, b: number, c: number) => any;
+    readonly engine_pointCloudStats: (a: number, b: number) => any;
     readonly engine_pollPick: (a: number) => any;
     readonly engine_preload: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly engine_project: (a: number, b: number, c: number) => any;
@@ -608,13 +719,14 @@ export interface InitOutput {
     readonly engine_setNetworkScales: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkStyle: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setNetworkValues: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setPointCloudStyle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly engine_setRasterStyle: (a: number, b: number, c: number, d: number) => void;
     readonly engine_setSky: (a: number, b: number) => void;
     readonly engine_setSymbolLayer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly engine_setSymbols: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => [number, number];
     readonly engine_setTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => [number, number];
     readonly engine_setTileLoader: (a: number, b: any) => void;
-    readonly engine_setTiles3dStyle: (a: number, b: number, c: number, d: number) => void;
+    readonly engine_setTiles3dStyle: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly engine_setZoomRange: (a: number, b: number, c: number) => void;
     readonly engine_stats: (a: number) => any;
     readonly engine_textureFormats: (a: number) => any;

package/dist/wasm/isard.js

@@ -175,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 |
@@ -344,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)
@@ -388,7 +434,6 @@ export class Engine {
         wasm.engine_removeLayer(this.__wbg_ptr, id);
     }
     /**
-     * Draws a frame; returns true while tiles are still loading (a new frame will be asked through `redraw`)
      * @returns {boolean}
      */
     render() {
@@ -835,6 +880,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
@@ -924,13 +986,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
@@ -1037,9 +1100,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, color?:
- * Float32Array (the material's base color, when not white) }] }`.
+ * 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
@@ -1089,6 +1152,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;
@@ -1251,6 +1318,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);
         },
@@ -1598,6 +1671,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;
@@ -1606,6 +1686,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;
@@ -1630,6 +1714,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 {
@@ -1758,6 +1852,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);
@@ -1795,6 +1893,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;
@@ -1843,6 +1945,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;
@@ -1870,6 +1976,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;
@@ -1914,6 +2023,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;
         },
@@ -1929,6 +2041,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];
         },
@@ -2008,6 +2123,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); },
@@ -2205,7 +2324,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: 168, 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

@@ -176,9 +176,6 @@ export class Engine {
     project(lon: number, lat: number): [x: number, y: number] | undefined;
     removeExtrusionBatch(id: number, key: number): void;
     removeLayer(id: number): void;
-    /**
-     * Draws a frame; returns true while tiles are still loading (a new frame will be asked through `redraw`)
-     */
     render(): boolean;
     /**
      * Asks what is under a screen point without waiting for the GPU (as `pick`, with the position there): the

package/dist/wasm/isard_core.js

@@ -352,7 +352,6 @@ export class Engine {
         wasm.engine_removeLayer(this.__wbg_ptr, id);
     }
     /**
-     * Draws a frame; returns true while tiles are still loading (a new frame will be asked through `redraw`)
      * @returns {boolean}
      */
     render() {

package/dist/wasm/isard_points.d.ts

@@ -0,0 +1,43 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * The vertices (`STRIDE` bytes each, see `points`) of a COPC chunk of `count` points. `laz`: the data of the LAZ
+ * VLR; `layout`: format, record length, scale and offset of the header; `grid`: the positions of the node's square
+ * (`Grid::numbers`)
+ */
+export function decodeCopc(chunk: Uint8Array, laz: Uint8Array, layout: Float64Array, grid: Float64Array, count: number): Uint8Array;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly decodeCopc: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => [number, number, number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;