@origingame/engine 0.2.0 → 0.4.0

package/dist/web-publish/origin-engine-lanes.js

@@ -212,6 +212,42 @@ export function og_anim_retarget(world, desc) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {number} rig
+ * @returns {string}
+ */
+export function og_anim_rig2d_info(world, rig) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_anim_rig2d_info(world, rig);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_anim_skeleton2d_boxes(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_anim_skeleton2d_boxes(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} archetype_view
  * @param {string} component
@@ -1297,6 +1333,26 @@ export function og_load_palette(world, path) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} path
+ * @returns {string}
+ */
+export function og_load_post(world, path) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_post(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string} path
@@ -1322,13 +1378,13 @@ export function og_load_rig(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_scene(world, path) {
+export function og_load_rig2d(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_scene(world, ptr0, len0);
+        const ret = wasm.og_load_rig2d(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1342,13 +1398,13 @@ export function og_load_scene(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_shader(world, path) {
+export function og_load_scene(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_shader(world, ptr0, len0);
+        const ret = wasm.og_load_scene(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1362,13 +1418,13 @@ export function og_load_shader(world, path) {
  * @param {string} path
  * @returns {string}
  */
-export function og_load_skin(world, path) {
+export function og_load_shader(world, path) {
     let deferred2_0;
     let deferred2_1;
     try {
         const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_load_skin(world, ptr0, len0);
+        const ret = wasm.og_load_shader(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -1433,6 +1489,26 @@ export function og_load_status(world, asset) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} path
+ * @returns {string}
+ */
+export function og_load_style(world, path) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_style(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string} path
@@ -1493,6 +1569,64 @@ export function og_load_tilemap(world, path) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} path
+ * @returns {string}
+ */
+export function og_load_timeline(world, path) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_timeline(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} path
+ * @returns {string}
+ */
+export function og_load_video(world, path) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_load_video(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} video
+ * @returns {string}
+ */
+export function og_load_video_info(world, video) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_load_video_info(world, video);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string | null} [desc]
@@ -1761,6 +1895,158 @@ export function og_nav_set_obstacle(world, mesh, id, obstacle) {
     }
 }
 
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_net_hash(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_net_hash(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_net_status(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_net_status(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [input]
+ * @returns {string}
+ */
+export function og_net_submit(world, input) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(input) ? 0 : passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_net_submit(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_path_create(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_path_create(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} name
+ * @returns {string}
+ */
+export function og_path_find(world, name) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_path_find(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} path
+ * @returns {string}
+ */
+export function og_path_length(world, path) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_path_length(world, path);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} path
+ * @param {string} point
+ * @returns {string}
+ */
+export function og_path_nearest(world, path, point) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(point, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_path_nearest(world, path, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} path
+ * @param {number} t
+ * @returns {string}
+ */
+export function og_path_sample(world, path, t) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_path_sample(world, path, t);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {number} entity
@@ -2286,6 +2572,136 @@ export function og_platform_result(world, request) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_platform_room_create(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_room_create(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_platform_room_info(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_info(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} room
+ * @returns {string}
+ */
+export function og_platform_room_join(world, room) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(room, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_room_join(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_platform_room_leave(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_leave(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} message
+ * @returns {string}
+ */
+export function og_platform_room_message(world, message) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_message(world, message);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_platform_room_peers(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_platform_room_peers(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} data
+ * @param {number | null} [to]
+ * @returns {string}
+ */
+export function og_platform_room_send(world, data, to) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_platform_room_send(world, ptr0, len0, isLikeNone(to) ? Number.MAX_SAFE_INTEGER : (to) >>> 0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string} value
@@ -2588,6 +3004,43 @@ export function og_render_apply_look(world, look) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string} preset
+ * @returns {string}
+ */
+export function og_render_apply_quality(world, preset) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(preset, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_apply_quality(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_render_baked_lighting(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_baked_lighting(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @param {string | null} [desc]
@@ -2608,6 +3061,26 @@ export function og_render_box_geometry(world, desc) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_buffer_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_buffer_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * @param {number} world
  * @returns {string}
@@ -2616,27 +3089,572 @@ export function og_render_capabilities(world) {
     let deferred1_0;
     let deferred1_1;
     try {
-        const ret = wasm.og_render_capabilities(world);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
+        const ret = wasm.og_render_capabilities(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_capsule_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_capsule_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_circle_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_circle_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_cone_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_cone_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_csg_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_csg_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_cylinder_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_cylinder_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_dodecahedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_dodecahedron_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_extrude_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_extrude_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_floating_text(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_floating_text(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} geometry
+ * @returns {string}
+ */
+export function og_render_geometry_info(world, geometry) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_geometry_info(world, geometry);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_icosahedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_icosahedron_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_lathe_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_lathe_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_lines(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_lines(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_render_look(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_look(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_measure_text(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_measure_text(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_merge_geometries(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_merge_geometries(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_octahedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_octahedron_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_plane_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_plane_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_points(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_points(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_polyhedron_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_polyhedron_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @returns {string}
+ */
+export function og_render_post_errors(world) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_render_post_errors(world);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string} ray
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_raycast(world, ray, desc) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(ray, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_raycast(world, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_render_target(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_render_target(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_ribbon(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_ribbon(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {string | null} [desc]
+ * @returns {string}
+ */
+export function og_render_ring_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_ring_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} material
+ * @param {string} shader
+ * @returns {string}
+ */
+export function og_render_set_material_shader(world, material, shader) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(shader, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_set_material_shader(world, material, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} post
+ * @param {string} name
+ * @param {string} value
+ * @returns {string}
+ */
+export function og_render_set_post_param(world, post, name, value) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_set_post_param(world, post, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} material
+ * @param {string} name
+ * @param {string} value
+ * @returns {string}
+ */
+export function og_render_set_shader_param(world, material, name, value) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_set_shader_param(world, material, ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
     }
 }
 
 /**
  * @param {number} world
+ * @param {number} shader
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_floating_text(world, desc) {
+export function og_render_shader_material(world, shader, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_floating_text(world, ptr0, len0);
+        const ret = wasm.og_render_shader_material(world, shader, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2645,35 +3663,18 @@ export function og_render_floating_text(world, desc) {
     }
 }
 
-/**
- * @param {number} world
- * @returns {string}
- */
-export function og_render_look(world) {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const ret = wasm.og_render_look(world);
-        deferred1_0 = ret[0];
-        deferred1_1 = ret[1];
-        return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-}
-
 /**
  * @param {number} world
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_measure_text(world, desc) {
+export function og_render_shape_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_measure_text(world, ptr0, len0);
+        const ret = wasm.og_render_shape_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2687,13 +3688,13 @@ export function og_render_measure_text(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_plane_geometry(world, desc) {
+export function og_render_sphere_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_plane_geometry(world, ptr0, len0);
+        const ret = wasm.og_render_sphere_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2707,13 +3708,13 @@ export function og_render_plane_geometry(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_ribbon(world, desc) {
+export function og_render_sprite(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_ribbon(world, ptr0, len0);
+        const ret = wasm.og_render_sprite(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2724,17 +3725,16 @@ export function og_render_ribbon(world, desc) {
 
 /**
  * @param {number} world
- * @param {number} material
- * @param {string} shader
+ * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_set_material_shader(world, material, shader) {
+export function og_render_standard_material(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(shader, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_set_material_shader(world, material, ptr0, len0);
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_standard_material(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2745,41 +3745,36 @@ export function og_render_set_material_shader(world, material, shader) {
 
 /**
  * @param {number} world
- * @param {number} material
- * @param {string} name
- * @param {string} value
+ * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_set_shader_param(world, material, name, value) {
-    let deferred3_0;
-    let deferred3_1;
+export function og_render_sweep_geometry(world, desc) {
+    let deferred2_0;
+    let deferred2_1;
     try {
-        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(value, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_set_shader_param(world, material, ptr0, len0, ptr1, len1);
-        deferred3_0 = ret[0];
-        deferred3_1 = ret[1];
+        var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ret = wasm.og_render_sweep_geometry(world, ptr0, len0);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
     } finally {
-        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
     }
 }
 
 /**
  * @param {number} world
- * @param {number} shader
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_shader_material(world, shader, desc) {
+export function og_render_tetrahedron_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_shader_material(world, shader, ptr0, len0);
+        const ret = wasm.og_render_tetrahedron_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2793,13 +3788,13 @@ export function og_render_shader_material(world, shader, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_sphere_geometry(world, desc) {
+export function og_render_text(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_sphere_geometry(world, ptr0, len0);
+        const ret = wasm.og_render_text(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2813,13 +3808,13 @@ export function og_render_sphere_geometry(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_sprite(world, desc) {
+export function og_render_torus_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_sprite(world, ptr0, len0);
+        const ret = wasm.og_render_torus_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2833,13 +3828,13 @@ export function og_render_sprite(world, desc) {
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_standard_material(world, desc) {
+export function og_render_tube_geometry(world, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_standard_material(world, ptr0, len0);
+        const ret = wasm.og_render_tube_geometry(world, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -2850,16 +3845,17 @@ export function og_render_standard_material(world, desc) {
 
 /**
  * @param {number} world
+ * @param {number} geometry
  * @param {string | null} [desc]
  * @returns {string}
  */
-export function og_render_text(world, desc) {
+export function og_render_update_geometry(world, geometry, desc) {
     let deferred2_0;
     let deferred2_1;
     try {
         var ptr0 = isLikeNone(desc) ? 0 : passStringToWasm0(desc, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         var len0 = WASM_VECTOR_LEN;
-        const ret = wasm.og_render_text(world, ptr0, len0);
+        const ret = wasm.og_render_update_geometry(world, geometry, ptr0, len0);
         deferred2_0 = ret[0];
         deferred2_1 = ret[1];
         return getStringFromWasm0(ret[0], ret[1]);
@@ -3004,6 +4000,45 @@ export function og_rng_stream_range(rng_stream, low, high) {
     return ret;
 }
 
+/**
+ * @param {number} engine
+ * @param {string} event
+ * @returns {boolean}
+ */
+export function og_room_deliver(engine, event) {
+    const ptr0 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.og_room_deliver(engine, ptr0, len0);
+    return ret !== 0;
+}
+
+/**
+ * @param {number} engine
+ * @param {string} info
+ */
+export function og_room_set_host(engine, info) {
+    const ptr0 = passStringToWasm0(info, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.og_room_set_host(engine, ptr0, len0);
+}
+
+/**
+ * @param {number} engine
+ * @returns {string}
+ */
+export function og_room_take(engine) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_room_take(engine);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {number} runtime_probe
  * @param {string} id
@@ -3492,6 +4527,97 @@ export function og_time_set_scale(world, scale) {
     }
 }
 
+/**
+ * @param {number} world
+ * @param {number} asset
+ * @returns {string}
+ */
+export function og_timeline_info(world, asset) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_info(world, asset);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_timeline_pause(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_pause(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_timeline_play(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_play(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @param {number} time
+ * @returns {string}
+ */
+export function og_timeline_seek(world, entity, time) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_seek(world, entity, time);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {number} world
+ * @param {number} entity
+ * @returns {string}
+ */
+export function og_timeline_stop(world, entity) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_timeline_stop(world, entity);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * @param {string} position
  * @param {string} quaternion
@@ -5382,6 +6508,38 @@ export function og_web_texture_target(engine, manifest, id, bytes) {
     }
 }
 
+/**
+ * The trace (og-runtime's `trace.rs`, the shell's `trace()`): turns the
+ * engine's trace on or off.
+ * @param {number} engine
+ * @param {boolean} on
+ */
+export function og_web_trace(engine, on) {
+    wasm.og_web_trace(engine, on);
+}
+
+/**
+ * The trace's spans since the last take, as JSON (`{ now, events }`, the
+ * events Chrome trace events on the engine's clock); `last` waits for the
+ * GPU's frames in flight where it can (natively only: the web's arrive in
+ * a later take).
+ * @param {number} engine
+ * @param {boolean} last
+ * @returns {string}
+ */
+export function og_web_trace_take(engine, last) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.og_web_trace_take(engine, last);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
 /**
  * Make one pipeline the engine's renderer has not used yet (og-render's
  * `Renderer::warm`): the engine Worker calls it in idle time behind the
@@ -6359,6 +7517,10 @@ function __wbg_get_imports(memory) {
         __wbg_end_b57473834b877409: function(arg0) {
             arg0.end();
         },
+        __wbg_features_5cac120c28ba0475: function(arg0) {
+            const ret = arg0.features;
+            return ret;
+        },
         __wbg_features_dec7bd2fd3d91bd6: function(arg0) {
             const ret = arg0.features;
             return ret;
@@ -6411,6 +7573,10 @@ function __wbg_get_imports(memory) {
         __wbg_frontFace_b064adb15b6f3772: function(arg0, arg1) {
             arg0.frontFace(arg1 >>> 0);
         },
+        __wbg_getBindGroupLayout_fb40c3b93d37f466: function(arg0, arg1) {
+            const ret = arg0.getBindGroupLayout(arg1 >>> 0);
+            return ret;
+        },
         __wbg_getBufferSubData_dd23246099b166d1: function(arg0, arg1, arg2, arg3) {
             arg0.getBufferSubData(arg1 >>> 0, arg2, arg3);
         },
@@ -6562,6 +7728,26 @@ function __wbg_get_imports(memory) {
             const ret = arg0.info;
             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 {
@@ -6760,6 +7946,13 @@ function __wbg_get_imports(memory) {
             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_minStorageBufferOffsetAlignment_5ba9b77792bdadb3: function(arg0) {
             const ret = arg0.minStorageBufferOffsetAlignment;
             return ret;
@@ -6880,12 +8073,19 @@ function __wbg_get_imports(memory) {
         __wbg_polygonOffset_8f922d9173d8849d: function(arg0, arg1, arg2) {
             arg0.polygonOffset(arg1, arg2);
         },
+        __wbg_popErrorScope_182b8e03671d81ef: function(arg0) {
+            const ret = arg0.popErrorScope();
+            return ret;
+        },
         __wbg_postMessage_46095c3ed2a3651d: function() { return handleError(function (arg0, arg1) {
             arg0.postMessage(arg1);
         }, arguments); },
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(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;
@@ -6987,6 +8187,9 @@ function __wbg_get_imports(memory) {
         __wbg_setVertexBuffer_cbf4ca1627c02f4c: function(arg0, arg1, arg2, arg3, arg4) {
             arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
         },
+        __wbg_setViewport_c0be08dcc8965ccf: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            arg0.setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
+        },
         __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(arg0, arg1, arg2);
             return ret;
@@ -7862,33 +9065,33 @@ function __wbg_get_imports(memory) {
             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: 2027, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2235, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___JsValue______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4362, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4635, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___JsValue__core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4364, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4637, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___js_sys_61cb8e1cd79b86e3___futures__task__wait_async_polyfill__MessageEvent______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2025, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("GPUDevice")], shim_idx: 2233, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2025, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__342);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("any")], shim_idx: 2233, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__403);
             return ret;
         },
         __wbindgen_generic_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2025, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__343);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("undefined")], shim_idx: 2233, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__404);
             return ret;
         },
         __wbindgen_generic_0000000000000007: function(arg0) {
@@ -7959,7 +9162,7 @@ function __wbg_get_imports(memory) {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        memory: memory || new WebAssembly.Memory({initial:39,maximum:32768,shared:true}),
+        memory: memory || new WebAssembly.Memory({initial:42,maximum:32768,shared:true}),
     };
     return {
         __proto__: null,
@@ -7982,22 +9185,22 @@ function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bin
     }
 }
 
-function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_(arg0, arg1, arg2);
+function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__342(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__342(arg0, arg1, arg2);
+function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__403(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__403(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__343(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_507ee5aabebc46c8___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__343(arg0, arg1, arg2);
+function wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__404(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_4274632476068e3f___convert__closures_____invoke___wasm_bindgen_4274632476068e3f___sys__JsNullable_wgpu_a740c3b21528c483___backend__webgpu__webgpu_sys__gen_GpuError__GpuError___core_f9975da687154ecd___result__Result_____wasm_bindgen_4274632476068e3f___JsError___true__404(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
@@ -8035,6 +9238,9 @@ const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equa
 const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
 
 
+const __wbindgen_enum_GpuErrorFilter = ["validation", "out-of-memory", "internal"];
+
+
 const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];