isard 1.16.0 → 2.1.0

package/dist/wasm/{isard_core.js → isard_webgl2.js}

@@ -1,10 +1,16 @@
-/* @ts-self-types="./isard_core.d.ts" */
+/* @ts-self-types="./isard_webgl2.d.ts" */
 
 /**
- * A map on one canvas: its WebGL2 context, camera, ground (raster layers over the relief) and the layers over it.
- * Draws only when `render` is called (the JavaScript side calls it after `redraw` asks for a frame)
+ * A map on one canvas: its device, its camera, what it draws. Draws only when `render` is called (the JavaScript
+ * side calls it after `redraw` asks for a frame)
  */
 export class Engine {
+    static __wrap(ptr) {
+        const obj = Object.create(Engine.prototype);
+        obj.__wbg_ptr = ptr;
+        EngineFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
@@ -20,8 +26,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when `feature_count` features need a table past the GPU's largest texture
      * @param {Float64Array} points
      * @param {Uint32Array} feature
      * @param {number} feature_count
@@ -39,10 +44,10 @@ 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
+     * A layer drawn by the page: `render(target)` is called before every frame's pass with its targets (the device,
+     * the color, the depth in `'3d'`: `customMatrix` gives the matrices of that frame meanwhile), what it drew laid over
+     * the frame at the layer's place; `depth`: with the depth of the solid scene (`'3d'` mode)
+     * @param {(target: CustomTarget) => void} render
      * @param {boolean} depth
      * @returns {number}
      */
@@ -55,8 +60,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log)
+     * Never in practice: the layer starts empty
      * @returns {number}
      */
     addExtrusions() {
@@ -73,8 +77,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log), or when `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when `feature_count` features need a table past the GPU's largest texture
      * @param {Float64Array} points
      * @param {Uint32Array} ring_start
      * @param {Uint32Array} polygon_start
@@ -103,8 +106,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created, a shader fails to compile or the trails need a
-     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when the trails need a table past the GPU's largest texture
      * @param {number} particles
      * @param {number} trail
      * @returns {number}
@@ -117,14 +119,17 @@ export class Engine {
         return ret[0] >>> 0;
     }
     /**
-     * Ground layer running `code` (GLSL ES 3.0 defining `vec4 ground(vec2 offset)`, see `render::ground`) over the
-     * ground; `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors
-     * come back with the shader's info log (line numbers of `code`)
+     * Ground layer running `code` (WGSL defining `fn ground(offset: vec2f) -> vec4f`, see `render::ground`) over the
+     * ground; `names` and `types`: its uniforms (`f32`, `vec2f`, `vec4<u32>`, `mat4x4f`…), read as `u.<name>`;
+     * `anchor`: Mercator point the offsets are taken from; bounds: Mercator box it shows in. Compilation errors are
+     * reported in the console when the layer is first drawn
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `code` does not compile or link, with the shader's info log
+     * Throws (to JavaScript) on a uniform's name or type WGSL does not take
      * @param {string} code
+     * @param {string[]} names
+     * @param {string[]} types
      * @param {number} anchor_x
      * @param {number} anchor_y
      * @param {number} min_x
@@ -133,10 +138,14 @@ export class Engine {
      * @param {number} max_y
      * @returns {number}
      */
-    addGround(code, anchor_x, anchor_y, min_x, min_y, max_x, max_y) {
+    addGround(code, names, types, anchor_x, anchor_y, min_x, min_y, max_x, max_y) {
         const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_addGround(this.__wbg_ptr, ptr0, len0, anchor_x, anchor_y, min_x, min_y, max_x, max_y);
+        const ptr1 = passArrayJsValueToWasm0(names, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArrayJsValueToWasm0(types, wasm.__wbindgen_malloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_addGround(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, anchor_x, anchor_y, min_x, min_y, max_x, max_y);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -148,8 +157,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log), or when the features or the lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when the features or the lines need a table past the GPU's largest texture
      * @param {Float64Array} points
      * @param {Uint32Array} start
      * @param {Uint32Array} feature
@@ -173,18 +181,36 @@ 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`
+     * (`geo::models::INSTANCE_NUMBERS` numbers each: longitude, latitude, altitude, heading, pitch, roll in degrees,
+     * scale); `ground`: altitudes above the relief, else above the ellipsoid. A model that fails to load or decode
+     * leaves the layer empty
+     * @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);
+        return ret >>> 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`
-     * edges (node index pairs, interleaved). `line_start` and `line_points`: the line of each edge from A to B, points
-     * `line_start[e] .. line_start[e + 1]` of `line_points` (Mercator, interleaved; straight if fewer than two). `costs`: per edge, the
-     * cost of travelling it from A to B then from B to A; without, values are interpolated along the edges.
+     * edges (node index pairs, interleaved). `line_start` and `line_points`: the line of each edge from A to B,
+     * points `line_start[e] .. line_start[e + 1]` of `line_points` (Mercator, interleaved; straight if fewer than
+     * two). `costs`: per edge, the cost of travelling it from A to B then from B to A; without, values are
+     * interpolated along the edges.
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `style` is not 25 numbers, `edges` is not node pairs or names a node past
-     * those of `mercator`, the nodes or edges need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or when
-     * a WebGL object cannot be created or a shader fails to compile (the error carries its info log)
+     * Throws (to JavaScript) when `style` is not 25 numbers, `edges` is not node pairs or names a node past those of
+     * `mercator`, or the nodes or edges need a table past the GPU's largest texture
      * @param {Float64Array} mercator
      * @param {Uint32Array} edges
      * @param {Uint32Array | null | undefined} line_start
@@ -212,14 +238,25 @@ 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
+     * The file is read later: a bad file, or a `resolve` that throws, leaves the layer empty
+     * @param {string} url
+     * @param {(wkt: string | undefined) => PointCloudCrs} resolve
+     * @returns {number}
+     */
+    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);
+        return ret >>> 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 |
      * null>`, an image of `size` × `size` (null: nothing there); `ground: false`: draped on 3D layers only
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when the texture holding the layer's tiles cannot be created
      * @param {string} url
      * @param {number} min_z
      * @param {number} max_z
@@ -234,18 +271,14 @@ export class Engine {
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ret = wasm.engine_addRaster(this.__wbg_ptr, ptr0, len0, min_z, max_z, opacity, saturation, isLikeNone(size) ? Number.MAX_SAFE_INTEGER : (size) >> 0, isLikeNone(loader) ? 0 : addToExternrefTable0(loader), isLikeNone(ground) ? 0xFFFFFF : ground ? 1 : 0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        return ret[0] >>> 0;
+        return ret >>> 0;
     }
     /**
      * An empty symbol layer
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL object cannot be created or a shader fails to compile (the error carries its
-     * info log)
+     * Never in practice: its tables start empty
      * @returns {number}
      */
     addSymbols() {
@@ -255,13 +288,30 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * 3D Tiles (b3dm / glb textured meshes, external tilesets) from the URL of a `tileset.json`. `max_error`:
+     * screen-space error (CSS pixels) above which a tile is refined; 16 is the usual value, lower is finer.
+     * `geoid`: its heights are altitudes (NGF-IGN69), each tile raised by the RAF20 geoid onto the relief.
+     *
+     * The tileset is read later: a bad one leaves the layer empty
+     * @param {string} url
+     * @param {number} max_error
+     * @param {boolean | null} [geoid]
+     * @returns {number}
+     */
+    addTiles3d(url, max_error, geoid) {
+        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_addTiles3d(this.__wbg_ptr, ptr0, len0, max_error, isLikeNone(geoid) ? 0xFFFFFF : geoid ? 1 : 0);
+        return ret >>> 0;
+    }
     /**
      * An empty layer of vector tiles drawn as geometry: its style layers come with `setVectorSublayers`, its tiles
-     * with `setVectorTile`
+     * with `setVectorTile` or `setVectorTileMesh`
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a shader fails to compile (the error carries its info log)
+     * Never in practice: the layer starts empty
      * @returns {number}
      */
     addVectorTiles() {
@@ -271,6 +321,22 @@ export class Engine {
         }
         return ret[0] >>> 0;
     }
+    /**
+     * The backend drawing: "browserwebgpu" or "gl"
+     * @returns {string}
+     */
+    backend() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.engine_backend(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Longitudes and latitudes the view covers on the ground, `[west, south, east, north]` (degrees): the screen's
      * border cast on the ground, or on the far plane where it passes the horizon
@@ -290,6 +356,12 @@ export class Engine {
         const ret = wasm.engine_camera(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Removes the panorama
+     */
+    clearPanorama() {
+        wasm.engine_clearPanorama(this.__wbg_ptr);
+    }
     /**
      * The turns go around the screen center again
      */
@@ -309,7 +381,23 @@ export class Engine {
         wasm.engine_clearViewshed(this.__wbg_ptr);
     }
     /**
-     * Model-view-projection matrix (16 numbers, column-major, for `uniformMatrix4fv`) of the local frame at a
+     * The engine of `canvas`, `redraw` called when it needs a new frame; `antialias`: the 3D multisampled (default
+     * true). Asynchronous: the device is asked for
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when the canvas gives no device ("WebGPU is not available" through WebGPU)
+     * @param {HTMLCanvasElement} canvas
+     * @param {() => void} redraw
+     * @param {boolean | null} [antialias]
+     * @returns {Promise<Engine>}
+     */
+    static create(canvas, redraw, antialias) {
+        const ret = wasm.engine_create(canvas, redraw, isLikeNone(antialias) ? 0xFFFFFF : antialias ? 1 : 0);
+        return ret;
+    }
+    /**
+     * Model-view-projection matrix (16 numbers, column-major, WebGPU's clip depth from 0 to 1) 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
@@ -349,9 +437,15 @@ export class Engine {
         return ret;
     }
     /**
-     * Position under a screen point (CSS pixels), undefined above the horizon; on the relief itself: from the copy of
-     * its tiles kept on the CPU, the drawn ground read back from the GPU only where none is there (a read back waits
-     * for the frame: called during a move, it stalls it)
+     * The `GPUDevice` the engine draws with, for the custom layers' objects; undefined on the WebGL2 fallback
+     * @returns {GPUDevice | undefined}
+     */
+    gpuDevice() {
+        const ret = wasm.engine_gpuDevice(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Position under a screen point (CSS pixels), undefined above the horizon
      * @param {number} x
      * @param {number} y
      * @returns {[lon: number, lat: number] | undefined}
@@ -361,8 +455,8 @@ export class Engine {
         return ret;
     }
     /**
-     * Colors an extrusion layer by the node values of network layer `network` (undefined: by its own values):
-     * each block takes min(value(A) + cost from A, value(B) + cost from B) from its anchors (`setExtrusionAnchors`),
+     * Colors an extrusion layer by the node values of network layer `network` (undefined: by its own values): each
+     * block takes min(value(A) + cost from A, value(B) + cost from B) from its anchors (`setExtrusionAnchors`),
      * through the layer's ramp, up to `max` (above: its own color)
      * @param {number} id
      * @param {number | null | undefined} network
@@ -372,9 +466,9 @@ export class Engine {
         wasm.engine_linkExtrusionNetwork(this.__wbg_ptr, id, isLikeNone(network) ? Number.MAX_SAFE_INTEGER : (network) >>> 0, max);
     }
     /**
-     * Model-view-projection matrix (16 numbers, column-major) of the local frame at a longitude, latitude (degrees)
-     * and altitude (metres), x east, y north, z up, in metres, for the last frame drawn (else the camera): the 3D
-     * overlays of the page (`Panel`) placed with it after each frame
+     * Model-view-projection matrix (16 numbers, column-major, WebGL's clip depth) of the local frame at a longitude,
+     * latitude (degrees) and altitude (metres), x east, y north, z up, in metres, for the last frame drawn (else the
+     * camera): the 3D overlays of the page (`Panel`) placed with it after each frame
      * @param {number} lon
      * @param {number} lat
      * @param {number} altitude
@@ -386,6 +480,25 @@ export class Engine {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    /**
+     * The largest texture the device takes (pixels a side): the symbol layers' atlases stay within it
+     * @returns {number}
+     */
+    maxTextureSize() {
+        const ret = wasm.engine_maxTextureSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * The GPU memory of the layers the budget counts (`setMemoryBudget`): two numbers a layer, its id and its bytes
+     * (a raster's pool, the tiles of a 3D Tiles layer or a point cloud), the relief last with id 0
+     * @returns {Float64Array}
+     */
+    memory() {
+        const ret = wasm.engine_memory(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
     /**
      * Moves a layer to a drawing position (0 = bottom)
      * @param {number} id
@@ -403,26 +516,6 @@ export class Engine {
         const ret = wasm.engine_networkStats(this.__wbg_ptr, id);
         return ret;
     }
-    /**
-     * `redraw` is called when the engine needs a new frame (a tile arrived); `antialias`: multisampled (default true)
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when the canvas gives no WebGL2 context ("WebGL2 is not available"), or when a WebGL
-     * object of the globe, the sky or the raster pass cannot be created or one of their shaders fails to compile
-     * @param {HTMLCanvasElement} canvas
-     * @param {() => void} redraw
-     * @param {boolean | null} [antialias]
-     */
-    constructor(canvas, redraw, antialias) {
-        const ret = wasm.engine_new(canvas, redraw, isLikeNone(antialias) ? 0xFFFFFF : antialias ? 1 : 0);
-        if (ret[2]) {
-            throw takeFromExternrefTable0(ret[1]);
-        }
-        this.__wbg_ptr = ret[0];
-        EngineFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * Drags the ground from one screen point to another (CSS pixels); in relief, the ground point grabbed stays
      * under the cursor
@@ -435,30 +528,42 @@ export class Engine {
         wasm.engine_pan(this.__wbg_ptr, x0, y0, x1, y1);
     }
     /**
-     * Feature under a screen point (CSS pixels), or the nearest one within `radius` CSS pixels: its layer and its
-     * index there (the edge of a network, the feature of a line, circle or fill layer), undefined if none. The
-     * pickable layers are drawn with each feature colored by its number; then the fills are tested on the ground.
-     * `only`: the ids of the layers to look in (all if undefined): the others are not drawn and hide nothing.
-     * Reads the pixels back at once (the GPU finishes its work first): for clicks; `requestPick` for the hover
-     * @param {number} x
-     * @param {number} y
-     * @param {number | null} [radius]
-     * @param {Uint32Array | null} [only]
-     * @returns {PickHit | undefined}
+     * What a point cloud says of itself, undefined before its head is read
+     * @param {number} id
+     * @returns {PointCloudInfo | undefined}
      */
-    pick(x, y, radius, only) {
-        var ptr0 = isLikeNone(only) ? 0 : passArray32ToWasm0(only, wasm.__wbindgen_malloc);
-        var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_pick(this.__wbg_ptr, x, y, !isLikeNone(radius), isLikeNone(radius) ? 0 : radius, ptr0, len0);
+    pointCloudInfo(id) {
+        const ret = wasm.engine_pointCloudInfo(this.__wbg_ptr, id);
+        return ret;
+    }
+    /**
+     * The point of a point cloud picked by `pollPick` (its index there): read back with the answer; undefined for
+     * another
+     * @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)
+     * The answer to request `id` once the GPU has delivered it (then forgotten), undefined while it is not there yet
+     * (or for a request given up)
+     * @param {number} id
      * @returns {PickResult | undefined}
      */
-    pollPick() {
-        const ret = wasm.engine_pollPick(this.__wbg_ptr);
+    pollPick(id) {
+        const ret = wasm.engine_pollPick(this.__wbg_ptr, id);
         return ret;
     }
     /**
@@ -500,7 +605,7 @@ export class Engine {
         wasm.engine_removeExtrusionBatch(this.__wbg_ptr, id, key);
     }
     /**
-     * Removes a layer and frees its GPU objects; the other layers forget it (a layer that referred to it)
+     * Removes a layer and frees its GPU objects (as it drops)
      * @param {number} id
      */
     removeLayer(id) {
@@ -515,8 +620,8 @@ export class Engine {
         wasm.engine_removeVectorTile(this.__wbg_ptr, id, key);
     }
     /**
-     * Draws a frame: the backdrop, the ground and the layers over it bottom to top, then the panorama and the
-     * viewshed; returns true while tiles are still loading (a new frame will be asked through `redraw`)
+     * Draws a frame: the backdrop, the ground; returns true while tiles are still loading (a new frame will be asked
+     * through `redraw`)
      * @returns {boolean}
      */
     render() {
@@ -524,20 +629,21 @@ export class Engine {
         return ret !== 0;
     }
     /**
-     * Asks what is under a screen point without waiting for the GPU (as `pick`, with the position there): the
-     * picking pass is drawn now and read back into a buffer; `pollPick` gives the answer on a later frame. A new
-     * request replaces the one in flight. Returns false if nothing could be asked (no WebGL2 fence)
+     * Asks what is under a screen point (CSS pixels), or nearest to it within `radius` CSS pixels, without waiting
+     * for the GPU: the picking pass is drawn now, its pixels read back later; `pollPick` gives the answer. `only`: the
+     * ids of the layers to look in (all if undefined): the others are not drawn and hide nothing. The request's
+     * number, never 0
      * @param {number} x
      * @param {number} y
      * @param {number | null} [radius]
      * @param {Uint32Array | null} [only]
-     * @returns {boolean}
+     * @returns {number}
      */
     requestPick(x, y, radius, only) {
         var ptr0 = isLikeNone(only) ? 0 : passArray32ToWasm0(only, wasm.__wbindgen_malloc);
         var len0 = WASM_VECTOR_LEN;
         const ret = wasm.engine_requestPick(this.__wbg_ptr, x, y, !isLikeNone(radius), isLikeNone(radius) ? 0 : radius, ptr0, len0);
-        return ret !== 0;
+        return ret >>> 0;
     }
     /**
      * Viewport in CSS pixels and device pixel ratio
@@ -579,8 +685,7 @@ export class Engine {
      * The body the map is drawn on: its equatorial radius (metres) and flattening (0 for a sphere), the halo of its
      * atmosphere around the globe (RGB 0-1 and its strength, 4 numbers; `undefined` for an airless body), and the
      * lowest and highest altitudes of its ground (metres: what its relief may raise into view). WGS 84, the Earth's
-     * blue halo and the range of its relief worldwide (-450 m to 8900 m) by default; set before the layers and the
-     * relief, whose shaders may take its size (`ISARD_CIRCUMFERENCE` of the ground layers)
+     * blue halo and the range of its relief worldwide (-450 m to 8900 m) by default
      * @param {number} radius
      * @param {number} flattening
      * @param {Float32Array | null | undefined} halo
@@ -625,13 +730,23 @@ export class Engine {
         const len1 = WASM_VECTOR_LEN;
         wasm.engine_setCircles(this.__wbg_ptr, id, ptr0, len0, ptr1, len1);
     }
+    /**
+     * A raster layer draped on the roofs, or all the faces, of a 3D Tiles layer, an extrusion layer, a vector tiles
+     * layer's buildings or a model layer (`raster` undefined: none)
+     * @param {number} id
+     * @param {number | null | undefined} raster
+     * @param {boolean} all_faces
+     * @param {number} opacity
+     */
+    setDrape(id, raster, all_faces, opacity) {
+        wasm.engine_setDrape(this.__wbg_ptr, id, isLikeNone(raster) ? Number.MAX_SAFE_INTEGER : (raster) >>> 0, all_faces, opacity);
+    }
     /**
      * Anchors of batch `key` on the linked network: per feature, node A, node B, cost from A, cost from B
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the batch's features need an anchor texture past the GPU's
-     * `MAX_TEXTURE_SIZE`, or when it cannot be created
+     * Throws (to JavaScript) when the batch's features need a table past the GPU's largest texture
      * @param {number} id
      * @param {number} key
      * @param {Float32Array} anchors
@@ -650,8 +765,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when a WebGL buffer or vertex array of the batch cannot be created, or when
-     * `feature_count` features need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when `feature_count` features need a table past the GPU's largest texture
      * @param {number} id
      * @param {number} key
      * @param {Float64Array} points
@@ -879,7 +993,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) as `setGlyphPages` does: a size that is not positive, or the texture not created
+     * Throws (to JavaScript) as `setGlyphPages` does
      * @param {number} width
      * @param {number} height
      * @param {Uint8Array | null} [data]
@@ -899,8 +1013,8 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), `pages`
-     * is not 1 to 256, or the atlas texture cannot be created
+     * Throws (to JavaScript) when `width` or `height` is not positive or past the GPU's largest texture, or `pages`
+     * is not 1 to 256
      * @param {number} width
      * @param {number} height
      * @param {number} pages
@@ -923,42 +1037,40 @@ export class Engine {
         wasm.engine_setGroundBounds(this.__wbg_ptr, id, min_x, min_y, max_x, max_y);
     }
     /**
-     * Creates the texture of sampler `name` (`format`: r8, r8ui, r16ui, r16i, r32ui, r32f, rg16ui, rg32f, rgba8,
-     * rgba8ui, rgba16ui, rgba32f; `depth` 0 for 2D, else a 2D array of that many layers; `linear` filtering for the
-     * non-integer formats); `data`: its texels as bytes, or undefined for an empty texture
+     * Creates the texture `name` of a ground layer (`format`: r8, r8ui, r16ui, r16i, r32ui, r32f, rg16ui, rg32f,
+     * rgba8, rgba8ui, rgba16ui, rgba32f; `depth` 0 for 2D, else a 2D array of that many layers); `data`: its texels
+     * as bytes, or undefined for an empty texture
      *
      * # Errors
      *
-     * Throws (to JavaScript) on an unknown `format`, a size not positive (or overflowing), `data` shorter
-     * than the texels, more textures than the layer takes, or a texture WebGL cannot create
+     * Throws (to JavaScript) on an unknown `format`, a size of 0, `data` shorter than the texels, a name WGSL does not
+     * take, or more textures than the layer takes
      * @param {number} id
      * @param {string} name
      * @param {string} format
      * @param {number} width
      * @param {number} height
      * @param {number} depth
-     * @param {boolean} linear
      * @param {Uint8Array | null} [data]
      */
-    setGroundTexture(id, name, format, width, height, depth, linear, data) {
+    setGroundTexture(id, name, format, width, height, depth, data) {
         const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
         var ptr2 = isLikeNone(data) ? 0 : passArray8ToWasm0(data, wasm.__wbindgen_malloc);
         var len2 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setGroundTexture(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, width, height, depth, linear, ptr2, len2);
+        const ret = wasm.engine_setGroundTexture(this.__wbg_ptr, id, ptr0, len0, ptr1, len1, width, height, depth, ptr2, len2);
         if (ret[1]) {
             throw takeFromExternrefTable0(ret[0]);
         }
     }
     /**
-     * A uniform of a ground layer's code, as numbers
+     * A uniform of a ground layer's code, as numbers (column major for a matrix)
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the shader has no uniform `name` (one its code does not use is removed
-     * by the compiler)
+     * Throws (to JavaScript) when no uniform `name` was declared, or for a count of numbers not its type's
      * @param {number} id
      * @param {string} name
      * @param {Float64Array} values
@@ -987,8 +1099,7 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when `width` or `height` is not positive (or their product overflows), or the
-     * atlas texture cannot be created
+     * Throws (to JavaScript) when `width` or `height` is not positive or past the GPU's largest texture
      * @param {number} width
      * @param {number} height
      */
@@ -1020,8 +1131,8 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or
-     * when it cannot be created; the layer then keeps its lines
+     * Throws (to JavaScript) when the lines need a table past the GPU's largest texture; the layer then keeps its
+     * lines
      * @param {number} id
      * @param {Float64Array} points
      * @param {Uint32Array} start
@@ -1050,6 +1161,50 @@ export class Engine {
     setMaxPitch(max) {
         wasm.engine_setMaxPitch(this.__wbg_ptr, max);
     }
+    /**
+     * The GPU memory the layers' tiles (3D Tiles, point clouds) and the rasters' pools may hold all together (bytes):
+     * past it the tiles drawn least recently are unloaded, whichever their layer. A raster's pool takes its memory
+     * when it is made: one made later takes the budget as it is then
+     * @param {number} bytes
+     */
+    setMemoryBudget(bytes) {
+        wasm.engine_setMemoryBudget(this.__wbg_ptr, bytes);
+    }
+    /**
+     * Lights at night the part of a model layer's model from `from` metres up (a street lamp's head) in `r, g, b`;
+     * `from` not a number: none
+     * @param {number} id
+     * @param {number} from
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setModelGlow(id, from, r, g, b) {
+        wasm.engine_setModelGlow(this.__wbg_ptr, id, from, r, g, b);
+    }
+    /**
+     * Highlights the feature `feature` of a model layer's model (an IFC model's element) in `r, g, b`; `feature` not a
+     * number: none
+     * @param {number} id
+     * @param {number} feature
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     */
+    setModelHighlight(id, feature, r, g, b) {
+        wasm.engine_setModelHighlight(this.__wbg_ptr, id, feature, r, g, b);
+    }
+    /**
+     * 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
@@ -1102,10 +1257,46 @@ export class Engine {
         const len0 = WASM_VECTOR_LEN;
         wasm.engine_setNetworkValues(this.__wbg_ptr, id, ptr0, len0);
     }
+    /**
+     * The image of camera `index` of the panorama (the images sharing the size of the first), which the engine takes
+     * (closes once copied)
+     * @param {number} index
+     * @param {ImageBitmap} image
+     */
+    setPanoramaImage(index, image) {
+        wasm.engine_setPanoramaImage(this.__wbg_ptr, index, image);
+    }
+    /**
+     * Shows a panorama: at `lon`, `lat` (degrees) and `height` (metres above the ellipsoid), turned by `rotation`
+     * (9 numbers, row-major: its frame to east, north, up), its `cameras` (25 numbers each: rotation from the panorama
+     * frame, row-major, 9; position in it, 3; focal x, y; center x, y; skew; image width, height; principal point of
+     * the distortion x, y; its coefficients r³, r⁵, r⁷; its limit, pixels), a backdrop sphere of `radius` metres, at
+     * `opacity`. Its images come after (`setPanoramaImage`)
+     *
+     * # Errors
+     *
+     * Throws (to JavaScript) when `rotation` holds fewer than 9 numbers
+     * @param {number} lon
+     * @param {number} lat
+     * @param {number} height
+     * @param {Float64Array} rotation
+     * @param {Float64Array} cameras
+     * @param {number} radius
+     * @param {number} opacity
+     */
+    setPanorama(lon, lat, height, rotation, cameras, radius, opacity) {
+        const ptr0 = passArrayF64ToWasm0(rotation, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF64ToWasm0(cameras, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.engine_setPanorama(this.__wbg_ptr, lon, lat, height, ptr0, len0, ptr1, len1, radius, opacity);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * Sets the point the next turns and tilts go around (`rotate`): what is drawn under a screen point (CSS
-     * pixels), a roof or a mesh as the relief. Read back from the last frame (a stall): once, where a drag starts.
-     * Returns whether something was drawn there; over nothing, the turns go around the center
+     * pixels). Returns whether something was drawn there; over nothing, the turns go around the center
      * @param {number} x
      * @param {number} y
      * @returns {boolean}
@@ -1114,6 +1305,23 @@ export class Engine {
         const ret = wasm.engine_setPivot(this.__wbg_ptr, x, y);
         return ret !== 0;
     }
+    /**
+     * 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);
+    }
     /**
      * Opacity and saturation (0-1) of a raster layer; nothing for another id
      * @param {number} id
@@ -1150,25 +1358,17 @@ export class Engine {
      * The sun casting shadows and the night: its azimuth (degrees clockwise from north) and altitude (degrees above
      * the horizon), the shadows' opacity (0 to 1; none under the horizon or not a number), how dark the night is (0 to
      * 1: the frame tinted, the lights of the layers on). Neither shadows nor night: nothing drawn
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when a WebGL object cannot be created or the pass fails to compile
      * @param {number} azimuth
      * @param {number} altitude
      * @param {number} opacity
      * @param {number} night
      */
     setSun(azimuth, altitude, opacity, night) {
-        const ret = wasm.engine_setSun(this.__wbg_ptr, azimuth, altitude, opacity, night);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+        wasm.engine_setSun(this.__wbg_ptr, azimuth, altitude, opacity, night);
     }
     /**
-     * Shows `layers` on one side of a vertical line only, the others beneath on the other side (comparing two states
-     * of a place): left of `x` (CSS pixels from the left of the canvas), or right of it; `others` on the other side
-     * only (two meshes of the same place, each on its side, never drawn over each other); a non-finite `x` stops
+     * Shows `layers` left of `x` (CSS pixels from the left of the canvas; right of it if `right`), `others` on the
+     * other side only; `x` not a number, or no layer: no swipe
      * @param {number} x
      * @param {boolean} right
      * @param {Uint32Array} layers
@@ -1207,8 +1407,8 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the labels need a table texture past the GPU's `MAX_TEXTURE_SIZE`, or
-     * when it cannot be created; the layer then keeps its labels
+     * Throws (to JavaScript) when the labels need a table past the GPU's largest texture; the layer then keeps its
+     * labels
      * @param {number} id
      * @param {Float64Array} anchors
      * @param {Float32Array} boxes
@@ -1236,15 +1436,10 @@ export class Engine {
      * Relief under the raster layers, from raw altitudes (`image/x-bil;bits=32`, 256 × 256, or the same followed by
      * the validity mask of an `ArcGIS` raw grid): `url` is a template with `{bbox}` (WMS `GetMap` in EPSG:3857, or in
      * the Mercator metres of another body) or `{z}/{x}/{y}`; `undefined` turns it off. `exaggeration` scales the
-     * heights (1: true relief); `max_z`: finest level loaded (up to 15, from 6 on the Earth, coarser on bodies of a
-     * larger relief for their size: `terrain_levels`); `geoid`: altitudes raised by the RAF20 geoid height (heights
-     * above the ellipsoid, those of 3D Tiles; over France, on the Earth only), else left as served (the default);
-     * `loader`: gives the
-     * altitudes of each tile instead of fetching `url` (an encoding decoded by the page: Terrarium, Terrain-RGB)
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when the texture holding the relief's tiles cannot be created
+     * heights (1: true relief); `max_z`: finest level loaded; `geoid`: altitudes raised by the RAF20 geoid height
+     * (heights above the ellipsoid, those of 3D Tiles; over France, on the Earth only), else left as served (the
+     * default); `loader`: gives the altitudes of each tile instead of fetching `url` (an encoding decoded by the
+     * page: Terrarium, Terrain-RGB)
      * @param {string | null | undefined} url
      * @param {number} exaggeration
      * @param {number | null | undefined} max_z
@@ -1254,21 +1449,56 @@ export class Engine {
     setTerrain(url, exaggeration, max_z, geoid, loader) {
         var ptr0 = isLikeNone(url) ? 0 : passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setTerrain(this.__wbg_ptr, ptr0, len0, exaggeration, isLikeNone(max_z) ? 0xFFFFFF : max_z, isLikeNone(geoid) ? 0xFFFFFF : geoid ? 1 : 0, isLikeNone(loader) ? 0 : addToExternrefTable0(loader));
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+        wasm.engine_setTerrain(this.__wbg_ptr, ptr0, len0, exaggeration, isLikeNone(max_z) ? 0xFFFFFF : max_z, isLikeNone(geoid) ? 0xFFFFFF : geoid ? 1 : 0, isLikeNone(loader) ? 0 : addToExternrefTable0(loader));
+    }
+    /**
+     * Pool of workers that fetch and decode 3D Tiles content off the main thread: an object with
+     * `load(id, url, transform, yUp, reload, priority) → Promise<{ anchor, primitives }>` and `abort(id)`. Without
+     * it, tiles are decoded on the main thread. Set it before adding 3D Tiles layers.
+     * @param {import('./isard_tiles3d.js').TileLoaderLike | null} loader
+     */
+    setTileLoader(loader) {
+        wasm.engine_setTileLoader(this.__wbg_ptr, loader);
+    }
+    /**
+     * Whether the walls of a 3D Tiles layer's untextured meshes show their windows: glass by day, some lit at night
+     * @param {number} id
+     * @param {boolean} facades
+     */
+    setTiles3dFacades(id, facades) {
+        wasm.engine_setTiles3dFacades(this.__wbg_ptr, id, facades);
+    }
+    /**
+     * Each feature of a 3D Tiles layer its color (null: the layer's)
+     * @param {number} id
+     * @param {((properties: Record<string, unknown>[] | undefined, count: number) => Uint8Array) | null} colors
+     */
+    setTiles3dFeatureColors(id, colors) {
+        wasm.engine_setTiles3dFeatureColors(this.__wbg_ptr, id, colors);
+    }
+    /**
+     * Screen-space error threshold, opacity, size of the points (CSS pixels, 2 if not given) and color (RGB 0-1, empty
+     * for none: it tints the textures and colors the untextured meshes) of a 3D Tiles layer
+     * @param {number} id
+     * @param {number} max_error
+     * @param {number} opacity
+     * @param {number | null | undefined} point_size
+     * @param {Float32Array} color
+     */
+    setTiles3dStyle(id, max_error, opacity, point_size, color) {
+        const ptr0 = passArrayF32ToWasm0(color, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.engine_setTiles3dStyle(this.__wbg_ptr, id, max_error, opacity, !isLikeNone(point_size), isLikeNone(point_size) ? 0 : point_size, ptr0, len0);
     }
     /**
      * The style layers of a vector tile layer, in drawing order: per layer, its kind (0 fill, 1 line, 2 extrusion, 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), 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)
+     * 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), 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
@@ -1306,18 +1536,18 @@ export class Engine {
     }
     /**
      * Adds or replaces tile `key` of a vector tile layer ready for the GPU, as the basemap workers make it (the
-     * tessellation module): its polygons as for `setVectorTile` (picked here; their prisms built here if drawn in
-     * relief while `prism` is false), the vertices of its fills (`shapes::Vertex` as bytes, each with its feature),
-     * their triangles, per sublayer its top cap and the rest of its prism (`fill_ranges`: four numbers, first and
-     * end of each), its line pieces (`pieces::Piece` as bytes), the line table (feature and length of each line),
+     * tessellation module): its polygons as for `setVectorTile` (their prisms built here if drawn in relief while
+     * `prism` is false), the vertices of its fills (`shapes::Vertex` as bytes, each with its feature), their
+     * triangles, per sublayer its top cap and the rest of its prism (`fill_ranges`: four numbers, first and end of
+     * each), its line pieces (`vector_tiles::TilePiece` as bytes), the line table (feature and length of each line),
      * per sublayer its pieces (`line_ranges`: first, end), the blocks of its extrusion sublayers (`shapes::Block` as
      * bytes), their triangles, per sublayer its blocks' triangles (`block_ranges`: first, end), the extent of its
      * points (`bounds`: min x, min y, max x, max y), its features' sublayers (one each, as for `setVectorTile`)
      *
      * # Errors
      *
-     * Throws (to JavaScript) when the vertices, pieces or blocks are cut short, when a WebGL object of the tile cannot be
-     * created, or when its features or lines need a table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when the vertices, pieces or blocks are cut short, or when its features or lines need a
+     * table past the GPU's largest texture
      * @param {number} id
      * @param {number} key
      * @param {Float64Array} points
@@ -1399,19 +1629,16 @@ export class Engine {
      * 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), its features' sublayers (one each, the
-     * features of a sublayer after those of the one before), 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; `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
+     * features of a sublayer after those of the one before), styled as an extrusion layer's (`setFeatureStyle` with
+     * the key); `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; `roofs` and `roof_heights`: per polygon, the shape and height of its block's
+     * roof (`shapes::Roofs`), 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
      *
-     * Throws (to JavaScript) when a WebGL object of the tile cannot be created, or when its features or lines need a
-     * table texture past the GPU's `MAX_TEXTURE_SIZE`
+     * Throws (to JavaScript) when its features or lines need a table past the GPU's largest texture
      * @param {number} id
      * @param {number} key
      * @param {Float64Array} points
@@ -1473,11 +1700,6 @@ export class Engine {
      * only heading, tilt, angles of view across and up (degrees), the heading NaN to look all around. What some
      * observer sees is tinted with `visible`, what is hidden from all those that reach it with `hidden` (RGB 0-1),
      * at `opacity`; `outline` (RGB 0-1, or empty) the color of the cones' edges drawn in 3D
-     *
-     * # Errors
-     *
-     * Throws (to JavaScript) when, on the first call, a WebGL object cannot be created or a shader fails to compile
-     * (the error carries its info log)
      * @param {Float64Array} observers
      * @param {Float32Array} visible
      * @param {Float32Array} hidden
@@ -1493,10 +1715,7 @@ export class Engine {
         const len2 = WASM_VECTOR_LEN;
         const ptr3 = passArrayF32ToWasm0(outline, wasm.__wbindgen_malloc);
         const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity, ptr3, len3);
-        if (ret[1]) {
-            throw takeFromExternrefTable0(ret[0]);
-        }
+        wasm.engine_setViewshed(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, opacity, ptr3, len3);
     }
     /**
      * Lowest and highest zoom levels the camera accepts
@@ -1527,8 +1746,9 @@ export class Engine {
     }
     /**
      * The height above the relief (metres) of the top of what stands at a position (degrees): a roof, a mesh, 0 on
-     * the bare ground; undefined where nothing of the last frame is there. The scene is drawn from above into a single
-     * pixel and read back (a stall, cheap: one pixel to fill)
+     * the bare ground; undefined where nothing of the last frame is there, or until measured: the scene is drawn
+     * looking down at it after a frame and read back a frame or two later (a frame is asked for), the answer kept and
+     * measured again every 250 ms at most
      * @param {number} lon
      * @param {number} lat
      * @returns {any}
@@ -1539,8 +1759,8 @@ export class Engine {
     }
     /**
      * What is drawn under a screen point (CSS pixels): longitude, latitude and its height above the relief (metres),
-     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. The scene is drawn again and
-     * read back (a stall): for clicks and drags
+     * on a roof, a wall or a mesh as on the ground; undefined where nothing was drawn. From the last copy of the
+     * scene's depth (a frame or two old, one pixel in 4 CSS pixels): at once, without waiting for the GPU
      * @param {number} x
      * @param {number} y
      * @returns {[lon: number, lat: number, height: number] | undefined}
@@ -1549,6 +1769,35 @@ export class Engine {
         const ret = wasm.engine_surface(this.__wbg_ptr, x, y);
         return ret;
     }
+    /**
+     * Compressed texture formats of the GPU, for the KTX2 transcoding
+     * @returns {import('./isard_tiles3d.js').TextureFormats}
+     */
+    textureFormats() {
+        const ret = wasm.engine_textureFormats(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The feature of a picked handle (`pick`'s index on a 3D Tiles layer): `[properties, feature]`, its properties
+     * (undefined when its tile has none) and its index in its tile; undefined if the handle is not of the last picking
+     * pass
+     * @param {number} id
+     * @param {number} index
+     * @returns {[properties: Record<string, unknown> | undefined, feature: number] | undefined}
+     */
+    tiles3dFeature(id, index) {
+        const ret = wasm.engine_tiles3dFeature(this.__wbg_ptr, id, index);
+        return ret;
+    }
+    /**
+     * Counters of a 3D Tiles layer, undefined if there is none with this id
+     * @param {number} id
+     * @returns {Tiles3dStats | undefined}
+     */
+    tiles3dStats(id) {
+        const ret = wasm.engine_tiles3dStats(this.__wbg_ptr, id);
+        return ret;
+    }
     /**
      * A region of the first page of the glyph atlas: `width` × `height` bytes at (`x`, `y`)
      * @param {number} x
@@ -1581,8 +1830,8 @@ export class Engine {
      *
      * # Errors
      *
-     * Throws (to JavaScript) when there is no texture `name`, or when the region is out of its bounds or
-     * `data` holds too few bytes
+     * Throws (to JavaScript) when there is no texture `name`, or when the region is out of its bounds or `data` holds
+     * too few bytes
      * @param {number} id
      * @param {string} name
      * @param {number} x
@@ -1615,22 +1864,11 @@ 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
-     * vector tile layer draws (`addVectorTiles`), coarser far away in a tilted view as the raster layers, and no
-     * farther than `reach` times the screen center's distance (infinite: to the horizon)
+     * vector tile layer draws, coarser far away in a tilted view as the raster layers, and no farther than `reach`
+     * times the screen center's distance (infinite: to the horizon)
      * @param {number} min_z
      * @param {number} max_z
      * @param {number} reach
@@ -1668,6 +1906,14 @@ if (Symbol.dispose) Engine.prototype[Symbol.dispose] = Engine.prototype.free;
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
+        __wbg_Window_a2a6c4d665047b14: function(arg0) {
+            const ret = arg0.Window;
+            return ret;
+        },
+        __wbg_WorkerGlobalScope_2664448a7c667d67: function(arg0) {
+            const ret = arg0.WorkerGlobalScope;
+            return ret;
+        },
         __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
@@ -1680,6 +1926,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;
@@ -1688,6 +1938,15 @@ function __wbg_get_imports() {
             const ret = arg0 === null;
             return ret;
         },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = arg0;
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_90b56bc79aad6f6c: function(arg0) {
+            const ret = typeof(arg0) === 'string';
+            return ret;
+        },
         __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
@@ -1725,6 +1984,10 @@ function __wbg_get_imports() {
         __wbg_activeTexture_2fad46c01cafe6b1: function(arg0, arg1) {
             arg0.activeTexture(arg1 >>> 0);
         },
+        __wbg_apply_a910804df6e1e433: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.apply(arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_arrayBuffer_f07be74819944ea2: function() { return handleError(function (arg0) {
             const ret = arg0.arrayBuffer();
             return ret;
@@ -1735,6 +1998,22 @@ function __wbg_get_imports() {
         __wbg_attachShader_9567ae57af6746d5: function(arg0, arg1, arg2) {
             arg0.attachShader(arg1, arg2);
         },
+        __wbg_beginQuery_eaee271e7ccd67d1: function(arg0, arg1, arg2) {
+            arg0.beginQuery(arg1 >>> 0, arg2);
+        },
+        __wbg_beginRenderPass_3c53642423af50dc: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.beginRenderPass(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_bindAttribLocation_6a6f66cbe96ef24e: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.bindAttribLocation(arg1, arg2 >>> 0, getStringFromWasm0(arg3, arg4));
+        },
+        __wbg_bindAttribLocation_ade0ee986a734cdf: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.bindAttribLocation(arg1, arg2 >>> 0, getStringFromWasm0(arg3, arg4));
+        },
+        __wbg_bindBufferRange_a5aef3642afdabc8: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.bindBufferRange(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
+        },
         __wbg_bindBuffer_0324f62b876c4403: function(arg0, arg1, arg2) {
             arg0.bindBuffer(arg1 >>> 0, arg2);
         },
@@ -1753,6 +2032,9 @@ function __wbg_get_imports() {
         __wbg_bindRenderbuffer_e0c5aeef245a913a: function(arg0, arg1, arg2) {
             arg0.bindRenderbuffer(arg1 >>> 0, arg2);
         },
+        __wbg_bindSampler_9b9743706aee71d1: function(arg0, arg1, arg2) {
+            arg0.bindSampler(arg1 >>> 0, arg2);
+        },
         __wbg_bindTexture_3cf008f256f3ed99: function(arg0, arg1, arg2) {
             arg0.bindTexture(arg1 >>> 0, arg2);
         },
@@ -1765,6 +2047,18 @@ function __wbg_get_imports() {
         __wbg_bindVertexArray_f58af0a346185ec5: function(arg0, arg1) {
             arg0.bindVertexArray(arg1);
         },
+        __wbg_blendColor_68fc6d6454f2128d: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.blendColor(arg1, arg2, arg3, arg4);
+        },
+        __wbg_blendColor_a6256f41d1925899: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.blendColor(arg1, arg2, arg3, arg4);
+        },
+        __wbg_blendEquationSeparate_0a17fa4ea863d445: function(arg0, arg1, arg2) {
+            arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
+        },
+        __wbg_blendEquationSeparate_fa2d4e5dde5ad8b3: function(arg0, arg1, arg2) {
+            arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
+        },
         __wbg_blendEquation_5fb8aee6a55cf900: function(arg0, arg1) {
             arg0.blendEquation(arg1 >>> 0);
         },
@@ -1783,6 +2077,9 @@ function __wbg_get_imports() {
         __wbg_blendFunc_589e4252bb396484: function(arg0, arg1, arg2) {
             arg0.blendFunc(arg1 >>> 0, arg2 >>> 0);
         },
+        __wbg_blitFramebuffer_7b39bfec6cfece56: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+            arg0.blitFramebuffer(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0);
+        },
         __wbg_blob_232135c7e297b861: function() { return handleError(function (arg0) {
             const ret = arg0.blob();
             return ret;
@@ -1805,26 +2102,71 @@ function __wbg_get_imports() {
         __wbg_bufferSubData_8609cd8a2c013181: function(arg0, arg1, arg2, arg3) {
             arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
         },
-        __wbg_byteLength_27689b065d089962: function(arg0) {
-            const ret = arg0.byteLength;
+        __wbg_buffer_6aace268d05b9dbe: function(arg0) {
+            const ret = arg0.buffer;
             return ret;
         },
-        __wbg_call_01721c8c75200a10: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-            const ret = arg0.call(arg1, arg2, arg3, arg4, arg5);
+        __wbg_buffer_9cb148c510fd44ba: function(arg0) {
+            const ret = arg0.buffer;
             return ret;
-        }, arguments); },
-        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
-            const ret = arg0.call(arg1);
+        },
+        __wbg_byteLength_141bda7c7c28aa72: function(arg0) {
+            const ret = arg0.byteLength;
             return ret;
-        }, arguments); },
-        __wbg_clearColor_3f6aa096dc12e8b7: function(arg0, arg1, arg2, arg3, arg4) {
-            arg0.clearColor(arg1, arg2, arg3, arg4);
         },
-        __wbg_clearColor_796427e8ac60fe14: function(arg0, arg1, arg2, arg3, arg4) {
-            arg0.clearColor(arg1, arg2, arg3, arg4);
+        __wbg_byteLength_18a1704c0bf397bb: function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
         },
-        __wbg_clearStencil_1b8b8c727f598eec: function(arg0, arg1) {
-            arg0.clearStencil(arg1);
+        __wbg_byteLength_27689b065d089962: function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
+        },
+        __wbg_byteLength_9f985b8373f1f3fe: function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
+        },
+        __wbg_byteOffset_0a6d6550fa691da7: function(arg0) {
+            const ret = arg0.byteOffset;
+            return ret;
+        },
+        __wbg_byteOffset_58a6efdc19adce02: function(arg0) {
+            const ret = arg0.byteOffset;
+            return ret;
+        },
+        __wbg_call_01721c8c75200a10: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            const ret = arg0.call(arg1, arg2, arg3, arg4, arg5);
+            return ret;
+        }, arguments); },
+        __wbg_call_1875a20c43a36133: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.call(arg1, arg2, arg3);
+            return ret;
+        }, arguments); },
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_clearBufferfv_05f7fc7252e623eb: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.clearBufferfv(arg1 >>> 0, arg2, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_clearBufferiv_e8e740accbd0f2df: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.clearBufferiv(arg1 >>> 0, arg2, getArrayI32FromWasm0(arg3, arg4));
+        },
+        __wbg_clearBufferuiv_e7f50f91f2195e38: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.clearBufferuiv(arg1 >>> 0, arg2, getArrayU32FromWasm0(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);
         },
         __wbg_clearStencil_e4383e4a543e7997: function(arg0, arg1) {
             arg0.clearStencil(arg1);
@@ -1835,6 +2177,10 @@ function __wbg_get_imports() {
         __wbg_clear_cb96796cc568b7c8: function(arg0, arg1) {
             arg0.clear(arg1 >>> 0);
         },
+        __wbg_clientWaitSync_73122aa040ce343d: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.clientWaitSync(arg1, arg2 >>> 0, arg3 >>> 0);
+            return ret;
+        },
         __wbg_close_355afba6ea5ad1ae: function(arg0) {
             arg0.close();
         },
@@ -1850,14 +2196,72 @@ function __wbg_get_imports() {
         __wbg_compileShader_c2b53ff3a8851f60: function(arg0, arg1) {
             arg0.compileShader(arg1);
         },
+        __wbg_compressedTexSubImage2D_4942a783e20221c2: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+            arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8);
+        },
+        __wbg_compressedTexSubImage2D_4c408678ff5f3056: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8, arg9);
+        },
+        __wbg_compressedTexSubImage2D_80961cdbbd2b3aea: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+            arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8);
+        },
+        __wbg_compressedTexSubImage3D_1e0f86237d82f8b9: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+            arg0.compressedTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10);
+        },
+        __wbg_compressedTexSubImage3D_682e402a0ac201ba: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+            arg0.compressedTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10, arg11);
+        },
+        __wbg_configure_1e2c1c9edad07d26: function() { return handleError(function (arg0, arg1) {
+            arg0.configure(arg1);
+        }, arguments); },
+        __wbg_copyBufferSubData_e82219c4834bd9ae: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.copyBufferSubData(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
+        },
+        __wbg_copyBufferToBuffer_01766818654a9868: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4);
+        }, arguments); },
+        __wbg_copyBufferToBuffer_9c174b96fb08d551: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4, arg5);
+        }, arguments); },
+        __wbg_copyExternalImageToTexture_116560f3be856776: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            arg0.copyExternalImageToTexture(arg1, arg2, arg3);
+        }, arguments); },
+        __wbg_copyTexSubImage2D_455fba12cf4a776c: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+            arg0.copyTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+        },
+        __wbg_copyTexSubImage2D_fe71e36efa520f37: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
+            arg0.copyTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+        },
+        __wbg_copyTexSubImage3D_717cd6c97934f2e6: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.copyTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        },
+        __wbg_copyTextureToBuffer_1234b3210431ad05: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            arg0.copyTextureToBuffer(arg1, arg2, arg3);
+        }, arguments); },
+        __wbg_createBindGroupLayout_b1bd63b4e88459d8: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createBindGroupLayout(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_createBindGroup_f539b26ca341308f: function(arg0, arg1) {
+            const ret = arg0.createBindGroup(arg1);
+            return ret;
+        },
         __wbg_createBuffer_d1dd23bf8704564c: function(arg0) {
             const ret = arg0.createBuffer();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createBuffer_d800e9b1d41b2ee5: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createBuffer(arg1);
+            return ret;
+        }, arguments); },
         __wbg_createBuffer_ffe613371d42cfd3: function(arg0) {
             const ret = arg0.createBuffer();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createCommandEncoder_3352d1ffc36c6fc0: function(arg0, arg1) {
+            const ret = arg0.createCommandEncoder(arg1);
+            return ret;
+        },
         __wbg_createFramebuffer_2c6b5b0f49c88e5d: function(arg0) {
             const ret = arg0.createFramebuffer();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1874,6 +2278,10 @@ function __wbg_get_imports() {
             const ret = arg0.createImageBitmap(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_createPipelineLayout_6eab52c327118937: function(arg0, arg1) {
+            const ret = arg0.createPipelineLayout(arg1);
+            return ret;
+        },
         __wbg_createProgram_cbf448e6f18a9402: function(arg0) {
             const ret = arg0.createProgram();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1882,6 +2290,14 @@ function __wbg_get_imports() {
             const ret = arg0.createProgram();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createQuery_ec241083d0b36197: function(arg0) {
+            const ret = arg0.createQuery();
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_createRenderPipeline_0ebb7ebc653e9207: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createRenderPipeline(arg1);
+            return ret;
+        }, arguments); },
         __wbg_createRenderbuffer_2b17e9fe2e6fb4be: function(arg0) {
             const ret = arg0.createRenderbuffer();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1890,6 +2306,18 @@ function __wbg_get_imports() {
             const ret = arg0.createRenderbuffer();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createSampler_1b330d9da0c6523f: function(arg0) {
+            const ret = arg0.createSampler();
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_createSampler_9bd91d7e928c0060: function(arg0, arg1) {
+            const ret = arg0.createSampler(arg1);
+            return ret;
+        },
+        __wbg_createShaderModule_cefa51336cb288ae: function(arg0, arg1) {
+            const ret = arg0.createShaderModule(arg1);
+            return ret;
+        },
         __wbg_createShader_6c1a2295587878a5: function(arg0, arg1) {
             const ret = arg0.createShader(arg1 >>> 0);
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1906,6 +2334,10 @@ function __wbg_get_imports() {
             const ret = arg0.createTexture();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createTexture_ed7e9fc04dd54d84: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createTexture(arg1);
+            return ret;
+        }, arguments); },
         __wbg_createVertexArrayOES_a8dc8498b56df937: function(arg0) {
             const ret = arg0.createVertexArrayOES();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -1914,6 +2346,10 @@ function __wbg_get_imports() {
             const ret = arg0.createVertexArray();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_createView_da41c2d2cb212715: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.createView(arg1);
+            return ret;
+        }, arguments); },
         __wbg_cullFace_12123c1c97f1ba2c: function(arg0, arg1) {
             arg0.cullFace(arg1 >>> 0);
         },
@@ -1938,12 +2374,18 @@ function __wbg_get_imports() {
         __wbg_deleteProgram_b524b30ad176cdb4: function(arg0, arg1) {
             arg0.deleteProgram(arg1);
         },
+        __wbg_deleteQuery_266895df9763e0b3: function(arg0, arg1) {
+            arg0.deleteQuery(arg1);
+        },
         __wbg_deleteRenderbuffer_826c9b43b7ea68f5: function(arg0, arg1) {
             arg0.deleteRenderbuffer(arg1);
         },
         __wbg_deleteRenderbuffer_f4e121a3ab21c605: function(arg0, arg1) {
             arg0.deleteRenderbuffer(arg1);
         },
+        __wbg_deleteSampler_f8afded8bf215d53: function(arg0, arg1) {
+            arg0.deleteSampler(arg1);
+        },
         __wbg_deleteShader_a70f6cc1918d67eb: function(arg0, arg1) {
             arg0.deleteShader(arg1);
         },
@@ -1983,11 +2425,15 @@ function __wbg_get_imports() {
         __wbg_depthRange_6a4e169ccf314148: function(arg0, arg1, arg2) {
             arg0.depthRange(arg1, arg2);
         },
-        __wbg_detachShader_1ed15fc2d289cf15: function(arg0, arg1, arg2) {
-            arg0.detachShader(arg1, arg2);
+        __wbg_description_83b8a393160021b9: function(arg0, arg1) {
+            const ret = arg1.description;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_detachShader_67dabaaad80a795e: function(arg0, arg1, arg2) {
-            arg0.detachShader(arg1, arg2);
+        __wbg_destroy_637537007d9eaa44: function(arg0) {
+            arg0.destroy();
         },
         __wbg_disableVertexAttribArray_11c9f11bee30c9d8: function(arg0, arg1) {
             arg0.disableVertexAttribArray(arg1 >>> 0);
@@ -2001,6 +2447,18 @@ function __wbg_get_imports() {
         __wbg_disable_81b2cb5f8cea15ae: function(arg0, arg1) {
             arg0.disable(arg1 >>> 0);
         },
+        __wbg_displayHeight_903e670be87f29ab: function(arg0) {
+            const ret = arg0.displayHeight;
+            return ret;
+        },
+        __wbg_displayWidth_5da2bf55e335368a: function(arg0) {
+            const ret = arg0.displayWidth;
+            return ret;
+        },
+        __wbg_document_9854e03c05fc8834: function(arg0) {
+            const ret = arg0.document;
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
         __wbg_drawArraysInstancedANGLE_b76512b5abba6668: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.drawArraysInstancedANGLE(arg1 >>> 0, arg2, arg3, arg4);
         },
@@ -2013,17 +2471,23 @@ function __wbg_get_imports() {
         __wbg_drawArrays_741af5c3f8db636f: function(arg0, arg1, arg2, arg3) {
             arg0.drawArrays(arg1 >>> 0, arg2, arg3);
         },
+        __wbg_drawBuffersWEBGL_c1bc0bbfd584c9b2: function(arg0, arg1) {
+            arg0.drawBuffersWEBGL(arg1);
+        },
+        __wbg_drawBuffers_7a58bd4729f7a1fc: function(arg0, arg1) {
+            arg0.drawBuffers(arg1);
+        },
         __wbg_drawElementsInstancedANGLE_c3fc0cfa9e29a1bc: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             arg0.drawElementsInstancedANGLE(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
         },
         __wbg_drawElementsInstanced_d7c396aa034159b6: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             arg0.drawElementsInstanced(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
         },
-        __wbg_drawElements_c8988ba71de1101a: function(arg0, arg1, arg2, arg3, arg4) {
-            arg0.drawElements(arg1 >>> 0, arg2, arg3 >>> 0, arg4);
+        __wbg_drawIndexed_638959aae942557c: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
         },
-        __wbg_drawElements_cc1e6c631e89eddf: function(arg0, arg1, arg2, arg3, arg4) {
-            arg0.drawElements(arg1 >>> 0, arg2, arg3 >>> 0, arg4);
+        __wbg_draw_086a9578fc9898c2: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
         },
         __wbg_enableVertexAttribArray_1496b78a8dbab9fd: function(arg0, arg1) {
             arg0.enableVertexAttribArray(arg1 >>> 0);
@@ -2037,6 +2501,31 @@ function __wbg_get_imports() {
         __wbg_enable_cb4fc19b51148c37: function(arg0, arg1) {
             arg0.enable(arg1 >>> 0);
         },
+        __wbg_endQuery_73863d04a795d520: function(arg0, arg1) {
+            arg0.endQuery(arg1 >>> 0);
+        },
+        __wbg_end_b57473834b877409: function(arg0) {
+            arg0.end();
+        },
+        __wbg_engine_new: function(arg0) {
+            const ret = Engine.__wrap(arg0);
+            return ret;
+        },
+        __wbg_error_8c8dff942c7c4f11: function(arg0) {
+            const ret = arg0.error;
+            return ret;
+        },
+        __wbg_error_c9cf3fc2064683a9: function(arg0) {
+            console.error(arg0);
+        },
+        __wbg_features_5cac120c28ba0475: function(arg0) {
+            const ret = arg0.features;
+            return ret;
+        },
+        __wbg_features_dec7bd2fd3d91bd6: function(arg0) {
+            const ret = arg0.features;
+            return ret;
+        },
         __wbg_fenceSync_330293024adb66bc: function(arg0, arg1, arg2) {
             const ret = arg0.fenceSync(arg1 >>> 0, arg2 >>> 0);
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -2045,6 +2534,20 @@ function __wbg_get_imports() {
             const ret = arg0.fetch(getStringFromWasm0(arg1, arg2), arg3);
             return ret;
         },
+        __wbg_finish_09ec094c10f41e7b: function(arg0) {
+            const ret = arg0.finish();
+            return ret;
+        },
+        __wbg_finish_173a156040775de3: function(arg0) {
+            arg0.finish();
+        },
+        __wbg_finish_31ffb964be7e9749: function(arg0) {
+            arg0.finish();
+        },
+        __wbg_finish_ec1c191f66a895b1: function(arg0, arg1) {
+            const ret = arg0.finish(arg1);
+            return ret;
+        },
         __wbg_flush_13b162660ad850d2: function(arg0) {
             arg0.flush();
         },
@@ -2063,20 +2566,18 @@ function __wbg_get_imports() {
         __wbg_framebufferTexture2D_caddefa1f767646e: function(arg0, arg1, arg2, arg3, arg4, arg5) {
             arg0.framebufferTexture2D(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5);
         },
+        __wbg_framebufferTextureLayer_1d5c0f0e3234e521: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.framebufferTextureLayer(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
+        },
+        __wbg_framebufferTextureMultiviewOVR_77f19224ff7be6ef: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            arg0.framebufferTextureMultiviewOVR(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5, arg6);
+        },
         __wbg_frontFace_6751b4b97f997aeb: function(arg0, arg1) {
             arg0.frontFace(arg1 >>> 0);
         },
         __wbg_frontFace_b064adb15b6f3772: function(arg0, arg1) {
             arg0.frontFace(arg1 >>> 0);
         },
-        __wbg_getActiveUniform_239de631a40c387a: function(arg0, arg1, arg2) {
-            const ret = arg0.getActiveUniform(arg1, arg2 >>> 0);
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
-        __wbg_getActiveUniform_f2052b3c57679fe2: function(arg0, arg1, arg2) {
-            const ret = arg0.getActiveUniform(arg1, arg2 >>> 0);
-            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
-        },
         __wbg_getBufferSubData_dd23246099b166d1: function(arg0, arg1, arg2, arg3) {
             arg0.getBufferSubData(arg1 >>> 0, arg2, arg3);
         },
@@ -2084,10 +2585,34 @@ function __wbg_get_imports() {
             const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         }, arguments); },
+        __wbg_getContext_189ce278aa985704: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_getContext_635e36719cad2623: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_getContext_e567868594d2e0c6: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_getCurrentTexture_9f3b84d0eaa6cd95: function() { return handleError(function (arg0) {
+            const ret = arg0.getCurrentTexture();
+            return ret;
+        }, arguments); },
         __wbg_getExtension_abfda2c5db286b07: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.getExtension(getStringFromWasm0(arg1, arg2));
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         }, arguments); },
+        __wbg_getIndexedParameter_0f49864473e337fa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.getIndexedParameter(arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        }, arguments); },
+        __wbg_getMappedRange_fb54c6327b2d8d20: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.getMappedRange(arg1, arg2);
+            return ret;
+        }, arguments); },
         __wbg_getParameter_974595a6624c6c10: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.getParameter(arg1 >>> 0);
             return ret;
@@ -2096,6 +2621,10 @@ function __wbg_get_imports() {
             const ret = arg0.getParameter(arg1 >>> 0);
             return ret;
         }, arguments); },
+        __wbg_getPreferredCanvasFormat_0ef5034c8902201b: function(arg0) {
+            const ret = arg0.getPreferredCanvasFormat();
+            return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 102) - 1;
+        },
         __wbg_getProgramInfoLog_208fb1ff31006495: function(arg0, arg1, arg2) {
             const ret = arg1.getProgramInfoLog(arg2);
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2118,6 +2647,10 @@ function __wbg_get_imports() {
             const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
             return ret;
         },
+        __wbg_getQueryParameter_937ba13f77db778f: function(arg0, arg1, arg2) {
+            const ret = arg0.getQueryParameter(arg1, arg2 >>> 0);
+            return ret;
+        },
         __wbg_getShaderInfoLog_7e0cbba353ca95da: function(arg0, arg1, arg2) {
             const ret = arg1.getShaderInfoLog(arg2);
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -2144,10 +2677,18 @@ function __wbg_get_imports() {
             const ret = arg0.getSupportedExtensions();
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_getSupportedProfiles_7b2acfa66b565d24: function(arg0) {
+            const ret = arg0.getSupportedProfiles();
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
         __wbg_getSyncParameter_bb4be47b67bfa2f8: function(arg0, arg1, arg2) {
             const ret = arg0.getSyncParameter(arg1, arg2 >>> 0);
             return ret;
         },
+        __wbg_getUniformBlockIndex_5e2252ceb34531a5: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.getUniformBlockIndex(arg1, getStringFromWasm0(arg2, arg3));
+            return ret;
+        },
         __wbg_getUniformLocation_50ba45dade572703: function(arg0, arg1, arg2, arg3) {
             const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -2156,14 +2697,73 @@ function __wbg_get_imports() {
             const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1);
+            return ret;
+        }, arguments); },
+        __wbg_get_806853698d9fc227: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(arg0, arg1 >>> 0);
+            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_fd12a9100976c296: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        },
+        __wbg_get_index_f4750150bb3083b3: function(arg0, arg1) {
+            const ret = arg0[arg1 >>> 0];
+            return ret;
+        },
         __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
+        __wbg_gpu_afdd4387c7afe5f9: function(arg0) {
+            const ret = arg0.gpu;
+            return ret;
+        },
+        __wbg_has_eafa12e457ea88fb: function(arg0, arg1, arg2) {
+            const ret = arg0.has(getStringFromWasm0(arg1, arg2));
+            return ret;
+        },
+        __wbg_headers_eba93595f8944c2f: function(arg0) {
+            const ret = arg0.headers;
+            return ret;
+        },
+        __wbg_height_50d2b2bc8c6ec859: function(arg0) {
+            const ret = arg0.height;
+            return ret;
+        },
+        __wbg_height_816341c9bbd4e9e3: function(arg0) {
+            const ret = arg0.height;
+            return ret;
+        },
         __wbg_height_9dca4d43c3e4b84b: function(arg0) {
             const ret = arg0.height;
             return ret;
         },
+        __wbg_height_aa756cf29b6d629c: function(arg0) {
+            const ret = arg0.height;
+            return ret;
+        },
+        __wbg_height_fc97e1a0c2e7331f: function(arg0) {
+            const ret = arg0.height;
+            return ret;
+        },
+        __wbg_includes_9b0dfa946c313621: function(arg0, arg1, arg2) {
+            const ret = arg0.includes(arg1, arg2);
+            return ret;
+        },
+        __wbg_info_971d8b9db3dae69f: function(arg0) {
+            const ret = arg0.info;
+            return ret;
+        },
         __wbg_instanceof_ArrayBuffer_a99f175873e5d9b8: function(arg0) {
             let result;
             try {
@@ -2184,6 +2784,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 {
@@ -2194,6 +2804,46 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Float64Array_8a59377f9eec1b8b: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Float64Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_GpuOutOfMemoryError_5c3b8a2499f59adb: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof GPUOutOfMemoryError;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_GpuValidationError_7659e07b12d4e184: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof GPUValidationError;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_HtmlCanvasElement_0a30c11fbbf41841: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof HTMLCanvasElement;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_ImageBitmap_74bea45ee48d3d7a: function(arg0) {
             let result;
             try {
@@ -2204,6 +2854,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Promise_e1dc6893aa1ece28: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Response_b8758567269c30b2: function(arg0) {
             let result;
             try {
@@ -2214,6 +2874,26 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Uint32Array_53a4facaf04b8a8b: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint32Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_WebGl2RenderingContext_64c994c14c0790fb: function(arg0) {
             let result;
             try {
@@ -2234,22 +2914,28 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isContextLost_fbbab8b921e614b7: function(arg0) {
-            const ret = arg0.isContextLost();
-            return ret;
-        },
-        __wbg_isEnabled_a3522bc4076e6296: function(arg0, arg1) {
-            const ret = arg0.isEnabled(arg1 >>> 0);
+        __wbg_invalidateFramebuffer_4f576db65bb37d6a: function() { return handleError(function (arg0, arg1, arg2) {
+            arg0.invalidateFramebuffer(arg1 >>> 0, arg2);
+        }, arguments); },
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
+            const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isEnabled_acb9d89bd88c16bd: function(arg0, arg1) {
-            const ret = arg0.isEnabled(arg1 >>> 0);
+        __wbg_isFallbackAdapter_4c8cc3b18677460a: function(arg0) {
+            const ret = arg0.isFallbackAdapter;
             return ret;
         },
         __wbg_is_4b278c0bd3caba97: function(arg0, arg1) {
             const ret = Object.is(arg0, arg1);
             return ret;
         },
+        __wbg_label_7add8cb37a6ef98f: function(arg0, arg1) {
+            const ret = arg1.label;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg_length_58572db4c38f3c3e: function(arg0) {
             const ret = arg0.length;
             return ret;
@@ -2258,35 +2944,199 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_length_b5f0008bbf60cf59: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
         __wbg_length_d4bdea10311bd9cf: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_limits_06bcb36c8409843b: function(arg0) {
+            const ret = arg0.limits;
+            return ret;
+        },
+        __wbg_limits_601ad2e086ef8141: function(arg0) {
+            const ret = arg0.limits;
+            return ret;
+        },
         __wbg_linkProgram_571a9ea00d38ff83: function(arg0, arg1) {
             arg0.linkProgram(arg1);
         },
         __wbg_linkProgram_acdc299c43d734a0: function(arg0, arg1) {
             arg0.linkProgram(arg1);
         },
-        __wbg_name_91a697e9ff1634bf: function(arg0, arg1) {
-            const ret = arg1.name;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg_new_2e41357094e99294: function() { return handleError(function () {
-            const ret = new AbortController();
+        __wbg_mapAsync_b0597127f5037286: function(arg0, arg1, arg2, arg3) {
+            const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
             return ret;
+        },
+        __wbg_matchMedia_8a4857f947f11f82: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.matchMedia(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         }, arguments); },
-        __wbg_new_5502aad30c185fc8: function(arg0, arg1) {
-            try {
-                var state0 = {a: arg0, b: arg1};
-                var cb0 = (arg0, arg1) => {
+        __wbg_matches_778d0873b064b1bf: function(arg0) {
+            const ret = arg0.matches;
+            return ret;
+        },
+        __wbg_maxBindGroupsPlusVertexBuffers_52369f089736ef9d: function(arg0) {
+            const ret = arg0.maxBindGroupsPlusVertexBuffers;
+            return ret;
+        },
+        __wbg_maxBindGroups_4e424afe6ce86ca2: function(arg0) {
+            const ret = arg0.maxBindGroups;
+            return ret;
+        },
+        __wbg_maxBindingsPerBindGroup_7d035da36821c44f: function(arg0) {
+            const ret = arg0.maxBindingsPerBindGroup;
+            return ret;
+        },
+        __wbg_maxBufferSize_423f4a084e32a195: function(arg0) {
+            const ret = arg0.maxBufferSize;
+            return ret;
+        },
+        __wbg_maxColorAttachmentBytesPerSample_c4cd9126f6d287c6: function(arg0) {
+            const ret = arg0.maxColorAttachmentBytesPerSample;
+            return ret;
+        },
+        __wbg_maxColorAttachments_d924670762b9e250: function(arg0) {
+            const ret = arg0.maxColorAttachments;
+            return ret;
+        },
+        __wbg_maxComputeInvocationsPerWorkgroup_707a3868f7cebb59: function(arg0) {
+            const ret = arg0.maxComputeInvocationsPerWorkgroup;
+            return ret;
+        },
+        __wbg_maxComputeWorkgroupSizeX_0a4d99463cbd6e5e: function(arg0) {
+            const ret = arg0.maxComputeWorkgroupSizeX;
+            return ret;
+        },
+        __wbg_maxComputeWorkgroupSizeY_85123ea0587f7558: function(arg0) {
+            const ret = arg0.maxComputeWorkgroupSizeY;
+            return ret;
+        },
+        __wbg_maxComputeWorkgroupSizeZ_a3186b4c5267d44f: function(arg0) {
+            const ret = arg0.maxComputeWorkgroupSizeZ;
+            return ret;
+        },
+        __wbg_maxComputeWorkgroupStorageSize_57b297355cfb6204: function(arg0) {
+            const ret = arg0.maxComputeWorkgroupStorageSize;
+            return ret;
+        },
+        __wbg_maxComputeWorkgroupsPerDimension_4158f95e673d54c4: function(arg0) {
+            const ret = arg0.maxComputeWorkgroupsPerDimension;
+            return ret;
+        },
+        __wbg_maxDynamicStorageBuffersPerPipelineLayout_226b0b70910aa16c: function(arg0) {
+            const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
+            return ret;
+        },
+        __wbg_maxDynamicUniformBuffersPerPipelineLayout_0e835fda711fc7e6: function(arg0) {
+            const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
+            return ret;
+        },
+        __wbg_maxInterStageShaderVariables_8c4a1d727e2aa35a: function(arg0) {
+            const ret = arg0.maxInterStageShaderVariables;
+            return ret;
+        },
+        __wbg_maxSampledTexturesPerShaderStage_6675f5e91d9a728a: function(arg0) {
+            const ret = arg0.maxSampledTexturesPerShaderStage;
+            return ret;
+        },
+        __wbg_maxSamplersPerShaderStage_1910fa38a6ed1e1f: function(arg0) {
+            const ret = arg0.maxSamplersPerShaderStage;
+            return ret;
+        },
+        __wbg_maxStorageBufferBindingSize_2e244bded070b18d: function(arg0) {
+            const ret = arg0.maxStorageBufferBindingSize;
+            return ret;
+        },
+        __wbg_maxStorageBuffersPerShaderStage_a285f3ebca51ca0d: function(arg0) {
+            const ret = arg0.maxStorageBuffersPerShaderStage;
+            return ret;
+        },
+        __wbg_maxStorageTexturesPerShaderStage_7aa946f0fc322a2b: function(arg0) {
+            const ret = arg0.maxStorageTexturesPerShaderStage;
+            return ret;
+        },
+        __wbg_maxTextureArrayLayers_0e699147ad00502d: function(arg0) {
+            const ret = arg0.maxTextureArrayLayers;
+            return ret;
+        },
+        __wbg_maxTextureDimension1D_aabf6add54decfe2: function(arg0) {
+            const ret = arg0.maxTextureDimension1D;
+            return ret;
+        },
+        __wbg_maxTextureDimension2D_dd598b27e9c0c1c4: function(arg0) {
+            const ret = arg0.maxTextureDimension2D;
+            return ret;
+        },
+        __wbg_maxTextureDimension3D_f944266c65dfd1a9: function(arg0) {
+            const ret = arg0.maxTextureDimension3D;
+            return ret;
+        },
+        __wbg_maxUniformBufferBindingSize_59fa6be7cfbeeb53: function(arg0) {
+            const ret = arg0.maxUniformBufferBindingSize;
+            return ret;
+        },
+        __wbg_maxUniformBuffersPerShaderStage_bee5f00a4d706c7f: function(arg0) {
+            const ret = arg0.maxUniformBuffersPerShaderStage;
+            return ret;
+        },
+        __wbg_maxVertexAttributes_5cf6392c4e9033fe: function(arg0) {
+            const ret = arg0.maxVertexAttributes;
+            return ret;
+        },
+        __wbg_maxVertexBufferArrayStride_548baa887375d865: function(arg0) {
+            const ret = arg0.maxVertexBufferArrayStride;
+            return ret;
+        },
+        __wbg_maxVertexBuffers_75d881156591f5da: function(arg0) {
+            const ret = arg0.maxVertexBuffers;
+            return ret;
+        },
+        __wbg_message_2aad50368e15e8f1: function(arg0, arg1) {
+            const ret = arg1.message;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_message_5f8387f0c32b90a7: function(arg0) {
+            const ret = arg0.message;
+            return ret;
+        },
+        __wbg_minStorageBufferOffsetAlignment_5ba9b77792bdadb3: function(arg0) {
+            const ret = arg0.minStorageBufferOffsetAlignment;
+            return ret;
+        },
+        __wbg_minUniformBufferOffsetAlignment_ab7d52a5293b22bd: function(arg0) {
+            const ret = arg0.minUniformBufferOffsetAlignment;
+            return ret;
+        },
+        __wbg_navigator_2156486643462a87: function(arg0) {
+            const ret = arg0.navigator;
+            return ret;
+        },
+        __wbg_navigator_c9bce48d4b578c9c: function(arg0) {
+            const ret = arg0.navigator;
+            return ret;
+        },
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
+            const ret = new Uint8Array(arg0);
+            return ret;
+        },
+        __wbg_new_2e41357094e99294: function() { return handleError(function () {
+            const ret = new AbortController();
+            return ret;
+        }, arguments); },
+        __wbg_new_5502aad30c185fc8: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return 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, state0.b, arg0, arg1);
+                        return wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined_______true_(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2305,18 +3155,60 @@ function __wbg_get_imports() {
             const ret = new Headers();
             return ret;
         }, arguments); },
+        __wbg_new_a217df4351db4b9b: function() { return handleError(function (arg0, arg1) {
+            const ret = new OffscreenCanvas(arg0 >>> 0, arg1 >>> 0);
+            return ret;
+        }, arguments); },
         __wbg_new_ee2291f50781bf1d: function() {
             const ret = new Array();
             return ret;
         },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_from_slice_f545fd22ddc142b8: function(arg0, arg1) {
+            const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_typed_689a3a281a8d4da6: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_typed_b01cb72a8af741a3: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined_______true_(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return ret;
+            } finally {
+                state0.a = 0;
+            }
+        },
         __wbg_new_with_byte_offset_70ba6193352e027b: function(arg0, arg1) {
             const ret = new Uint8Array(arg0, arg1 >>> 0);
             return ret;
         },
+        __wbg_new_with_byte_offset_and_length_2f5d7fc2a828b74d: function(arg0, arg1, arg2) {
+            const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+            return ret;
+        },
         __wbg_new_with_byte_offset_and_length_40c170286adc9005: function(arg0, arg1, arg2) {
             const ret = new Float32Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
+        __wbg_new_with_u8_array_sequence_and_options_fccc08fe93f4b8fd: function() { return handleError(function (arg0, arg1) {
+            const ret = new Blob(arg0, arg1);
+            return ret;
+        }, arguments); },
         __wbg_now_aa4ccb83129e9e55: function() {
             const ret = Date.now();
             return ret;
@@ -2329,10 +3221,26 @@ function __wbg_get_imports() {
             const ret = Array.of(arg0, arg1);
             return ret;
         },
+        __wbg_of_d5dbecdc59e02e34: function(arg0) {
+            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;
+        },
+        __wbg_ok_125878a7db256ecb: function(arg0) {
+            const ret = arg0.ok;
+            return ret;
+        },
+        __wbg_onSubmittedWorkDone_1190213cee1ecf7e: function(arg0) {
+            const ret = arg0.onSubmittedWorkDone();
+            return ret;
+        },
         __wbg_performance_d0d7b03fc649b694: function(arg0) {
             const ret = arg0.performance;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -2349,16 +3257,37 @@ function __wbg_get_imports() {
         __wbg_polygonOffset_8f922d9173d8849d: function(arg0, arg1, arg2) {
             arg0.polygonOffset(arg1, arg2);
         },
+        __wbg_popErrorScope_182b8e03671d81ef: function(arg0) {
+            const ret = arg0.popErrorScope();
+            return ret;
+        },
         __wbg_prototypesetcall_8b03c01e2c0f8066: function(arg0, arg1, arg2) {
             Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), arg2);
         },
         __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_pushErrorScope_fa7df784c43bdb51: function(arg0, arg1) {
+            arg0.pushErrorScope(__wbindgen_enum_GpuErrorFilter[arg1]);
+        },
         __wbg_push_2baf45db356cf468: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
         },
+        __wbg_queryCounterEXT_9016a6ffa350b4b2: function(arg0, arg1, arg2) {
+            arg0.queryCounterEXT(arg1, arg2 >>> 0);
+        },
+        __wbg_querySelectorAll_6aebfe3df1fb2014: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.querySelectorAll(getStringFromWasm0(arg1, arg2));
+            return ret;
+        }, arguments); },
+        __wbg_querySelector_ecbc2550705b235f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.querySelector(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
         __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
@@ -2366,6 +3295,13 @@ function __wbg_get_imports() {
         __wbg_queueMicrotask_a72f977e97f23c5f: function(arg0) {
             queueMicrotask(arg0);
         },
+        __wbg_queue_7b62c28143d44293: function(arg0) {
+            const ret = arg0.queue;
+            return ret;
+        },
+        __wbg_readBuffer_b5d9a34a2f3d20d5: function(arg0, arg1) {
+            arg0.readBuffer(arg1 >>> 0);
+        },
         __wbg_readPixels_31e44e70558ac590: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
         }, arguments); },
@@ -2375,68 +3311,679 @@ function __wbg_get_imports() {
         __wbg_readPixels_eb030cd9976eeca5: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
             arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
         }, arguments); },
+        __wbg_renderbufferStorageMultisample_ed16f3ef446e3bc7: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.renderbufferStorageMultisample(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
+        },
         __wbg_renderbufferStorage_52b131bbf3112b3a: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.renderbufferStorage(arg1 >>> 0, arg2 >>> 0, arg3, arg4);
         },
         __wbg_renderbufferStorage_bca487b0dea425b8: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.renderbufferStorage(arg1 >>> 0, arg2 >>> 0, arg3, arg4);
         },
+        __wbg_requestAdapter_a539af006419f2e9: function(arg0, arg1) {
+            const ret = arg0.requestAdapter(arg1);
+            return ret;
+        },
+        __wbg_requestDevice_5cb8a582e55d08cb: function(arg0, arg1) {
+            const ret = arg0.requestDevice(arg1);
+            return ret;
+        },
+        __wbg_resolveQuerySet_770f23fabac49845: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.resolveQuerySet(arg1, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
+        },
         __wbg_resolve_0076e10020304ede: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
         },
+        __wbg_samplerParameterf_2d62cb907392e2d6: function(arg0, arg1, arg2, arg3) {
+            arg0.samplerParameterf(arg1, arg2 >>> 0, arg3);
+        },
+        __wbg_samplerParameteri_a5615e67ed0b654b: function(arg0, arg1, arg2, arg3) {
+            arg0.samplerParameteri(arg1, arg2 >>> 0, arg3);
+        },
         __wbg_scissor_12ddc324094acd50: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.scissor(arg1, arg2, arg3, arg4);
         },
         __wbg_scissor_a9468482697c2bdb: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.scissor(arg1, arg2, arg3, arg4);
         },
+        __wbg_setBindGroup_11bdbb60cc8b54b9: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
+        }, arguments); },
+        __wbg_setBindGroup_418c3e0eb6943ce0: function(arg0, arg1, arg2) {
+            arg0.setBindGroup(arg1 >>> 0, arg2);
+        },
+        __wbg_setIndexBuffer_01327df91742b73e: function(arg0, arg1, arg2, arg3) {
+            arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3);
+        },
+        __wbg_setIndexBuffer_241097e303986c14: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
+        },
+        __wbg_setPipeline_b6f981027e02cd16: function(arg0, arg1) {
+            arg0.setPipeline(arg1);
+        },
+        __wbg_setScissorRect_889235eeb784732b: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.setScissorRect(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
+        },
+        __wbg_setStencilReference_48705a9a2cceae02: function(arg0, arg1) {
+            arg0.setStencilReference(arg1 >>> 0);
+        },
         __wbg_setTimeout_db7bbc18a17e152a: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.setTimeout(arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_setVertexBuffer_6db3b60e99280744: function(arg0, arg1, arg2, arg3) {
+            arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3);
+        },
+        __wbg_setVertexBuffer_cbf4ca1627c02f4c: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
+        },
         __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
         }, arguments); },
+        __wbg_set_34d08fd992d43d61: function(arg0, arg1, arg2) {
+            arg0.set(arg1, arg2 >>> 0);
+        },
+        __wbg_set_a_82818effc94f6256: function(arg0, arg1) {
+            arg0.a = arg1;
+        },
+        __wbg_set_access_a099cfbbeec9b96f: function(arg0, arg1) {
+            arg0.access = __wbindgen_enum_GpuStorageTextureAccess[arg1];
+        },
+        __wbg_set_address_mode_u_a68737cf5d288f95: function(arg0, arg1) {
+            arg0.addressModeU = __wbindgen_enum_GpuAddressMode[arg1];
+        },
+        __wbg_set_address_mode_v_b1c3c45933f540d1: function(arg0, arg1) {
+            arg0.addressModeV = __wbindgen_enum_GpuAddressMode[arg1];
+        },
+        __wbg_set_address_mode_w_889c31cf7022c764: function(arg0, arg1) {
+            arg0.addressModeW = __wbindgen_enum_GpuAddressMode[arg1];
+        },
         __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;
+        __wbg_set_alpha_106f21a936a85eba: function(arg0, arg1) {
+            arg0.alpha = arg1;
+        },
+        __wbg_set_alpha_mode_5544568dbac50280: function(arg0, arg1) {
+            arg0.alphaMode = __wbindgen_enum_GpuCanvasAlphaMode[arg1];
+        },
+        __wbg_set_alpha_to_coverage_enabled_3372ce329447b8f1: function(arg0, arg1) {
+            arg0.alphaToCoverageEnabled = arg1 !== 0;
+        },
+        __wbg_set_array_layer_count_22afa0a979e4ad55: function(arg0, arg1) {
+            arg0.arrayLayerCount = arg1 >>> 0;
         },
-        __wbg_set_antialias_1f699e96763e8a35: function(arg0, arg1) {
-            arg0.antialias = arg1 !== 0;
+        __wbg_set_array_stride_f64_6816040e5e7598c3: function(arg0, arg1) {
+            arg0.arrayStride = arg1;
+        },
+        __wbg_set_aspect_9de5253d4c460895: function(arg0, arg1) {
+            arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
+        },
+        __wbg_set_aspect_a48d046965270281: function(arg0, arg1) {
+            arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
+        },
+        __wbg_set_aspect_b1a9909bf315433f: function(arg0, arg1) {
+            arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
+        },
+        __wbg_set_attributes_9e38cb1dde387a5b: function(arg0, arg1, arg2) {
+            arg0.attributes = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_b_a3297ee7e7cac3a8: function(arg0, arg1) {
+            arg0.b = arg1;
+        },
+        __wbg_set_base_array_layer_2435ba92c80346ae: function(arg0, arg1) {
+            arg0.baseArrayLayer = arg1 >>> 0;
+        },
+        __wbg_set_base_mip_level_8b6093e875e7c65d: function(arg0, arg1) {
+            arg0.baseMipLevel = arg1 >>> 0;
+        },
+        __wbg_set_beginning_of_pass_write_index_e552c5e8b8bbf52f: function(arg0, arg1) {
+            arg0.beginningOfPassWriteIndex = arg1 >>> 0;
+        },
+        __wbg_set_bind_group_layouts_458c44ba55100b82: function(arg0, arg1, arg2) {
+            arg0.bindGroupLayouts = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_binding_81b3fac7f7acaf8d: function(arg0, arg1) {
+            arg0.binding = arg1 >>> 0;
+        },
+        __wbg_set_binding_b6cee57f35ac5190: function(arg0, arg1) {
+            arg0.binding = arg1 >>> 0;
+        },
+        __wbg_set_blend_1a801617945f7945: function(arg0, arg1) {
+            arg0.blend = arg1;
+        },
+        __wbg_set_buffer_1548ae88a9188037: function(arg0, arg1) {
+            arg0.buffer = arg1;
+        },
+        __wbg_set_buffer_8d0ac64ad20dfc84: function(arg0, arg1) {
+            arg0.buffer = arg1;
+        },
+        __wbg_set_buffer_910a40a90f97cfca: function(arg0, arg1) {
+            arg0.buffer = arg1;
+        },
+        __wbg_set_buffers_5d0e0c50791f710e: function(arg0, arg1, arg2) {
+            arg0.buffers = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_bytes_per_row_1e824a5502b54b3d: function(arg0, arg1) {
+            arg0.bytesPerRow = arg1 >>> 0;
+        },
+        __wbg_set_bytes_per_row_c28583f0063160f1: function(arg0, arg1) {
+            arg0.bytesPerRow = arg1 >>> 0;
         },
         __wbg_set_cache_7507c4cc5938ccc7: function(arg0, arg1) {
             arg0.cache = __wbindgen_enum_RequestCache[arg1];
         },
+        __wbg_set_clear_value_gpu_color_dict_a9f763e8372ac1de: function(arg0, arg1) {
+            arg0.clearValue = arg1;
+        },
+        __wbg_set_code_5d5b0b9e2fd0dca7: function(arg0, arg1, arg2) {
+            arg0.code = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_color_8ecace4011f47d2e: function(arg0, arg1) {
+            arg0.color = arg1;
+        },
+        __wbg_set_color_attachments_622fe2d5997fda7a: function(arg0, arg1, arg2) {
+            arg0.colorAttachments = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
         __wbg_set_color_space_conversion_f27e9d866a683b4b: function(arg0, arg1) {
             arg0.colorSpaceConversion = __wbindgen_enum_ColorSpaceConversion[arg1];
         },
-        __wbg_set_depth_8b49de49803d4e60: function(arg0, arg1) {
-            arg0.depth = arg1 !== 0;
+        __wbg_set_compare_080c9e492ff36990: function(arg0, arg1) {
+            arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
+        },
+        __wbg_set_compare_817cf3695599eaa6: function(arg0, arg1) {
+            arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
+        },
+        __wbg_set_count_8ff0c9474e39a849: function(arg0, arg1) {
+            arg0.count = arg1 >>> 0;
+        },
+        __wbg_set_cull_mode_85d2b4ab0ce3a564: function(arg0, arg1) {
+            arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
+        },
+        __wbg_set_depth_bias_95abf479cae3f3cd: function(arg0, arg1) {
+            arg0.depthBias = arg1;
+        },
+        __wbg_set_depth_bias_clamp_ba3d0b8348151350: function(arg0, arg1) {
+            arg0.depthBiasClamp = arg1;
+        },
+        __wbg_set_depth_bias_slope_scale_6b2584d93f5b9cd2: function(arg0, arg1) {
+            arg0.depthBiasSlopeScale = arg1;
+        },
+        __wbg_set_depth_clear_value_e30a4c754c6b3b26: function(arg0, arg1) {
+            arg0.depthClearValue = arg1;
+        },
+        __wbg_set_depth_compare_a90de4e3714397ab: function(arg0, arg1) {
+            arg0.depthCompare = __wbindgen_enum_GpuCompareFunction[arg1];
+        },
+        __wbg_set_depth_fail_op_b5c64541d1b6b482: function(arg0, arg1) {
+            arg0.depthFailOp = __wbindgen_enum_GpuStencilOperation[arg1];
+        },
+        __wbg_set_depth_load_op_932888016d762d3e: function(arg0, arg1) {
+            arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
+        },
+        __wbg_set_depth_or_array_layers_e2f074a0284e4806: function(arg0, arg1) {
+            arg0.depthOrArrayLayers = arg1 >>> 0;
+        },
+        __wbg_set_depth_read_only_be790175a1c2db9a: function(arg0, arg1) {
+            arg0.depthReadOnly = arg1 !== 0;
+        },
+        __wbg_set_depth_stencil_attachment_54a8922f5fbe08bf: function(arg0, arg1) {
+            arg0.depthStencilAttachment = arg1;
+        },
+        __wbg_set_depth_stencil_b7cffc59ad4da529: function(arg0, arg1) {
+            arg0.depthStencil = arg1;
+        },
+        __wbg_set_depth_store_op_9054814f164ab55d: function(arg0, arg1) {
+            arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
+        },
+        __wbg_set_depth_write_enabled_31a821ee1fb3b0b3: function(arg0, arg1) {
+            arg0.depthWriteEnabled = arg1 !== 0;
+        },
+        __wbg_set_device_210484a77b675c9c: function(arg0, arg1) {
+            arg0.device = arg1;
+        },
+        __wbg_set_dimension_3da9d03131a9f446: function(arg0, arg1) {
+            arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
+        },
+        __wbg_set_dimension_56332450afa3e0c0: function(arg0, arg1) {
+            arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
+        },
+        __wbg_set_dst_factor_865ba9aaf187890c: function(arg0, arg1) {
+            arg0.dstFactor = __wbindgen_enum_GpuBlendFactor[arg1];
+        },
+        __wbg_set_end_of_pass_write_index_8f164f9e60d4ad16: function(arg0, arg1) {
+            arg0.endOfPassWriteIndex = arg1 >>> 0;
+        },
+        __wbg_set_entries_6f866302103b81e9: function(arg0, arg1, arg2) {
+            arg0.entries = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_entries_f26b77ab9548e906: function(arg0, arg1, arg2) {
+            arg0.entries = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_entry_point_71cef95c137b5774: function(arg0, arg1, arg2) {
+            arg0.entryPoint = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_entry_point_b70f98f5025a114d: function(arg0, arg1, arg2) {
+            arg0.entryPoint = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_external_texture_7f966c604c4f8098: function(arg0, arg1) {
+            arg0.externalTexture = arg1;
+        },
+        __wbg_set_fail_op_d59d0187e4111dfe: function(arg0, arg1) {
+            arg0.failOp = __wbindgen_enum_GpuStencilOperation[arg1];
+        },
+        __wbg_set_flip_y_5a9a7c3fd5a2314e: function(arg0, arg1) {
+            arg0.flipY = arg1 !== 0;
+        },
+        __wbg_set_format_23f7f32549751d43: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+        },
+        __wbg_set_format_283dca56552f07a3: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+        },
+        __wbg_set_format_5080a858117ad2c1: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuVertexFormat[arg1];
+        },
+        __wbg_set_format_66735b94bd868ba2: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+        },
+        __wbg_set_format_7f2bdbfb101b1ae1: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+        },
+        __wbg_set_format_92732ea75d3b79f5: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+        },
+        __wbg_set_format_f009e603f7d4c28e: function(arg0, arg1) {
+            arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
+        },
+        __wbg_set_fragment_d2b0ec97d7cf8d47: function(arg0, arg1) {
+            arg0.fragment = arg1;
+        },
+        __wbg_set_front_face_d3f8a2e07e7b25dd: function(arg0, arg1) {
+            arg0.frontFace = __wbindgen_enum_GpuFrontFace[arg1];
+        },
+        __wbg_set_g_b527ee8a9bed553d: function(arg0, arg1) {
+            arg0.g = arg1;
+        },
+        __wbg_set_has_dynamic_offset_0c72ffa900c5a269: function(arg0, arg1) {
+            arg0.hasDynamicOffset = 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];
+        __wbg_set_height_c9789c1c77eaedff: function(arg0, arg1) {
+            arg0.height = arg1 >>> 0;
+        },
+        __wbg_set_height_f6619158e5735877: function(arg0, arg1) {
+            arg0.height = arg1 >>> 0;
+        },
+        __wbg_set_height_fde391767df1ce27: function(arg0, arg1) {
+            arg0.height = arg1 >>> 0;
+        },
+        __wbg_set_label_17202740051e9722: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_2fefb39c0e0dbbe8: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_3cb2322e6f6db14c: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_3f2ccaafef5ff7c9: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_612add98a4398f92: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_70a09ee68d6b1b26: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_92cd3811e96b487c: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_9c2a186152427ee0: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_c3eaf136aa464cba: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_c7987704d29f284b: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_cfe64bca8945ee30: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_e02179cf97e95763: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_label_ee172cd5f6a96961: function(arg0, arg1, arg2) {
+            arg0.label = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_layout_454e3a091b390cd4: function(arg0, arg1) {
+            arg0.layout = arg1;
+        },
+        __wbg_set_layout_75dc1ca3f2421cff: function(arg0, arg1) {
+            arg0.layout = arg1;
+        },
+        __wbg_set_layout_gpu_auto_layout_mode_06a2b95af1043098: function(arg0, arg1) {
+            arg0.layout = __wbindgen_enum_GpuAutoLayoutMode[arg1];
+        },
+        __wbg_set_load_op_c56b1269acc2d51f: function(arg0, arg1) {
+            arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
+        },
+        __wbg_set_lod_max_clamp_db24179f67f3aa31: function(arg0, arg1) {
+            arg0.lodMaxClamp = arg1;
+        },
+        __wbg_set_lod_min_clamp_2bbce566e9fefa04: function(arg0, arg1) {
+            arg0.lodMinClamp = arg1;
+        },
+        __wbg_set_mag_filter_db8e6b42d4f8846d: function(arg0, arg1) {
+            arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
+        },
+        __wbg_set_mapped_at_creation_3f320fef6761b02c: function(arg0, arg1) {
+            arg0.mappedAtCreation = arg1 !== 0;
+        },
+        __wbg_set_mask_c1079e551ec360dc: function(arg0, arg1) {
+            arg0.mask = arg1 >>> 0;
+        },
+        __wbg_set_max_anisotropy_84749fdcec362dc4: function(arg0, arg1) {
+            arg0.maxAnisotropy = arg1;
+        },
+        __wbg_set_min_binding_size_f64_897e3cd4496ddec9: function(arg0, arg1) {
+            arg0.minBindingSize = arg1;
+        },
+        __wbg_set_min_filter_d435bbfc5a637757: function(arg0, arg1) {
+            arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
+        },
+        __wbg_set_mip_level_03ed7bbd0ded367f: function(arg0, arg1) {
+            arg0.mipLevel = arg1 >>> 0;
+        },
+        __wbg_set_mip_level_count_047936c630acee7b: function(arg0, arg1) {
+            arg0.mipLevelCount = arg1 >>> 0;
+        },
+        __wbg_set_mip_level_count_44bc46a1ae6f6daa: function(arg0, arg1) {
+            arg0.mipLevelCount = arg1 >>> 0;
+        },
+        __wbg_set_mip_level_f3745730372683d5: function(arg0, arg1) {
+            arg0.mipLevel = arg1 >>> 0;
+        },
+        __wbg_set_mipmap_filter_62fb49a84b0747ff: function(arg0, arg1) {
+            arg0.mipmapFilter = __wbindgen_enum_GpuMipmapFilterMode[arg1];
+        },
+        __wbg_set_mode_7edfbc344ef9c650: function(arg0, arg1) {
+            arg0.mode = __wbindgen_enum_GpuCanvasToneMappingMode[arg1];
+        },
+        __wbg_set_module_392eeaa269f203b0: function(arg0, arg1) {
+            arg0.module = arg1;
+        },
+        __wbg_set_module_715d37652c4998ec: function(arg0, arg1) {
+            arg0.module = arg1;
+        },
+        __wbg_set_multisample_ff72a7a5456cbeb7: function(arg0, arg1) {
+            arg0.multisample = arg1;
+        },
+        __wbg_set_multisampled_039f032dc4b67367: function(arg0, arg1) {
+            arg0.multisampled = arg1 !== 0;
+        },
+        __wbg_set_offset_f64_127e8a0aa5c5485a: function(arg0, arg1) {
+            arg0.offset = arg1;
+        },
+        __wbg_set_offset_f64_457756429ede426d: function(arg0, arg1) {
+            arg0.offset = arg1;
+        },
+        __wbg_set_offset_f64_a903425d5a8e5815: function(arg0, arg1) {
+            arg0.offset = arg1;
+        },
+        __wbg_set_offset_f64_d1d115dd438165b5: function(arg0, arg1) {
+            arg0.offset = arg1;
+        },
+        __wbg_set_onuncapturederror_bb813f1102da2296: function(arg0, arg1) {
+            arg0.onuncapturederror = arg1;
+        },
+        __wbg_set_operation_00a77386523b88f9: function(arg0, arg1) {
+            arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
+        },
+        __wbg_set_origin_gpu_origin_2d_dict_8156da81552cd590: function(arg0, arg1) {
+            arg0.origin = arg1;
+        },
+        __wbg_set_origin_gpu_origin_3d_dict_0619d4860adb4eb6: function(arg0, arg1) {
+            arg0.origin = arg1;
+        },
+        __wbg_set_origin_gpu_origin_3d_dict_abd0dec737979786: function(arg0, arg1) {
+            arg0.origin = arg1;
+        },
+        __wbg_set_pass_op_3cf10feb3d76ab97: function(arg0, arg1) {
+            arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
+        },
+        __wbg_set_power_preference_b42d00a8facfbade: function(arg0, arg1) {
+            arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
+        },
+        __wbg_set_premultiplied_alpha_6d23532454ce9a12: function(arg0, arg1) {
+            arg0.premultipliedAlpha = arg1 !== 0;
         },
         __wbg_set_premultiply_alpha_45a4cf9a1e87bfbf: function(arg0, arg1) {
             arg0.premultiplyAlpha = __wbindgen_enum_PremultiplyAlpha[arg1];
         },
+        __wbg_set_primitive_e796cf76f0ff89f3: function(arg0, arg1) {
+            arg0.primitive = arg1;
+        },
+        __wbg_set_query_set_f030702f1b69199f: function(arg0, arg1) {
+            arg0.querySet = arg1;
+        },
+        __wbg_set_r_6ece4d74af63364f: function(arg0, arg1) {
+            arg0.r = arg1;
+        },
+        __wbg_set_required_features_bbab71414c45e621: function(arg0, arg1, arg2) {
+            arg0.requiredFeatures = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_required_limits_837f62d865e7cfac: function(arg0, arg1) {
+            arg0.requiredLimits = arg1;
+        },
         __wbg_set_resize_height_274433c2f249624d: function(arg0, arg1) {
             arg0.resizeHeight = arg1 >>> 0;
         },
         __wbg_set_resize_width_6f06543b29d1ca48: function(arg0, arg1) {
             arg0.resizeWidth = arg1 >>> 0;
         },
+        __wbg_set_resolve_target_gpu_texture_view_e4c1e3bbb8c27d87: function(arg0, arg1) {
+            arg0.resolveTarget = arg1;
+        },
+        __wbg_set_resource_8fd8658b30d86ecf: function(arg0, arg1) {
+            arg0.resource = arg1;
+        },
+        __wbg_set_resource_gpu_buffer_binding_33099b25da65b610: function(arg0, arg1) {
+            arg0.resource = arg1;
+        },
+        __wbg_set_resource_gpu_texture_view_4cffe7bc7c8e5cbe: function(arg0, arg1) {
+            arg0.resource = arg1;
+        },
+        __wbg_set_rows_per_image_c6d50d227e634379: function(arg0, arg1) {
+            arg0.rowsPerImage = arg1 >>> 0;
+        },
+        __wbg_set_rows_per_image_deb456502f23c260: function(arg0, arg1) {
+            arg0.rowsPerImage = arg1 >>> 0;
+        },
+        __wbg_set_sample_count_481c255a12054e1d: function(arg0, arg1) {
+            arg0.sampleCount = arg1 >>> 0;
+        },
+        __wbg_set_sample_type_ebc5fcd029513bda: function(arg0, arg1) {
+            arg0.sampleType = __wbindgen_enum_GpuTextureSampleType[arg1];
+        },
+        __wbg_set_sampler_89cb4a7efcfc6005: function(arg0, arg1) {
+            arg0.sampler = arg1;
+        },
+        __wbg_set_shader_location_3fb9f6a012eba494: function(arg0, arg1) {
+            arg0.shaderLocation = arg1 >>> 0;
+        },
         __wbg_set_signal_2dbd377604627f26: function(arg0, arg1) {
             arg0.signal = arg1;
         },
-        __wbg_set_stencil_edc32d9477c7c107: function(arg0, arg1) {
-            arg0.stencil = arg1 !== 0;
+        __wbg_set_size_f64_2f591b0654540477: function(arg0, arg1) {
+            arg0.size = arg1;
+        },
+        __wbg_set_size_f64_e844c985b8f95261: function(arg0, arg1) {
+            arg0.size = arg1;
+        },
+        __wbg_set_size_gpu_extent_3d_dict_adf57388ab1d4f18: function(arg0, arg1) {
+            arg0.size = arg1;
+        },
+        __wbg_set_source_211aa06496d82b73: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_source_html_canvas_element_5577621adc0f8ff6: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_source_html_image_element_23fa06e99ca07cc0: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_source_html_video_element_e57b5cacb7b02736: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_source_image_data_c80600573a809775: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_source_offscreen_canvas_7d49271754887b4e: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_source_video_frame_e4faebda27c393e4: function(arg0, arg1) {
+            arg0.source = arg1;
+        },
+        __wbg_set_src_factor_6f2c9ec8e4d3d979: function(arg0, arg1) {
+            arg0.srcFactor = __wbindgen_enum_GpuBlendFactor[arg1];
+        },
+        __wbg_set_stencil_back_c54d0443b8b6a957: function(arg0, arg1) {
+            arg0.stencilBack = arg1;
+        },
+        __wbg_set_stencil_clear_value_a321b0e045bfd8c2: function(arg0, arg1) {
+            arg0.stencilClearValue = arg1 >>> 0;
+        },
+        __wbg_set_stencil_front_3ff3f8385852efff: function(arg0, arg1) {
+            arg0.stencilFront = arg1;
+        },
+        __wbg_set_stencil_load_op_37d20deccb26a0f1: function(arg0, arg1) {
+            arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
+        },
+        __wbg_set_stencil_read_mask_021ef4271b24352c: function(arg0, arg1) {
+            arg0.stencilReadMask = arg1 >>> 0;
+        },
+        __wbg_set_stencil_read_only_75fe66a2356d6e92: function(arg0, arg1) {
+            arg0.stencilReadOnly = arg1 !== 0;
+        },
+        __wbg_set_stencil_store_op_501f91638dd386e6: function(arg0, arg1) {
+            arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
+        },
+        __wbg_set_stencil_write_mask_ec1c12237e094bdd: function(arg0, arg1) {
+            arg0.stencilWriteMask = arg1 >>> 0;
+        },
+        __wbg_set_step_mode_3cbbdeba1e5dfd62: function(arg0, arg1) {
+            arg0.stepMode = __wbindgen_enum_GpuVertexStepMode[arg1];
+        },
+        __wbg_set_storage_texture_786aea7c5773b6c1: function(arg0, arg1) {
+            arg0.storageTexture = arg1;
+        },
+        __wbg_set_store_op_678f33376d741711: function(arg0, arg1) {
+            arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
+        },
+        __wbg_set_strip_index_format_70313df755145d5e: function(arg0, arg1) {
+            arg0.stripIndexFormat = __wbindgen_enum_GpuIndexFormat[arg1];
+        },
+        __wbg_set_targets_674b33931e512fb1: function(arg0, arg1, arg2) {
+            arg0.targets = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_texture_4e0ee4c98ac25b81: function(arg0, arg1) {
+            arg0.texture = arg1;
+        },
+        __wbg_set_texture_95f2bfdf7767e76f: function(arg0, arg1) {
+            arg0.texture = arg1;
+        },
+        __wbg_set_texture_a33be3fe02ac6264: function(arg0, arg1) {
+            arg0.texture = arg1;
+        },
+        __wbg_set_timestamp_writes_de6a09f299b71b76: function(arg0, arg1) {
+            arg0.timestampWrites = arg1;
+        },
+        __wbg_set_tone_mapping_320c1aad31db2e7f: function(arg0, arg1) {
+            arg0.toneMapping = arg1;
+        },
+        __wbg_set_topology_b92cfe523bd9653b: function(arg0, arg1) {
+            arg0.topology = __wbindgen_enum_GpuPrimitiveTopology[arg1];
+        },
+        __wbg_set_type_43e0092f16775979: function(arg0, arg1) {
+            arg0.type = __wbindgen_enum_GpuSamplerBindingType[arg1];
+        },
+        __wbg_set_type_79cec55caf4cdb6d: function(arg0, arg1) {
+            arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
+        },
+        __wbg_set_type_dcf75b2afa60c694: function(arg0, arg1, arg2) {
+            arg0.type = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_unclipped_depth_32b7caf29fa5633d: function(arg0, arg1) {
+            arg0.unclippedDepth = arg1 !== 0;
+        },
+        __wbg_set_usage_1ee33d98267e787d: function(arg0, arg1) {
+            arg0.usage = arg1 >>> 0;
+        },
+        __wbg_set_usage_2365e2704b1fdb10: function(arg0, arg1) {
+            arg0.usage = arg1 >>> 0;
+        },
+        __wbg_set_usage_d53ee6f0c7aedbfa: function(arg0, arg1) {
+            arg0.usage = arg1 >>> 0;
+        },
+        __wbg_set_usage_f3e34822998d2147: function(arg0, arg1) {
+            arg0.usage = arg1 >>> 0;
+        },
+        __wbg_set_vertex_77ed7a1229239b5a: function(arg0, arg1) {
+            arg0.vertex = arg1;
+        },
+        __wbg_set_view_dimension_893e2d16561e56e8: function(arg0, arg1) {
+            arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
+        },
+        __wbg_set_view_dimension_f2c5fe4bf927c3fe: function(arg0, arg1) {
+            arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
+        },
+        __wbg_set_view_formats_427069064d8b7139: function(arg0, arg1, arg2) {
+            arg0.viewFormats = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_view_formats_9c2f01a6f3b365c7: function(arg0, arg1, arg2) {
+            arg0.viewFormats = getArrayJsValueViewFromWasm0(arg1, arg2);
+        },
+        __wbg_set_view_gpu_texture_view_35f4655788535c4d: function(arg0, arg1) {
+            arg0.view = arg1;
+        },
+        __wbg_set_view_gpu_texture_view_a532c825c52042c0: function(arg0, arg1) {
+            arg0.view = arg1;
+        },
+        __wbg_set_visibility_d8a6821789538c25: function(arg0, arg1) {
+            arg0.visibility = arg1 >>> 0;
+        },
+        __wbg_set_width_0ca908d167690992: function(arg0, arg1) {
+            arg0.width = arg1 >>> 0;
+        },
+        __wbg_set_width_b0e1267db4b196b5: function(arg0, arg1) {
+            arg0.width = arg1 >>> 0;
+        },
+        __wbg_set_width_b20525f5f4df4eb8: function(arg0, arg1) {
+            arg0.width = arg1 >>> 0;
+        },
+        __wbg_set_write_mask_42d89f182ade6b2d: function(arg0, arg1) {
+            arg0.writeMask = arg1 >>> 0;
+        },
+        __wbg_set_x_58965df5af1ad27d: function(arg0, arg1) {
+            arg0.x = arg1 >>> 0;
+        },
+        __wbg_set_x_f470b03dd54724cd: function(arg0, arg1) {
+            arg0.x = arg1 >>> 0;
+        },
+        __wbg_set_y_4c44eb40ebca5bfc: function(arg0, arg1) {
+            arg0.y = arg1 >>> 0;
+        },
+        __wbg_set_y_b79cba22b145de99: function(arg0, arg1) {
+            arg0.y = arg1 >>> 0;
+        },
+        __wbg_set_z_2e6820ef0f5821ed: function(arg0, arg1) {
+            arg0.z = arg1 >>> 0;
         },
         __wbg_shaderSource_06379dac249994dd: function(arg0, arg1, arg2, arg3) {
             arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
@@ -2448,10 +3995,6 @@ function __wbg_get_imports() {
             const ret = arg0.signal;
             return ret;
         },
-        __wbg_size_74c48d7329291685: function(arg0) {
-            const ret = arg0.size;
-            return ret;
-        },
         __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -2472,11 +4015,17 @@ function __wbg_get_imports() {
             const ret = arg0.status;
             return ret;
         },
-        __wbg_stencilFunc_aa3cd8856be514c4: function(arg0, arg1, arg2, arg3) {
-            arg0.stencilFunc(arg1 >>> 0, arg2, arg3 >>> 0);
+        __wbg_stencilFuncSeparate_3f31dcd12a0d4785: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.stencilFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3, arg4 >>> 0);
+        },
+        __wbg_stencilFuncSeparate_f168b66c597aa85f: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.stencilFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3, arg4 >>> 0);
+        },
+        __wbg_stencilMaskSeparate_b30c097ea6b98504: function(arg0, arg1, arg2) {
+            arg0.stencilMaskSeparate(arg1 >>> 0, arg2 >>> 0);
         },
-        __wbg_stencilFunc_bab7e0b7c443f093: function(arg0, arg1, arg2, arg3) {
-            arg0.stencilFunc(arg1 >>> 0, arg2, arg3 >>> 0);
+        __wbg_stencilMaskSeparate_ff739f8711e9fd42: function(arg0, arg1, arg2) {
+            arg0.stencilMaskSeparate(arg1 >>> 0, arg2 >>> 0);
         },
         __wbg_stencilMask_9e18cc018897c747: function(arg0, arg1) {
             arg0.stencilMask(arg1 >>> 0);
@@ -2490,11 +4039,20 @@ function __wbg_get_imports() {
         __wbg_stencilOpSeparate_c5af5f5dbd237bea: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.stencilOpSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
         },
-        __wbg_stencilOp_12274af665ab8a00: 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_subgroupMaxSize_b43be0aa16182403: function(arg0) {
+            const ret = arg0.subgroupMaxSize;
+            return ret;
+        },
+        __wbg_subgroupMinSize_03feb6ee0cda6775: function(arg0) {
+            const ret = arg0.subgroupMinSize;
+            return ret;
         },
-        __wbg_stencilOp_2697194654fee819: function(arg0, arg1, arg2, arg3) {
-            arg0.stencilOp(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0);
+        __wbg_submit_077c85cc28e36892: function(arg0, arg1, arg2) {
+            arg0.submit(getArrayJsValueViewFromWasm0(arg1, arg2));
         },
         __wbg_texImage2D_82bf2b4c8aa9a1db: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
@@ -2505,6 +4063,12 @@ function __wbg_get_imports() {
         __wbg_texImage2D_ca3d0fe24620ec85: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
         }, arguments); },
+        __wbg_texImage3D_29a847f33877ed12: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+            arg0.texImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8 >>> 0, arg9 >>> 0, arg10);
+        }, arguments); },
+        __wbg_texImage3D_78fb39719c620063: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+            arg0.texImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8 >>> 0, arg9 >>> 0, arg10);
+        }, arguments); },
         __wbg_texParameteri_647fdb1426809cb5: function(arg0, arg1, arg2, arg3) {
             arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
         },
@@ -2517,21 +4081,48 @@ function __wbg_get_imports() {
         __wbg_texStorage3D_74b701c2b176380c: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             arg0.texStorage3D(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5, arg6);
         },
+        __wbg_texSubImage2D_07337d0974e99c39: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+        }, arguments); },
+        __wbg_texSubImage2D_196472d4111ce5b6: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+        }, arguments); },
+        __wbg_texSubImage2D_24cf5097ebaa84cc: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+        }, arguments); },
         __wbg_texSubImage2D_31a0c2797aa04f32: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
         }, arguments); },
         __wbg_texSubImage2D_5e90c7a719d40256: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
         }, arguments); },
+        __wbg_texSubImage2D_64e36398b8f046ac: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+        }, arguments); },
         __wbg_texSubImage2D_bb322aae90f7657f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
             arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
         }, arguments); },
+        __wbg_texSubImage2D_d7bffff06a3b8315: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
+        }, arguments); },
+        __wbg_texSubImage3D_001f2e62ed945b72: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+            arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
+        }, arguments); },
         __wbg_texSubImage3D_5143d5af7e182ddc: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
         }, arguments); },
+        __wbg_texSubImage3D_53c6014e2d129891: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+            arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
+        }, arguments); },
         __wbg_texSubImage3D_5d773fc7a8cd4d08: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
         }, arguments); },
+        __wbg_texSubImage3D_adb96e37e6949ec9: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+            arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
+        }, arguments); },
+        __wbg_texSubImage3D_d4e74595e01f7f71: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
+            arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
+        }, arguments); },
         __wbg_texSubImage3D_e0d113b7047a5130: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
             arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
         }, arguments); },
@@ -2543,9 +4134,8 @@ function __wbg_get_imports() {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_type_ff6f7b321fe8478b: function(arg0) {
-            const ret = arg0.type;
-            return ret;
+        __wbg_unconfigure_835307f58dc68d80: function(arg0) {
+            arg0.unconfigure();
         },
         __wbg_uniform1f_9cfecfaeb8cf43c1: function(arg0, arg1, arg2) {
             arg0.uniform1f(arg1, arg2);
@@ -2553,36 +4143,15 @@ function __wbg_get_imports() {
         __wbg_uniform1f_b5856e35a43b65a1: function(arg0, arg1, arg2) {
             arg0.uniform1f(arg1, arg2);
         },
-        __wbg_uniform1fv_1bf537fc926ef8b9: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform1fv(arg1, getArrayF32FromWasm0(arg2, arg3));
-        },
-        __wbg_uniform1fv_1cc1d09bc13b03bf: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform1fv(arg1, getArrayF32FromWasm0(arg2, arg3));
-        },
         __wbg_uniform1i_531b98c4a7177366: function(arg0, arg1, arg2) {
             arg0.uniform1i(arg1, arg2);
         },
         __wbg_uniform1i_fc2dc8cadc49d8ec: function(arg0, arg1, arg2) {
             arg0.uniform1i(arg1, arg2);
         },
-        __wbg_uniform1iv_4b8cbceccddfaa62: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform1iv(arg1, getArrayI32FromWasm0(arg2, arg3));
-        },
-        __wbg_uniform1iv_8fc880ae80c77c74: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform1iv(arg1, getArrayI32FromWasm0(arg2, arg3));
-        },
         __wbg_uniform1ui_353c67ec681b540c: function(arg0, arg1, arg2) {
             arg0.uniform1ui(arg1, arg2 >>> 0);
         },
-        __wbg_uniform1uiv_ad5e946730aacbec: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform1uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
-        },
-        __wbg_uniform2f_131da2d4bf17e4b9: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform2f(arg1, arg2, arg3);
-        },
-        __wbg_uniform2f_a92b5bb95dc5b4d9: function(arg0, arg1, arg2, arg3) {
-            arg0.uniform2f(arg1, arg2, arg3);
-        },
         __wbg_uniform2fv_319c49f0ce340f26: function(arg0, arg1, arg2, arg3) {
             arg0.uniform2fv(arg1, getArrayF32FromWasm0(arg2, arg3));
         },
@@ -2598,12 +4167,6 @@ function __wbg_get_imports() {
         __wbg_uniform2uiv_c95af5fb653ccb86: function(arg0, arg1, arg2, arg3) {
             arg0.uniform2uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
         },
-        __wbg_uniform3f_1211579ff87ccfad: function(arg0, arg1, arg2, arg3, arg4) {
-            arg0.uniform3f(arg1, arg2, arg3, arg4);
-        },
-        __wbg_uniform3f_ee105161897ee48a: function(arg0, arg1, arg2, arg3, arg4) {
-            arg0.uniform3f(arg1, arg2, arg3, arg4);
-        },
         __wbg_uniform3fv_055ea5ac38af4fce: function(arg0, arg1, arg2, arg3) {
             arg0.uniform3fv(arg1, getArrayF32FromWasm0(arg2, arg3));
         },
@@ -2640,24 +4203,58 @@ function __wbg_get_imports() {
         __wbg_uniform4uiv_a6fb3237d9df7ed4: function(arg0, arg1, arg2, arg3) {
             arg0.uniform4uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
         },
+        __wbg_uniformBlockBinding_07116582301fb019: function(arg0, arg1, arg2, arg3) {
+            arg0.uniformBlockBinding(arg1, arg2 >>> 0, arg3 >>> 0);
+        },
+        __wbg_uniformMatrix2fv_34b2245136106a2f: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_uniformMatrix2fv_611c7fcb378f057e: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_uniformMatrix2x3fv_6b33a76d09b6c00f: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix2x3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_uniformMatrix2x4fv_66c787e2d0a5dd0a: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix2x4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
         __wbg_uniformMatrix3fv_472e7824735acce1: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.uniformMatrix3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
         },
         __wbg_uniformMatrix3fv_83fdc9c3c0d43204: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.uniformMatrix3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
         },
+        __wbg_uniformMatrix3x2fv_33df849b78b8556e: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix3x2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_uniformMatrix3x4fv_8914dc5121a813b4: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix3x4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
         __wbg_uniformMatrix4fv_dff9738d995fd0b1: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.uniformMatrix4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
         },
         __wbg_uniformMatrix4fv_e691d7f14d3609f7: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.uniformMatrix4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
         },
+        __wbg_uniformMatrix4x2fv_1c9ccf4427b82548: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix4x2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_uniformMatrix4x3fv_a84b16e0a7abee2c: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.uniformMatrix4x3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_unmap_6a96b14c9ef5f7f5: function(arg0) {
+            arg0.unmap();
+        },
         __wbg_useProgram_5bdae58fd9f9826f: function(arg0, arg1) {
             arg0.useProgram(arg1);
         },
         __wbg_useProgram_e075c2902e420761: function(arg0, arg1) {
             arg0.useProgram(arg1);
         },
+        __wbg_valueOf_02fd4d101b7553c7: function(arg0) {
+            const ret = arg0.valueOf();
+            return ret;
+        },
         __wbg_vertexAttribDivisorANGLE_659fb027198a47c3: function(arg0, arg1, arg2) {
             arg0.vertexAttribDivisorANGLE(arg1 >>> 0, arg2 >>> 0);
         },
@@ -2673,6 +4270,14 @@ function __wbg_get_imports() {
         __wbg_vertexAttribPointer_54d56b18f71a946d: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
             arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
         },
+        __wbg_videoHeight_4070b88110b1ac0d: function(arg0) {
+            const ret = arg0.videoHeight;
+            return ret;
+        },
+        __wbg_videoWidth_ea74d0fb1493f025: function(arg0) {
+            const ret = arg0.videoWidth;
+            return ret;
+        },
         __wbg_viewport_16936692526e2ce6: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.viewport(arg1, arg2, arg3, arg4);
         },
@@ -2682,56 +4287,98 @@ function __wbg_get_imports() {
         __wbg_warn_13abc63e0d4b3527: function(arg0) {
             console.warn(arg0);
         },
+        __wbg_width_3b5d66c5eac1eb28: function(arg0) {
+            const ret = arg0.width;
+            return ret;
+        },
+        __wbg_width_3d0dce3d9892e35e: function(arg0) {
+            const ret = arg0.width;
+            return ret;
+        },
+        __wbg_width_7a1b335e4a553dc3: function(arg0) {
+            const ret = arg0.width;
+            return ret;
+        },
         __wbg_width_8a9cc26363f10d5f: function(arg0) {
             const ret = arg0.width;
             return ret;
         },
+        __wbg_width_c9bfe09197f3b26e: function(arg0) {
+            const ret = arg0.width;
+            return ret;
+        },
+        __wbg_writeBuffer_f4bb3f54adfe1330: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            arg0.writeBuffer(arg1, arg2, getArrayU8FromWasm0(arg3, arg4), arg5, arg6);
+        }, arguments); },
+        __wbg_writeTexture_30e592e8c061c3d9: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.writeTexture(arg1, getArrayU8FromWasm0(arg2, arg3), arg4, arg5);
+        }, arguments); },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 122, 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_);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2389, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 322, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUUncapturedErrorEvent")], shim_idx: 326, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuDeviceLostInfo__GpuDeviceLostInfo______true_);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 322, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__132);
+            return ret;
+        },
+        __wbindgen_generic_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 322, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__133);
             return ret;
         },
-        __wbindgen_generic_0000000000000002: function(arg0) {
+        __wbindgen_generic_0000000000000006: function(arg0) {
             // Cast intrinsic for `F64 -> Externref`.
             const ret = arg0;
             return ret;
         },
-        __wbindgen_generic_0000000000000003: function(arg0, arg1) {
+        __wbindgen_generic_0000000000000007: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
             const ret = getArrayF32FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_0000000000000004: function(arg0, arg1) {
+        __wbindgen_generic_0000000000000008: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(I16)) -> NamedExternref("Int16Array")`.
             const ret = getArrayI16FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_0000000000000005: function(arg0, arg1) {
+        __wbindgen_generic_0000000000000009: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(I32)) -> NamedExternref("Int32Array")`.
             const ret = getArrayI32FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_0000000000000006: function(arg0, arg1) {
+        __wbindgen_generic_000000000000000a: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(I8)) -> NamedExternref("Int8Array")`.
             const ret = getArrayI8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_0000000000000007: function(arg0, arg1) {
+        __wbindgen_generic_000000000000000b: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U16)) -> NamedExternref("Uint16Array")`.
             const ret = getArrayU16FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_0000000000000008: function(arg0, arg1) {
+        __wbindgen_generic_000000000000000c: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U32)) -> NamedExternref("Uint32Array")`.
             const ret = getArrayU32FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_0000000000000009: function(arg0, arg1) {
+        __wbindgen_generic_000000000000000d: function(arg0, arg1) {
             // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
             const ret = getArrayU8FromWasm0(arg0, arg1);
             return ret;
         },
-        __wbindgen_generic_000000000000000a: function(arg0, arg1) {
+        __wbindgen_generic_000000000000000e: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return ret;
@@ -2748,32 +4395,138 @@ function __wbg_get_imports() {
     };
     return {
         __proto__: null,
-        "./isard_core_bg.js": import0,
+        "./isard_webgl2_bg.js": import0,
     };
 }
 
-function wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_2e566c63402fe7fa___convert__closures_____invoke___wasm_bindgen_2e566c63402fe7fa___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_2e566c63402fe7fa___JsError___true_(arg0, arg1, arg2);
+function wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuDeviceLostInfo__GpuDeviceLostInfo______true_(arg0, arg1, arg2) {
+    wasm.wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuDeviceLostInfo__GpuDeviceLostInfo______true_(arg0, arg1, arg2);
+}
+
+function wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true_(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__132(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__132(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function 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_(arg0, arg1, arg2, arg3) {
-    wasm.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_(arg0, arg1, arg2, arg3);
+function wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__133(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___wasm_bindgen_4346cdda5a9d72ac___sys__JsNullable_wgpu_ce7204c20056c03e___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_4346cdda5a9d72ac___JsError___true__133(arg0, arg1, arg2);
+    if (ret[1]) {
+        throw takeFromExternrefTable0(ret[0]);
+    }
+}
+
+function wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_4346cdda5a9d72ac___convert__closures_____invoke___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined___js_sys_5e75a17f0680aa0e___Function_fn_wasm_bindgen_4346cdda5a9d72ac___JsValue_____wasm_bindgen_4346cdda5a9d72ac___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 
 const __wbindgen_enum_ColorSpaceConversion = ["none", "default"];
 
 
-const __wbindgen_enum_PremultiplyAlpha = ["none", "premultiply", "default"];
+const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
 
 
-const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
+const __wbindgen_enum_GpuAutoLayoutMode = ["auto"];
+
+
+const __wbindgen_enum_GpuBlendFactor = ["zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant", "src1", "one-minus-src1", "src1-alpha", "one-minus-src1-alpha"];
+
+
+const __wbindgen_enum_GpuBlendOperation = ["add", "subtract", "reverse-subtract", "min", "max"];
+
+
+const __wbindgen_enum_GpuBufferBindingType = ["uniform", "storage", "read-only-storage"];
+
+
+const __wbindgen_enum_GpuCanvasAlphaMode = ["opaque", "premultiplied"];
+
+
+const __wbindgen_enum_GpuCanvasToneMappingMode = ["standard", "extended"];
+
+
+const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
+
+
+const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
+
+
+const __wbindgen_enum_GpuErrorFilter = ["validation", "out-of-memory", "internal"];
+
+
+const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
+
+
+const __wbindgen_enum_GpuFrontFace = ["ccw", "cw"];
+
+
+const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
+
+
+const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
+
+
+const __wbindgen_enum_GpuMipmapFilterMode = ["nearest", "linear"];
+
+
+const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
+
 
+const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
 
-const __wbindgen_enum_WebGlPowerPreference = ["default", "low-power", "high-performance"];
+
+const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];
+
+
+const __wbindgen_enum_GpuStencilOperation = ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"];
+
+
+const __wbindgen_enum_GpuStorageTextureAccess = ["write-only", "read-only", "read-write"];
+
+
+const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
+
+
+const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
+
+
+const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
+
+
+const __wbindgen_enum_GpuTextureFormat = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16unorm", "r16snorm", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16unorm", "rg16snorm", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16unorm", "rgba16snorm", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"];
+
+
+const __wbindgen_enum_GpuTextureSampleType = ["float", "unfilterable-float", "depth", "sint", "uint"];
+
+
+const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
+
+
+const __wbindgen_enum_GpuVertexFormat = ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
+
+
+const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
+
+
+const __wbindgen_enum_PremultiplyAlpha = ["none", "premultiply", "default"];
+
+
+const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
 const EngineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_engine_free(ptr, 1));
@@ -2878,6 +4631,16 @@ function getArrayI8FromWasm0(ptr, len) {
     return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function getArrayJsValueViewFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
 function getArrayU16FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
@@ -3217,7 +4980,7 @@ async function __wbg_init(module_or_path) {
     }
 
     if (module_or_path === undefined) {
-        module_or_path = new URL('isard_core_bg.wasm', import.meta.url);
+        module_or_path = new URL('isard_webgl2_bg.wasm', import.meta.url);
     }
     const imports = __wbg_get_imports();