goudengine 0.0.826 → 0.0.828

package/wasm/goud_engine.js

@@ -1,28 +1,97 @@
 /* @ts-self-types="./goud_engine.d.ts" */
 
-/**
- * Chroma subsampling format
- * @enum {0 | 1 | 2 | 3}
- */
-export const ChromaSampling = Object.freeze({
+export class WasmContact {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmContact.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmContactFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmContactFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcontact_free(ptr, 0);
+    }
     /**
-     * Both vertically and horizontally subsampled.
+     * @returns {number}
+     */
+    get normal_x() {
+        const ret = wasm.__wbg_get_wasmcontact_normal_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get normal_y() {
+        const ret = wasm.__wbg_get_wasmcontact_normal_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get penetration() {
+        const ret = wasm.__wbg_get_wasmcontact_penetration(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get point_x() {
+        const ret = wasm.__wbg_get_wasmcontact_point_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get point_y() {
+        const ret = wasm.__wbg_get_wasmcontact_point_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set normal_x(arg0) {
+        wasm.__wbg_set_wasmcontact_normal_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
      */
-    Cs420: 0, "0": "Cs420",
+    set normal_y(arg0) {
+        wasm.__wbg_set_wasmcontact_normal_y(this.__wbg_ptr, arg0);
+    }
     /**
-     * Horizontally subsampled.
+     * @param {number} arg0
      */
-    Cs422: 1, "1": "Cs422",
+    set penetration(arg0) {
+        wasm.__wbg_set_wasmcontact_penetration(this.__wbg_ptr, arg0);
+    }
     /**
-     * Not subsampled.
+     * @param {number} arg0
      */
-    Cs444: 2, "2": "Cs444",
+    set point_x(arg0) {
+        wasm.__wbg_set_wasmcontact_point_x(this.__wbg_ptr, arg0);
+    }
     /**
-     * Monochrome.
+     * @param {number} arg0
      */
-    Cs400: 3, "3": "Cs400",
-});
+    set point_y(arg0) {
+        wasm.__wbg_set_wasmcontact_point_y(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) WasmContact.prototype[Symbol.dispose] = WasmContact.prototype.free;
 
+/**
+ * The primary game handle for browser-based games.
+ *
+ * Owns the ECS world, input state, frame timing, and an optional wgpu
+ * rendering backend attached to an HTML canvas element.
+ */
 export class WasmGame {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -41,6 +110,21 @@ export class WasmGame {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmgame_free(ptr, 0);
     }
+    /**
+     * @param {number} min_ax
+     * @param {number} min_ay
+     * @param {number} max_ax
+     * @param {number} max_ay
+     * @param {number} min_bx
+     * @param {number} min_by
+     * @param {number} max_bx
+     * @param {number} max_by
+     * @returns {boolean}
+     */
+    aabb_overlap(min_ax, min_ay, max_ax, max_ay, min_bx, min_by, max_bx, max_by) {
+        const ret = wasm.wasmgame_aabb_overlap(this.__wbg_ptr, min_ax, min_ay, max_ax, max_ay, min_bx, min_by, max_bx, max_by);
+        return ret !== 0;
+    }
     /**
      * @param {bigint} entity_bits
      * @param {string} name
@@ -57,6 +141,21 @@ export class WasmGame {
     add_scroll_delta(dx, dy) {
         wasm.wasmgame_add_scroll_delta(this.__wbg_ptr, dx, dy);
     }
+    /**
+     * @param {bigint} entity_bits
+     * @param {number} texture_handle
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     * @param {boolean} flip_x
+     * @param {boolean} flip_y
+     * @param {number} anchor_x
+     * @param {number} anchor_y
+     */
+    add_sprite(entity_bits, texture_handle, r, g, b, a, flip_x, flip_y, anchor_x, anchor_y) {
+        wasm.wasmgame_add_sprite(this.__wbg_ptr, entity_bits, texture_handle, r, g, b, a, flip_x, flip_y, anchor_x, anchor_y);
+    }
     /**
      * @param {bigint} entity_bits
      * @param {number} px
@@ -69,11 +168,69 @@ export class WasmGame {
         wasm.wasmgame_add_transform2d(this.__wbg_ptr, entity_bits, px, py, rotation, sx, sy);
     }
     /**
+     * Advances frame timing and prepares the wgpu surface for drawing.
+     *
+     * Call this at the start of each `requestAnimationFrame` callback.
      * @param {number} delta_time
      */
     begin_frame(delta_time) {
         wasm.wasmgame_begin_frame(this.__wbg_ptr, delta_time);
     }
+    /**
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} r1
+     * @param {number} x2
+     * @param {number} y2
+     * @param {number} r2
+     * @returns {boolean}
+     */
+    circle_overlap(x1, y1, r1, x2, y2, r2) {
+        const ret = wasm.wasmgame_circle_overlap(this.__wbg_ptr, x1, y1, r1, x2, y2, r2);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} center_ax
+     * @param {number} center_ay
+     * @param {number} half_wa
+     * @param {number} half_ha
+     * @param {number} center_bx
+     * @param {number} center_by
+     * @param {number} half_wb
+     * @param {number} half_hb
+     * @returns {WasmContact | undefined}
+     */
+    collision_aabb_aabb(center_ax, center_ay, half_wa, half_ha, center_bx, center_by, half_wb, half_hb) {
+        const ret = wasm.wasmgame_collision_aabb_aabb(this.__wbg_ptr, center_ax, center_ay, half_wa, half_ha, center_bx, center_by, half_wb, half_hb);
+        return ret === 0 ? undefined : WasmContact.__wrap(ret);
+    }
+    /**
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} cr
+     * @param {number} bx
+     * @param {number} by
+     * @param {number} bhw
+     * @param {number} bhh
+     * @returns {WasmContact | undefined}
+     */
+    collision_circle_aabb(cx, cy, cr, bx, by, bhw, bhh) {
+        const ret = wasm.wasmgame_collision_circle_aabb(this.__wbg_ptr, cx, cy, cr, bx, by, bhw, bhh);
+        return ret === 0 ? undefined : WasmContact.__wrap(ret);
+    }
+    /**
+     * @param {number} center_ax
+     * @param {number} center_ay
+     * @param {number} radius_a
+     * @param {number} center_bx
+     * @param {number} center_by
+     * @param {number} radius_b
+     * @returns {WasmContact | undefined}
+     */
+    collision_circle_circle(center_ax, center_ay, radius_a, center_bx, center_by, radius_b) {
+        const ret = wasm.wasmgame_collision_circle_circle(this.__wbg_ptr, center_ax, center_ay, radius_a, center_bx, center_by, radius_b);
+        return ret === 0 ? undefined : WasmContact.__wrap(ret);
+    }
     /**
      * Creates a game instance with wgpu rendering attached to a canvas.
      * @param {HTMLCanvasElement} canvas
@@ -89,6 +246,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Seconds elapsed since the previous frame.
      * @returns {number}
      */
     get delta_time() {
@@ -103,12 +261,46 @@ export class WasmGame {
         const ret = wasm.wasmgame_despawn(this.__wbg_ptr, entity_bits);
         return ret !== 0;
     }
+    /**
+     * Despawns multiple entities at once. Returns the number of entities
+     * successfully despawned.
+     * @param {BigUint64Array} entity_bits
+     * @returns {number}
+     */
+    despawn_batch(entity_bits) {
+        const ptr0 = passArray64ToWasm0(entity_bits, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_despawn_batch(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
     /**
      * @param {number} handle
      */
     destroy_texture(handle) {
         wasm.wasmgame_destroy_texture(this.__wbg_ptr, handle);
     }
+    /**
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @returns {number}
+     */
+    distance(x1, y1, x2, y2) {
+        const ret = wasm.wasmgame_distance(this.__wbg_ptr, x1, y1, x2, y2);
+        return ret;
+    }
+    /**
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} x2
+     * @param {number} y2
+     * @returns {number}
+     */
+    distance_squared(x1, y1, x2, y2) {
+        const ret = wasm.wasmgame_distance_squared(this.__wbg_ptr, x1, y1, x2, y2);
+        return ret;
+    }
     /**
      * @param {number} x
      * @param {number} y
@@ -137,6 +329,32 @@ export class WasmGame {
     draw_sprite(texture, x, y, w, h, rotation, r, g, b, a) {
         wasm.wasmgame_draw_sprite(this.__wbg_ptr, texture, x, y, w, h, rotation, r, g, b, a);
     }
+    /**
+     * @param {number} texture
+     * @param {number} x
+     * @param {number} y
+     * @param {number} w
+     * @param {number} h
+     * @param {number} rotation
+     * @param {number} src_x
+     * @param {number} src_y
+     * @param {number} src_w
+     * @param {number} src_h
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     * @returns {boolean}
+     */
+    draw_sprite_rect(texture, x, y, w, h, rotation, src_x, src_y, src_w, src_h, r, g, b, a) {
+        const ret = wasm.wasmgame_draw_sprite_rect(this.__wbg_ptr, texture, x, y, w, h, rotation, src_x, src_y, src_w, src_h, r, g, b, a);
+        return ret !== 0;
+    }
+    /**
+     * Flushes queued draw calls and presents the frame to the canvas.
+     *
+     * Call this at the end of each `requestAnimationFrame` callback.
+     */
     end_frame() {
         wasm.wasmgame_end_frame(this.__wbg_ptr);
     }
@@ -148,6 +366,7 @@ export class WasmGame {
         return ret >>> 0;
     }
     /**
+     * Approximate frames per second based on the most recent delta.
      * @returns {number}
      */
     get fps() {
@@ -155,6 +374,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Number of frames rendered since the game started.
      * @returns {bigint}
      */
     get frame_count() {
@@ -174,6 +394,23 @@ export class WasmGame {
         }
         return v1;
     }
+    /**
+     * Returns render statistics for the current frame, or `None` if
+     * rendering is not active.
+     * @returns {WasmRenderStats | undefined}
+     */
+    get_render_stats() {
+        const ret = wasm.wasmgame_get_render_stats(this.__wbg_ptr);
+        return ret === 0 ? undefined : WasmRenderStats.__wrap(ret);
+    }
+    /**
+     * @param {bigint} entity_bits
+     * @returns {WasmSprite | undefined}
+     */
+    get_sprite(entity_bits) {
+        const ret = wasm.wasmgame_get_sprite(this.__wbg_ptr, entity_bits);
+        return ret === 0 ? undefined : WasmSprite.__wrap(ret);
+    }
     /**
      * @param {bigint} entity_bits
      * @returns {WasmTransform2D | undefined}
@@ -191,13 +428,22 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
-     * Whether wgpu rendering is active.
+     * Returns `true` when wgpu rendering is active (canvas was provided at
+     * construction time).
      * @returns {boolean}
      */
     has_renderer() {
         const ret = wasm.wasmgame_has_renderer(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * @param {bigint} entity_bits
+     * @returns {boolean}
+     */
+    has_sprite(entity_bits) {
+        const ret = wasm.wasmgame_has_sprite(this.__wbg_ptr, entity_bits);
+        return ret !== 0;
+    }
     /**
      * @param {bigint} entity_bits
      * @returns {boolean}
@@ -206,6 +452,41 @@ export class WasmGame {
         const ret = wasm.wasmgame_has_transform2d(this.__wbg_ptr, entity_bits);
         return ret !== 0;
     }
+    /**
+     * Returns `true` if any key mapped to the given action was just pressed
+     * this frame (not held from previous frame).
+     * @param {string} action
+     * @returns {boolean}
+     */
+    is_action_just_pressed(action) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_is_action_just_pressed(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Returns `true` if any key mapped to the given action was just released
+     * this frame (held previous frame but not current).
+     * @param {string} action
+     * @returns {boolean}
+     */
+    is_action_just_released(action) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_is_action_just_released(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
+    /**
+     * Returns `true` if any key mapped to the given action is currently held.
+     * @param {string} action
+     * @returns {boolean}
+     */
+    is_action_pressed(action) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_is_action_pressed(this.__wbg_ptr, ptr0, len0);
+        return ret !== 0;
+    }
     /**
      * @param {bigint} entity_bits
      * @returns {boolean}
@@ -246,6 +527,14 @@ export class WasmGame {
         const ret = wasm.wasmgame_is_mouse_button_just_pressed(this.__wbg_ptr, button);
         return ret !== 0;
     }
+    /**
+     * @param {number} button
+     * @returns {boolean}
+     */
+    is_mouse_button_just_released(button) {
+        const ret = wasm.wasmgame_is_mouse_button_just_released(this.__wbg_ptr, button);
+        return ret !== 0;
+    }
     /**
      * @param {number} button
      * @returns {boolean}
@@ -255,16 +544,17 @@ export class WasmGame {
         return ret !== 0;
     }
     /**
-     * Loads a texture from a URL. Returns the texture handle (1-based;
-     * 0 is reserved for the white fallback texture used by draw_quad).
-     * @param {string} url
-     * @returns {Promise<number>}
+     * Maps an action name to a key code. Multiple keys can be mapped
+     * to the same action. Returns `true` on success.
+     * @param {string} action
+     * @param {number} key
+     * @returns {boolean}
      */
-    load_texture(url) {
-        const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    map_action_key(action, key) {
+        const ptr0 = passStringToWasm0(action, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmgame_load_texture(this.__wbg_ptr, ptr0, len0);
-        return ret;
+        const ret = wasm.wasmgame_map_action_key(this.__wbg_ptr, ptr0, len0, key);
+        return ret !== 0;
     }
     /**
      * @returns {number}
@@ -294,6 +584,31 @@ export class WasmGame {
         WasmGameFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {number} px
+     * @param {number} py
+     * @param {number} cx
+     * @param {number} cy
+     * @param {number} r
+     * @returns {boolean}
+     */
+    point_in_circle(px, py, cx, cy, r) {
+        const ret = wasm.wasmgame_point_in_circle(this.__wbg_ptr, px, py, cx, cy, r);
+        return ret !== 0;
+    }
+    /**
+     * @param {number} px
+     * @param {number} py
+     * @param {number} rx
+     * @param {number} ry
+     * @param {number} rw
+     * @param {number} rh
+     * @returns {boolean}
+     */
+    point_in_rect(px, py, rx, ry, rw, rh) {
+        const ret = wasm.wasmgame_point_in_rect(this.__wbg_ptr, px, py, rx, ry, rw, rh);
+        return ret !== 0;
+    }
     /**
      * @param {number} key_code
      */
@@ -306,6 +621,25 @@ export class WasmGame {
     press_mouse_button(button) {
         wasm.wasmgame_press_mouse_button(this.__wbg_ptr, button);
     }
+    /**
+     * Registers a texture from raw image bytes (PNG, JPG, etc.).
+     *
+     * The browser-side SDK fetches the image data asynchronously, then
+     * passes the raw bytes here for synchronous decode + GPU upload.
+     * Returns the texture handle (1-based; 0 is reserved for the white
+     * fallback texture used by `draw_quad`).
+     * @param {Uint8Array} data
+     * @returns {number}
+     */
+    register_texture_from_bytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.wasmgame_register_texture_from_bytes(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] >>> 0;
+    }
     /**
      * @param {number} key_code
      */
@@ -326,6 +660,14 @@ export class WasmGame {
         const ret = wasm.wasmgame_remove_name(this.__wbg_ptr, entity_bits);
         return ret !== 0;
     }
+    /**
+     * @param {bigint} entity_bits
+     * @returns {boolean}
+     */
+    remove_sprite(entity_bits) {
+        const ret = wasm.wasmgame_remove_sprite(this.__wbg_ptr, entity_bits);
+        return ret !== 0;
+    }
     /**
      * @param {bigint} entity_bits
      * @returns {boolean}
@@ -357,8 +699,9 @@ export class WasmGame {
         wasm.wasmgame_set_canvas_size(this.__wbg_ptr, width, height);
     }
     /**
-     * Sets the background clear color (called before begin_frame or via
-     * the TypeScript SDK's beginFrame parameters).
+     * Sets the background clear color.
+     *
+     * Takes effect on the next `begin_frame` / `end_frame` pair.
      * @param {number} r
      * @param {number} g
      * @param {number} b
@@ -374,6 +717,21 @@ export class WasmGame {
     set_mouse_position(x, y) {
         wasm.wasmgame_set_mouse_position(this.__wbg_ptr, x, y);
     }
+    /**
+     * @param {bigint} entity_bits
+     * @param {number} texture_handle
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     * @param {boolean} flip_x
+     * @param {boolean} flip_y
+     * @param {number} anchor_x
+     * @param {number} anchor_y
+     */
+    set_sprite(entity_bits, texture_handle, r, g, b, a, flip_x, flip_y, anchor_x, anchor_y) {
+        wasm.wasmgame_set_sprite(this.__wbg_ptr, entity_bits, texture_handle, r, g, b, a, flip_x, flip_y, anchor_x, anchor_y);
+    }
     /**
      * @param {bigint} entity_bits
      * @param {number} px
@@ -403,6 +761,7 @@ export class WasmGame {
         return BigInt.asUintN(64, ret);
     }
     /**
+     * The title string passed at construction time.
      * @returns {string}
      */
     get title() {
@@ -418,6 +777,7 @@ export class WasmGame {
         }
     }
     /**
+     * Total seconds elapsed since the game started.
      * @returns {number}
      */
     get total_time() {
@@ -425,6 +785,7 @@ export class WasmGame {
         return ret;
     }
     /**
+     * Logical canvas height in pixels.
      * @returns {number}
      */
     get window_height() {
@@ -432,6 +793,7 @@ export class WasmGame {
         return ret >>> 0;
     }
     /**
+     * Logical canvas width in pixels.
      * @returns {number}
      */
     get window_width() {
@@ -441,6 +803,215 @@ export class WasmGame {
 }
 if (Symbol.dispose) WasmGame.prototype[Symbol.dispose] = WasmGame.prototype.free;
 
+/**
+ * Per-frame rendering statistics exposed to JavaScript.
+ */
+export class WasmRenderStats {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmRenderStats.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmRenderStatsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmRenderStatsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmrenderstats_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get draw_calls() {
+        const ret = wasm.__wbg_get_wasmrenderstats_draw_calls(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get texture_binds() {
+        const ret = wasm.__wbg_get_wasmrenderstats_texture_binds(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get triangles() {
+        const ret = wasm.__wbg_get_wasmrenderstats_triangles(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set draw_calls(arg0) {
+        wasm.__wbg_set_wasmrenderstats_draw_calls(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set texture_binds(arg0) {
+        wasm.__wbg_set_wasmrenderstats_texture_binds(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set triangles(arg0) {
+        wasm.__wbg_set_wasmrenderstats_triangles(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) WasmRenderStats.prototype[Symbol.dispose] = WasmRenderStats.prototype.free;
+
+/**
+ * A plain-data snapshot of a `Sprite` component, safe to pass across
+ * the wasm-bindgen boundary.
+ */
+export class WasmSprite {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmSprite.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmSpriteFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmSpriteFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmsprite_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get a() {
+        const ret = wasm.__wbg_get_wasmsprite_a(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get anchor_x() {
+        const ret = wasm.__wbg_get_wasmsprite_anchor_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get anchor_y() {
+        const ret = wasm.__wbg_get_wasmsprite_anchor_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get b() {
+        const ret = wasm.__wbg_get_wasmsprite_b(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get flip_x() {
+        const ret = wasm.__wbg_get_wasmsprite_flip_x(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get flip_y() {
+        const ret = wasm.__wbg_get_wasmsprite_flip_y(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get g() {
+        const ret = wasm.__wbg_get_wasmsprite_g(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get r() {
+        const ret = wasm.__wbg_get_wasmsprite_r(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get texture_handle() {
+        const ret = wasm.__wbg_get_wasmsprite_texture_handle(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {number} arg0
+     */
+    set a(arg0) {
+        wasm.__wbg_set_wasmsprite_a(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set anchor_x(arg0) {
+        wasm.__wbg_set_wasmsprite_anchor_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set anchor_y(arg0) {
+        wasm.__wbg_set_wasmsprite_anchor_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set b(arg0) {
+        wasm.__wbg_set_wasmsprite_b(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set flip_x(arg0) {
+        wasm.__wbg_set_wasmsprite_flip_x(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {boolean} arg0
+     */
+    set flip_y(arg0) {
+        wasm.__wbg_set_wasmsprite_flip_y(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set g(arg0) {
+        wasm.__wbg_set_wasmsprite_g(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set r(arg0) {
+        wasm.__wbg_set_wasmsprite_r(this.__wbg_ptr, arg0);
+    }
+    /**
+     * @param {number} arg0
+     */
+    set texture_handle(arg0) {
+        wasm.__wbg_set_wasmsprite_texture_handle(this.__wbg_ptr, arg0);
+    }
+}
+if (Symbol.dispose) WasmSprite.prototype[Symbol.dispose] = WasmSprite.prototype.free;
+
+/**
+ * A plain-data snapshot of a `Transform2D` component, safe to pass across
+ * the wasm-bindgen boundary.
+ */
 export class WasmTransform2D {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -563,10 +1134,6 @@ function __wbg_get_imports() {
         __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
             arg0._wbg_cb_unref();
         },
-        __wbg_arrayBuffer_eb8e9ca620af2a19: function() { return handleError(function (arg0) {
-            const ret = arg0.arrayBuffer();
-            return ret;
-        }, arguments); },
         __wbg_beginRenderPass_b6be55dca13d3752: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.beginRenderPass(arg1);
             return ret;
@@ -635,10 +1202,6 @@ function __wbg_get_imports() {
         __wbg_error_8d9a8e04cd1d3588: function(arg0) {
             console.error(arg0);
         },
-        __wbg_fetch_e261f234f8b50660: function(arg0, arg1, arg2) {
-            const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));
-            return ret;
-        },
         __wbg_finish_1f441b2d9fcf60d0: function(arg0, arg1) {
             const ret = arg0.finish(arg1);
             return ret;
@@ -695,16 +1258,6 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Response_9b4d9fd451e051b1: function(arg0) {
-            let result;
-            try {
-                result = arg0 instanceof Response;
-            } catch (_) {
-                result = false;
-            }
-            const ret = result;
-            return ret;
-        },
         __wbg_instanceof_Window_23e677d2c6843922: function(arg0) {
             let result;
             try {
@@ -738,10 +1291,6 @@ function __wbg_get_imports() {
             const ret = arg0.navigator;
             return ret;
         },
-        __wbg_new_5f486cdf45a04d78: function(arg0) {
-            const ret = new Uint8Array(arg0);
-            return ret;
-        },
         __wbg_new_ab79df5bd7c26067: function() {
             const ret = new Object();
             return ret;
@@ -776,10 +1325,6 @@ function __wbg_get_imports() {
             const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_ok_7ec8b94facac7704: function(arg0) {
-            const ret = arg0.ok;
-            return ret;
-        },
         __wbg_onSubmittedWorkDone_a33e32762de21b3d: function(arg0) {
             const ret = arg0.onSubmittedWorkDone();
             return ret;
@@ -1348,10 +1893,6 @@ function __wbg_get_imports() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_status_318629ab93a22955: function(arg0) {
-            const ret = arg0.status;
-            return ret;
-        },
         __wbg_submit_19b0e21319bc36d7: function(arg0, arg1) {
             arg0.submit(arg1);
         },
@@ -1381,12 +1922,12 @@ function __wbg_get_imports() {
             arg0.writeTexture(arg1, arg2, arg3, arg4);
         }, arguments); },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 72, function: Function { arguments: [Externref], shim_idx: 73, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 61, function: Function { arguments: [Externref], shim_idx: 62, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h34b32f47e9536ad7, wasm_bindgen__convert__closures_____invoke__h8b43903f8a91b24f);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 777, function: Function { arguments: [Externref], shim_idx: 778, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 766, function: Function { arguments: [Externref], shim_idx: 767, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hb7ee5c5d3fd608d4, wasm_bindgen__convert__closures_____invoke__h6c9ef6970fdda1f4);
             return ret;
         },
@@ -1510,9 +2051,18 @@ const __wbindgen_enum_GpuVertexFormat = ["uint8", "uint8x2", "uint8x4", "sint8",
 
 
 const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
+const WasmContactFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmcontact_free(ptr >>> 0, 1));
 const WasmGameFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmgame_free(ptr >>> 0, 1));
+const WasmRenderStatsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmrenderstats_free(ptr >>> 0, 1));
+const WasmSpriteFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmsprite_free(ptr >>> 0, 1));
 const WasmTransform2DFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmtransform2d_free(ptr >>> 0, 1));
@@ -1685,6 +2235,20 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 
+function passArray64ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 8, 8) >>> 0;
+    getBigUint64ArrayMemory0().set(arg, ptr / 8);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);