@defold-typescript/types 0.39.0 → 0.40.0

package/generated/versions/defold-1.13.0/gui.d.ts

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Hash, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../../../src/core-types";
+import type { Hash, Matrix4, Opaque, Quaternion, Url, Vector, Vector3, Vector4 } from "../../../src/core-types";
 
 declare global {
   /**
@@ -622,15 +622,15 @@ declare global {
      * const node = gui.get_node("my_node");
      * // animate to new position
      * const pos = vmath.vector3(100, 100, 0);
-     * gui.animate(node, "position", pos, go.EASING_LINEAR, 2);
+     * gui.animate(node, "position", pos, gui.EASING_LINEAR, 2);
      * // ...
      * // cancel animation of the x component.
      * gui.cancel_animations(node, "position.x");
      *
      * // Cancels all property animations on a node in a single call:
      * // animate to new position and scale
-     * gui.animate(node, "position", vmath.vector3(100, 100, 0), go.EASING_LINEAR, 5);
-     * gui.animate(node, "scale", vmath.vector3(0.5), go.EASING_LINEAR, 5);
+     * gui.animate(node, "position", vmath.vector3(100, 100, 0), gui.EASING_LINEAR, 5);
+     * gui.animate(node, "scale", vmath.vector3(0.5), gui.EASING_LINEAR, 5);
      * // ...
      * // cancel positioning and scaling at once
      * gui.cancel_animations(node);
@@ -711,6 +711,10 @@ declare global {
      * @example
      * ```ts
      * export default defineScript({
+     *   init() {
+     *     return { some_value: 0 };
+     *   },
+     *
      *   final(self) {
      *     // report finalization
      *     msg.post("my_friend_instance", "im_dead", { my_stats: self.some_value });
@@ -758,7 +762,7 @@ declare global {
      * @param node - node to get the property for
      * @param property - the property to retrieve
      * @param options - optional options table (only applicable for material constants)
-     * - `index` number index into array property (1 based)
+     * - `index` number zero-based index into array property; the transpiler emits Defold's 1-based index
      * @example
      * ```ts
      * // Get properties on existing nodes:
@@ -1380,12 +1384,14 @@ declare global {
      * const size = 4;
      * const pos = vmath.vector3(200, 200, 0);
      * const path = "/assets/images/logo_4x4.astc";
-     * const buffer = sys.load_resource(path);
-     * const n = gui.new_box_node(pos, vmath.vector3(size, size, 0));
-     * // size is read from the .astc buffer
-     * // flip is not supported
-     * gui.new_texture(path, 0, 0, "astc", buffer, false);
-     * gui.set_texture(n, path);
+     * const [data] = sys.load_resource(path);
+     * if (data !== undefined) {
+     *   const n = gui.new_box_node(pos, vmath.vector3(size, size, 0));
+     *   // size is read from the .astc buffer
+     *   // flip is not supported
+     *   gui.new_texture(path, 0, 0, "astc", data, false);
+     *   gui.set_texture(n, path);
+     * }
      * ```
      */
     function new_texture(texture_id: string | Hash, width: number, height: number, type: string | Opaque<"constant">, buffer: string, flip?: boolean): LuaMultiReturn<[boolean, number]>;
@@ -1530,6 +1536,10 @@ declare global {
      * @example
      * ```ts
      * export default defineGuiScript({
+     *   init(): { my_value: number | undefined } {
+     *     return { my_value: undefined };
+     *   },
+     *
      *   on_input(self, action_id, action) {
      *     // check for input
      *     if (action_id === hash("my_action")) {
@@ -1563,6 +1573,10 @@ declare global {
      * @example
      * ```ts
      * export default defineGuiScript({
+     *   init() {
+     *     return { my_original_color: gui.get_color(gui.get_node("my_node")) };
+     *   },
+     *
      *   on_reload(self) {
      *     // restore some color (or similar)
      *     gui.set_color(gui.get_node("my_node"), self.my_original_color);
@@ -1745,13 +1759,13 @@ declare global {
      * @param property - the property to set
      * @param value - the property to set
      * @param options - optional options table (only applicable for material constants)
-     * - `index` number index into array property (1 based)
+     * - `index` number zero-based index into array property; the transpiler emits Defold's 1-based index
      * - `key` hash name of internal property
      * @example
      * ```ts
      * // Updates the position property on an existing node:
      * const node = gui.get_node("my_box_node");
-     * const node_position = gui.get(node, "position");
+     * const node_position = gui.get(node, "position") as Vector3;
      * gui.set(node, "position.x", node_position.x + 128);
      *
      * // Updates the rotation property on an existing node:
@@ -1768,23 +1782,23 @@ declare global {
      * // matrix4 is also supported
      * gui.set(node, "light_matrix", vmath.matrix4());
      * // update a constant in an array at position 4. the array is specified in the shader as:
-     * // uniform vec4 tint_array[4]; // lua is 1 based, shader is 0 based
-     * gui.set(node, "tint_array", vmath.vector4(1, 0, 0, 1), { index: 4 });
+     * // uniform vec4 tint_array[4]; // TypeScript and the shader are both 0 based
+     * gui.set(node, "tint_array", vmath.vector4(1, 0, 0, 1), { index: 3 });
      * // update a matrix constant in an array at position 4. the array is specified in the shader as:
      * // uniform mat4 light_matrix_array[4];
-     * gui.set(node, "light_matrix_array", vmath.matrix4(), { index: 4 });
+     * gui.set(node, "light_matrix_array", vmath.matrix4(), { index: 3 });
      * // update a sub-element in a constant
      * gui.set(node, "tint.x", 1);
      * // update a sub-element in an array constant at position 4
-     * gui.set(node, "tint_array.x", 1, { index: 4 });
+     * gui.set(node, "tint_array.x", 1, { index: 3 });
      *
      * // Set a named property
      * export default defineGuiScript({
      *   on_message(self, message_id, message) {
-     *     if (message_id === hash("set_font")) {
+     *     if (message_id === hash("set_font") && types.is_hash(message.font)) {
      *       gui.set(msg.url(), "fonts", message.font, { key: "my_font_name" });
      *       gui.set_font(gui.get_node("text"), "my_font_name");
-     *     } else if (message_id === hash("set_texture")) {
+     *     } else if (message_id === hash("set_texture") && types.is_hash(message.texture)) {
      *       gui.set(msg.url(), "textures", message.texture, { key: "my_texture" });
      *       gui.set_texture(gui.get_node("box"), "my_texture");
      *       gui.play_flipbook(gui.get_node("box"), "logo_256");
@@ -1793,7 +1807,7 @@ declare global {
      * });
      * ```
      */
-    function set(node: Opaque<"node"> | Url, property: string | Hash | gui.Property, value: number | Vector4 | Vector3 | Quaternion, options?: { index?: number; key?: Hash }): void;
+    function set(node: Opaque<"node"> | Url, property: string | Hash | gui.Property, value: number | Vector4 | Vector3 | Quaternion | Matrix4 | Hash, options?: { index?: number; key?: string | Hash }): void;
     /**
      * Sets the adjust mode on a node.
      * The adjust mode defines how the node will adjust itself to screen
@@ -2099,7 +2113,7 @@ declare global {
      * @param node - node to set the rotation for
      * @param rotation - new rotation
      */
-    function set_rotation(node: Opaque<"node">, rotation: Quaternion | Vector4): void;
+    function set_rotation(node: Opaque<"node">, rotation: Quaternion | Vector4 | Vector3): void;
     /**
      * Sets how the safe area is applied to this gui scene.
      *
@@ -2332,15 +2346,17 @@ declare global {
      * // in a counting fashion. It is assumed that the gui component receives messages
      * // from the game when a new score is to be shown.
      * export default defineGuiScript({
-     *   init(self) {
-     *     // fetch the score text node for later use (assumes it is called "score")
-     *     self.score_node = gui.get_node("score");
-     *     // keep track of the current score counted up so far
-     *     self.current_score = 0;
-     *     // keep track of the target score we should count up to
-     *     self.target_score = 0;
-     *     // how fast we will update the score, in score/second
-     *     self.score_update_speed = 1;
+     *   init() {
+     *     return {
+     *       // fetch the score text node for later use (assumes it is called "score")
+     *       score_node: gui.get_node("score"),
+     *       // keep track of the current score counted up so far
+     *       current_score: 0,
+     *       // keep track of the target score we should count up to
+     *       target_score: 0,
+     *       // how fast we will update the score, in score/second
+     *       score_update_speed: 1,
+     *     };
      *   },
      *
      *   update(self, dt) {
@@ -2359,7 +2375,7 @@ declare global {
      *
      *   on_message(self, message_id, message) {
      *     // check the message
-     *     if (message_id === hash("set_score")) {
+     *     if (message_id === hash("set_score") && typeof message.score === "number") {
      *       self.target_score = message.score;
      *     }
      *   },

package/generated/versions/defold-1.13.0/html5.d.ts

@@ -18,7 +18,9 @@ declare global {
      * const res = html5.run("10 + 20"); // returns the string "30"
      * print(res);
      * const res_num = tonumber(res); // convert to number
-     * print(res_num - 20); // prints 10
+     * if (res_num !== undefined) {
+     *   print(res_num - 20); // prints 10
+     * }
      * ```
      */
     function run(code: string): string;

package/generated/versions/defold-1.13.0/http.d.ts

@@ -1,4 +1,6 @@
 /** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
 declare global {
   /**
    * Functions for performing HTTP and HTTPS requests.
@@ -65,7 +67,7 @@ declare global {
      *       "http://www.google.com",
      *       "GET",
      *       (self, _id, response) => {
-     *         if (response.bytes_total !== undefined) {
+     *         if (response.bytes_received !== undefined && response.bytes_total !== undefined) {
      *           update_my_progress_bar(self, response.bytes_received / response.bytes_total);
      *         } else {
      *           print(response.status);
@@ -81,7 +83,7 @@ declare global {
      * });
      * ```
      */
-    function request(url: string, method: string, callback: (self: unknown, id: unknown, response: unknown) => void, headers?: LuaMap<string, string>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
+    function request(url: string, method: string, callback: (self: unknown, id: Hash, response: { status: number; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_received?: number; bytes_total?: number; range_start?: number; range_end?: number; document_size?: number }) => void, headers?: LuaMap<string, string> | Record<string, string>, post_data?: string, options?: { timeout?: number; path?: string; ignore_cache?: boolean; chunked_transfer?: boolean; report_progress?: boolean }): void;
   }
 }
 

package/generated/versions/defold-1.13.0/image.d.ts

@@ -43,8 +43,10 @@ declare global {
      * ```ts
      * // How to get the block size and dimensions from a .astc file
      * const [s] = sys.load_resource("/assets/cat.astc");
-     * const header = image.get_astc_header(s);
-     * pprint(s);
+     * if (s !== undefined) {
+     *   const header = image.get_astc_header(s);
+     *   pprint(s);
+     * }
      * ```
      */
     function get_astc_header(buffer: string): { width: number; height: number; depth: number; block_size_x: number; block_size_y: number; block_size_z: number } | undefined;
@@ -80,8 +82,10 @@ declare global {
      * // How to load an image from an URL and create a GUI texture from it:
      * const imgurl = "http://www.site.com/image.png";
      * http.request(imgurl, "GET", (self, id, response) => {
-     *   const img = image.load(response.response);
-     *   const tx = gui.new_texture("image_node", img.width, img.height, img.type, img.buffer);
+     *   const img = response.response !== undefined ? image.load(response.response) : undefined;
+     *   if (img !== undefined) {
+     *     const tx = gui.new_texture("image_node", img.width, img.height, img.type, img.buffer);
+     *   }
      * });
      * ```
      */
@@ -118,17 +122,22 @@ declare global {
      * // Load an image from an URL as a buffer and create a texture resource from it:
      * const imgurl = "http://www.site.com/image.png";
      * http.request(imgurl, "GET", (self, id, response) => {
-     *   const img = image.load_buffer(response.response, { flip_vertically: true });
-     *   const tparams = {
-     *     width: img.width,
-     *     height: img.height,
-     *     type: graphics.TEXTURE_TYPE_2D,
-     *     format: graphics.TEXTURE_FORMAT_RGBA,
-     *   };
-     *
-     *   const my_texture_id = resource.create_texture("/my_custom_texture.texturec", tparams, img.buffer);
-     *   // Apply the texture to a model
-     *   go.set("/go1#model", "texture0", my_texture_id);
+     *   const img =
+     *     response.response !== undefined
+     *       ? image.load_buffer(response.response, { flip_vertically: true })
+     *       : undefined;
+     *   if (img !== undefined) {
+     *     const tparams = {
+     *       width: img.width,
+     *       height: img.height,
+     *       type: graphics.TEXTURE_TYPE_2D,
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *     };
+     *
+     *     const my_texture_id = resource.create_texture("/my_custom_texture.texturec", tparams, img.buffer);
+     *     // Apply the texture to a model
+     *     go.set("/go1#model", "texture0", my_texture_id);
+     *   }
      * });
      * ```
      */

package/generated/versions/defold-1.13.0/index.d.ts

@@ -49,6 +49,7 @@ import "../../../src/message-guard";
 import "../../../src/window-event-guard";
 import "../../../src/scene-addresses";
 import "../../../src/go-overloads";
+import "../../../src/component-properties";
 import "../../../src/render-overloads";
 import "../../../src/vmath-overloads";
 

package/generated/versions/defold-1.13.0/material.d.ts

@@ -369,7 +369,7 @@ declare global {
      * material.set_textures(resource.material("/my_material.materialc"), { my_texture: resource.texture() });
      * ```
      */
-    function set_textures(path: Hash | string, textures: LuaMap<string, Hash>): void;
+    function set_textures(path: Hash | string, textures: LuaMap<string, Hash> | Record<string, Hash>): void;
     /**
      * Sets vertex attributes in a material, if the vertex attributes exist.
      *

package/generated/versions/defold-1.13.0/model.d.ts

@@ -87,11 +87,12 @@ declare global {
      * const game = { data: { weapons: { Sword: { damage: 10 } } } };
      *
      * export default defineScript({
-     *   init(self) {
+     *   init() {
      *     if (model.get_mesh_enabled("#model", "Sword")) {
      *       // set properties specific for the sword
-     *       self.weapon_properties = game.data.weapons["Sword"];
+     *       return { weapon_properties: game.data.weapons["Sword"] };
      *     }
+     *     return { weapon_properties: undefined };
      *   },
      * });
      * ```
@@ -243,7 +244,35 @@ declare global {
       /**
        * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
        */
-      textureN: Hash;
+      texture0: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture1: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture2: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture3: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture4: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture5: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture6: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture7: Hash;
     }
   }
 }

package/generated/versions/defold-1.13.0/physics.d.ts

@@ -70,7 +70,7 @@ declare global {
      *   init(self) {
      *     let gravity = physics.get_gravity();
      *     // Inverse gravity!
-     *     gravity = -gravity;
+     *     gravity = vmath.vector3(-gravity.x, -gravity.y, -gravity.z);
      *     physics.set_gravity(gravity);
      *   },
      * });
@@ -206,8 +206,8 @@ declare global {
      *
      * // How to perform a ray cast synchronously:
      * export default defineScript({
-     *   init(self) {
-     *     self.groups = [hash("world"), hash("enemy")];
+     *   init() {
+     *     return { groups: [hash("world"), hash("enemy")] };
      *   },
      *
      *   update(self, dt) {
@@ -247,8 +247,8 @@ declare global {
      * ```ts
      * // How to perform a ray cast asynchronously:
      * export default defineScript({
-     *   init(self) {
-     *     self.my_groups = [hash("my_group1"), hash("my_group2")];
+     *   init() {
+     *     return { my_groups: [hash("my_group1"), hash("my_group2")] };
      *   },
      *
      *   update(self, dt) {
@@ -414,9 +414,10 @@ declare global {
      * @example
      * ```ts
      * export default defineScript({
-     *   init(self) {
-     *     self.fliph = true; // set on some condition
-     *     physics.set_hflip("#collisionobject", self.fliph);
+     *   init() {
+     *     const fliph = true; // set on some condition
+     *     physics.set_hflip("#collisionobject", fliph);
+     *     return { fliph };
      *   },
      * });
      * ```
@@ -488,9 +489,10 @@ declare global {
      * @example
      * ```ts
      * export default defineScript({
-     *   init(self) {
-     *     self.flipv = true; // set on some condition
-     *     physics.set_vflip("#collisionobject", self.flipv);
+     *   init() {
+     *     const flipv = true; // set on some condition
+     *     physics.set_vflip("#collisionobject", flipv);
+     *     return { flipv };
      *   },
      * });
      * ```

package/generated/versions/defold-1.13.0/profiler.d.ts

@@ -128,7 +128,7 @@ declare global {
      * ```ts
      * // Show the last recorded frame
      * const recorded_frame_count = profiler.recorded_frame_count();
-     * profiler.view_recorded_frame(recorded_frame_count);
+     * profiler.view_recorded_frame({ frame: recorded_frame_count });
      * ```
      */
     function recorded_frame_count(): number;

package/generated/versions/defold-1.13.0/render.d.ts

@@ -6,7 +6,7 @@ declare global {
    * Rendering API documentation
    */
   namespace render {
-    type constant_buffer = Opaque<"constant_buffer">;
+    type constant_buffer = Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
     type render_target = Opaque<"render_target">;
     type texture = Opaque<"texture">;
     type ClearBufferKey = typeof graphics.BUFFER_TYPE_COLOR0_BIT | typeof graphics.BUFFER_TYPE_DEPTH_BIT | typeof graphics.BUFFER_TYPE_STENCIL_BIT;
@@ -87,7 +87,7 @@ declare global {
      * });
      * ```
      */
-    function constant_buffer(): Opaque<"constant_buffer">;
+    function constant_buffer(): Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
     /**
      * Deletes a render target created by a render script.
      * You cannot delete a render target resource.
@@ -169,6 +169,18 @@ declare global {
      * @example
      * ```ts
      * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
      *   update(self, dt) {
      *     render.enable_texture(0, self.my_render_target, graphics.BUFFER_TYPE_COLOR0_BIT);
      *     // draw a predicate with the render target available as texture 0 in the predicate
@@ -180,7 +192,7 @@ declare global {
      * });
      * ```
      */
-    function disable_texture(binding: Opaque<"texture"> | string | Hash): void;
+    function disable_texture(binding: Opaque<"texture"> | string | Hash | number): void;
     /**
      * Dispatches the currently enabled compute program. The dispatch call takes three arguments x,y,z which constitutes
      * the 'global working group' of the compute dispatch. Together with the 'local working group' specified in the compute shader
@@ -205,6 +217,7 @@ declare global {
      *       height: render.get_window_height(),
      *     };
      *     return {
+     *       backing_texture: resource.get_texture_info("/main/backing.texturec").handle,
      *       scene_rt: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
      *     };
      *   },
@@ -224,7 +237,7 @@ declare global {
      * render.dispatch_compute(32, 32, 32, { constants });
      * ```
      */
-    function dispatch_compute(x: number, y: number, z: number, options?: { constants?: Opaque<"constant_buffer"> }): void;
+    function dispatch_compute(x: number, y: number, z: number, options?: { constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] } }): void;
     /**
      * Draws all objects that match a specified predicate. An optional constant buffer can be
      * provided to override the default constants. If no constants buffer is provided, a default
@@ -251,8 +264,12 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
-     *     // define a predicate matching anything with material tag "my_tag"
-     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *     return {
+     *       // define a predicate matching anything with material tag "my_tag"
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *       proj: vmath.matrix4_perspective(math.rad(45), render.get_window_width() / render.get_window_height(), 0.1, 1000),
+     *       view: vmath.matrix4_look_at(vmath.vector3(0, 0, 10), vmath.vector3(0, 0, 0), vmath.vector3(0, 1, 0)),
+     *     };
      *   },
      *
      *   update(self, dt) {
@@ -275,7 +292,7 @@ declare global {
      * });
      * ```
      */
-    function draw(predicate: number, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer">; sort_order?: number }): void;
+    function draw(predicate: number, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] }; sort_order?: number }): void;
     /**
      * Draws all 3d debug graphics such as lines drawn with "draw_line" messages and physics visualization.
      *
@@ -395,6 +412,18 @@ declare global {
      * @example
      * ```ts
      * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
      *   update(self, dt) {
      *     // enable target so all drawing is done to it
      *     render.set_render_target(self.my_render_target);
@@ -416,6 +445,10 @@ declare global {
      * ```ts
      * // Or enable a render target by resource id:
      * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
      *   update(self, dt) {
      *     render.set_render_target("my_rt_resource");
      *     render.draw(self.my_pred);
@@ -432,6 +465,10 @@ declare global {
      * ```ts
      * // Or bind a texture handle directly:
      * export default defineRenderScript({
+     *   init() {
+     *     return { my_texture_handle: resource.get_texture_info("/main/my_texture.texturec").handle };
+     *   },
+     *
      *   update(self, dt) {
      *     // bind a texture to the texture unit 0
      *     render.enable_texture(0, self.my_texture_handle);
@@ -441,7 +478,7 @@ declare global {
      * });
      * ```
      */
-    function enable_texture(binding: number | string | Hash, handle_or_name: Opaque<"texture"> | string | Hash, buffer_type?: graphics.BufferType): void;
+    function enable_texture(binding: number | string | Hash, handle_or_name: Opaque<"texture"> | string | Hash | Opaque<"render_target"> | number, buffer_type?: graphics.BufferType): void;
     /**
      * Returns the logical window height that is set in the "game.project" settings.
      * Note that the actual window pixel size can change, either by device constraints
@@ -497,7 +534,7 @@ declare global {
      * });
      * ```
      */
-    function get_render_target_height(render_target: Opaque<"render_target">, buffer_type: graphics.BufferType): number;
+    function get_render_target_height(render_target: Opaque<"render_target"> | string | Hash, buffer_type: graphics.BufferType): number;
     /**
      * Returns the specified buffer width from a render target.
      *
@@ -542,7 +579,7 @@ declare global {
      * });
      * ```
      */
-    function get_render_target_width(render_target: Opaque<"render_target">, buffer_type: graphics.BufferType): number;
+    function get_render_target_width(render_target: Opaque<"render_target"> | string | Hash, buffer_type: graphics.BufferType): number;
     /**
      * Returns the logical window width that is set in the "game.project" settings.
      * Note that the actual window pixel size can change, either by device constraints
@@ -747,7 +784,7 @@ declare global {
      * });
      * ```
      */
-    function set_camera(camera?: Url | number, options?: { use_frustum?: boolean }): void;
+    function set_camera(camera?: Url | number | string, options?: { use_frustum?: boolean }): void;
     /**
      * Specifies whether the individual color components in the frame buffer is enabled for writing (`true`) or disabled (`false`). For example, if `blue` is `false`, nothing is written to the blue component of any pixel in any of the color buffers, regardless of the drawing operation attempted. Note that writing are either enabled or disabled for entire color components, not the individual bits of a component.
      * The component masks are all initially `true`.
@@ -897,7 +934,7 @@ declare global {
      * offset for each polygon. The initial value is `0`.
      * `units` is multiplied by an implementation-specific value to create a
      * constant depth offset. The initial value is `0`.
-     * The value of the offset is computed as `factor` &times; `DZ` + `r` &times; `units`
+     * The value of the offset is computed as `factor` × `DZ` + `r` × `units`
      * `DZ` is a measurement of the depth slope of the polygon which is the change in z (depth)
      * values divided by the change in either x or y coordinates, as you traverse a polygon.
      * The depth values are in window coordinates, clamped to the range [0, 1].
@@ -952,6 +989,18 @@ declare global {
      * // How to set a render target and draw to it and then switch back to the default render target
      * // The render target defines the depth/stencil buffers as transient, when set_render_target is called the next time the buffers may be invalidated and allow for optimisations depending on driver support
      * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
      *   update(self, dt) {
      *     // set render target so all drawing is done to it
      *     render.set_render_target(self.my_render_target, {
@@ -971,6 +1020,10 @@ declare global {
      * ```ts
      * // Or set the render target by a render target resource identifier:
      * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
      *   update(self, dt) {
      *     render.set_render_target("my_rt_resource");
      *
@@ -983,7 +1036,7 @@ declare global {
      * });
      * ```
      */
-    function set_render_target(render_target: Opaque<"render_target">, options?: { transient?: Record<string | number, unknown> }): void;
+    function set_render_target(render_target: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT, options?: { transient?: graphics.BufferType[] }): void;
     /**
      * Sets the render target size for a render target created from
      * either a render script, or from a render target resource.
@@ -1006,7 +1059,7 @@ declare global {
      * });
      * ```
      */
-    function set_render_target_size(render_target: Opaque<"render_target">, width: number, height: number): void;
+    function set_render_target_size(render_target: Opaque<"render_target"> | string | Hash, width: number, height: number): void;
     /**
      * Stenciling is similar to depth-buffering as it enables and disables drawing on a
      * per-pixel basis. First, GL drawing primitives are drawn into the stencil planes.
@@ -1132,7 +1185,11 @@ declare global {
      *   },
      *
      *   on_message(self, message_id, message) {
-     *     if (message_id === hash("set_view_projection")) {
+     *     if (
+     *       message_id === hash("set_view_projection") &&
+     *       types.is_matrix4(message.view) &&
+     *       types.is_matrix4(message.projection)
+     *     ) {
      *       // camera view and projection arrives here.
      *       self.view = message.view;
      *       self.projection = message.projection;