@defold-typescript/types 0.50.1 → 0.52.0

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

@@ -1,5 +1,5 @@
 /** @noSelfInFile */
-import type { Hash } from "../../../src/core-types";
+import type { Hash, Url } from "../../../src/core-types";
 
 declare global {
   /**
@@ -31,6 +31,8 @@ declare global {
      * - number `range_start`: the start offset into the requested file
      * - number `range_end`: the end offset into the requested file (inclusive)
      * - number `document_size`: the full size of the requested file
+     *
+     * With `report_progress` set, the callback also receives progress events carrying `bytes_sent`, `bytes_received`, `bytes_total` and `url` but no `status`; `response.bytes_received !== undefined` marks a progress event, since a final response never carries it.
      * @param headers - optional table with custom headers
      * @param post_data - optional data to send
      * @param options - optional table with request parameters. Supported entries:
@@ -70,7 +72,7 @@ declare global {
      * });
      * ```
      */
-    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;
+    function request(url: string, method: string, callback: (self: unknown, id: Hash, response: { status: number; url: string; response?: string; headers?: LuaMap<string, string>; path?: string; error?: string; bytes_sent?: number; bytes_received?: number; bytes_total?: number; range_start?: number; range_end?: number; document_size?: number }, sender: Url) => 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.1/image.d.ts

@@ -44,7 +44,7 @@ declare global {
      * }
      * ```
      */
-    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;
+    function get_astc_header(buffer: string): { width: number; height: number; depth: number; block_size_x: number; block_size_y: number; block_size_z: number };
     /**
      * Load image (PNG or JPEG) from buffer.
      *
@@ -77,7 +77,87 @@ declare global {
      * });
      * ```
      */
-    function load(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    function load(buffer: string): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    /**
+     * Load image (PNG or JPEG) from buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - An optional table containing parameters for loading the image. Supported entries:
+     *
+     * `premultiply_alpha`
+     * boolean True if alpha should be premultiplied into the color components. Defaults to `false`.
+     * `flip_vertically`
+     * boolean True if the image contents should be flipped vertically. Defaults to `false`.
+     * @returns object or `nil` if loading fails. The object is a table with the following fields:
+     *
+     * - number `width`: image width
+     * - number `height`: image height
+     * - constant `type`: image type
+     *   - `image.TYPE_RGB`
+     *   - `image.TYPE_RGBA`
+     *   - `image.TYPE_LUMINANCE`
+     *   - `image.TYPE_LUMINANCE_ALPHA`
+     * - string `buffer`: the raw image data
+     * @example
+     * ```ts
+     * // 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 = 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);
+     *   }
+     * });
+     * ```
+     */
+    function load(buffer: string, options: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: string } | undefined;
+    /**
+     * Load image (PNG or JPEG) from a string buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - An optional table containing parameters for loading the image. Supported entries:
+     *
+     * `premultiply_alpha`
+     * boolean True if alpha should be premultiplied into the color components. Defaults to `false`.
+     * `flip_vertically`
+     * boolean True if the image contents should be flipped vertically. Defaults to `false`.
+     * @returns object or `nil` if loading fails. The object is a table with the following fields:
+     *
+     * - number `width`: image width
+     * - number `height`: image height
+     * - constant `type`: image type
+     *   - `image.TYPE_RGB`
+     *   - `image.TYPE_RGBA`
+     *   - `image.TYPE_LUMINANCE`
+     *   - `image.TYPE_LUMINANCE_ALPHA`
+     * - buffer `buffer`: the script buffer that holds the decompressed image data. See buffer.create how to use the buffer.
+     * @example
+     * ```ts
+     * // 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 =
+     *     response.response !== undefined
+     *       ? image.load_buffer(response.response, { flip_vertically: true })
+     *       : undefined;
+     *   // the engine registers a texture format only when the driver supports it
+     *   const format = graphics.TEXTURE_FORMAT_RGBA;
+     *   if (img !== undefined && format !== undefined) {
+     *     const tparams = {
+     *       width: img.width,
+     *       height: img.height,
+     *       type: graphics.TEXTURE_TYPE_2D,
+     *       format,
+     *     };
+     *
+     *     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);
+     *   }
+     * });
+     * ```
+     */
+    function load_buffer(buffer: string): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> } } | undefined;
     /**
      * Load image (PNG or JPEG) from a string buffer.
      *
@@ -124,7 +204,7 @@ declare global {
      * });
      * ```
      */
-    function load_buffer(buffer: string, options?: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> } | undefined;
+    function load_buffer(buffer: string, options: { premultiply_alpha?: boolean; flip_vertically?: boolean }): { width: number; height: number; type: Opaque<"constant">; buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> } } | undefined;
   }
 }
 

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

@@ -47,10 +47,13 @@ import "../../../src/engine-globals";
 import "../../../src/msg-overloads";
 import "../../../src/message-guard";
 import "../../../src/window-event-guard";
+import "../../../src/physics-event-guard";
 import "../../../src/scene-addresses";
 import "../../../src/go-overloads";
 import "../../../src/component-properties";
 import "../../../src/render-overloads";
+import "../../../src/gui-overloads";
+import "../../../src/gui-texture-removal";
 import "../../../src/vmath-overloads";
 import "../../../src/sys-overloads";
 

package/generated/versions/defold-1.13.1/liveupdate.d.ts

@@ -38,6 +38,10 @@ declare global {
      * Memory wasn't allocated
      */
     const LIVEUPDATE_MEM_ERROR: number & { readonly __brand: "liveupdate.LIVEUPDATE_MEM_ERROR" };
+    /**
+     * Live update is not initialized. `liveupdate.add_mount` and `liveupdate.remove_mount` return it while live update is disabled.
+     */
+    const LIVEUPDATE_NOT_INITIALIZED: number & { readonly __brand: "liveupdate.LIVEUPDATE_NOT_INITIALIZED" };
     /**
      * LIVEUPDATE_OK
      */

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

@@ -217,6 +217,8 @@ declare global {
      * - `graphics.TEXTURE_USAGE_FLAG_STORAGE`
      * - `graphics.TEXTURE_USAGE_FLAG_INPUT`
      * - `graphics.TEXTURE_USAGE_FLAG_COLOR`
+     *
+     * Keyed by sampler slot from 1; a slot with no texture has no entry, so iterate with `for (const [slot, info] of textures)`.
      * @example
      * ```ts
      * // Get the textures from a material specified as a resource property
@@ -231,7 +233,7 @@ declare global {
      * });
      * ```
      */
-    function get_textures(path: Hash | string): { path: Hash; handle: Hash; width: number; height: number; depth: number; mipmaps: number; type: number; flags: number }[];
+    function get_textures(path: Hash | string): LuaMap<number, { path: Hash; handle: Hash; width: number; height: number; depth: number; mipmaps: number; type: number; flags: number }>;
     /**
      * Returns a table of all the vertex attributes in the material. This function will return all the vertex attributes
      * that are used in the vertex shader of the material.

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

@@ -155,10 +155,9 @@ declare global {
      * // How to play the "jump" animation followed by the "run" animation:
      * const url = msg.url("#model");
      *
-     * function anim_done(self: unknown, message_id: unknown, message: unknown, sender: unknown) {
+     * function anim_done(self: unknown, message_id: Hash, message: { animation_id: Hash }) {
      *   if (message_id === hash("model_animation_done")) {
-     *     const { animation_id } = message as { animation_id: Hash };
-     *     if (animation_id === hash("jump")) {
+     *     if (message.animation_id === hash("jump")) {
      *       // open animation done, chain with "run"
      *       const properties = { blend_duration: 0.2 };
      *       model.play_anim(url, "run", go.PLAYBACK_LOOP_FORWARD, properties, anim_done);
@@ -175,7 +174,7 @@ declare global {
      * });
      * ```
      */
-    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: go.Playback, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void): void;
+    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: go.Playback, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: Hash, message: BuiltinMessages["model_animation_done"]) => void): void;
     /**
      * Resets a shader constant for a model component.
      * The constant must be defined in the material assigned to the model.
@@ -229,7 +228,7 @@ declare global {
       /**
        * The current animation set on the component. The type of the property is hash.
        */
-      animation: Hash;
+      readonly animation: Hash;
       /**
        * The normalized animation cursor. The type of the property is number.
        * Please note that model events may not fire as expected when the cursor is manipulated directly.

package/generated/versions/defold-1.13.1/particlefx.d.ts

@@ -134,7 +134,28 @@ declare global {
      * });
      * ```
      */
-    function stop(url: string | Hash | Url, options?: { clear?: boolean }): void;
+    function stop(url: string | Hash | Url): void;
+    /**
+     * Stops a particle FX component from playing.
+     * Stopping a particle FX does not remove already spawned particles.
+     * Which particle FX to stop is identified by the URL.
+     *
+     * @param url - the particle fx that should stop playing
+     * @param options - Options when stopping the particle fx. Supported options:
+     *
+     * - boolean `clear`: instantly clear spawned particles
+     * @example
+     * ```ts
+     * // How to stop a particle fx when a game object is deleted and immediately also
+     * // clear any spawned particles:
+     * export default defineScript({
+     *   final(self) {
+     *     particlefx.stop("#particlefx", { clear: true });
+     *   },
+     * });
+     * ```
+     */
+    function stop(url: string | Hash | Url, options: { clear?: boolean }): void;
     interface properties {
       /**
        * The animation used during rendering by an emitter in a particle FX component.

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

@@ -200,7 +200,7 @@ declare global {
      * @returns It returns a list. If missed it returns `nil`. See ray_cast_response for details on the returned values.
      * @example
      * ```ts
-     * function handle_result(hit: { fraction: number; position: Vector3; normal: Vector3; id: Hash; group: Hash; request_id: number }) {
+     * function handle_result(hit: { fraction: number; position: Vector3; normal: Vector3; id: Hash; group: Hash }) {
      *   // act on the hit (see 'ray_cast_response')
      * }
      *
@@ -225,7 +225,7 @@ declare global {
      * });
      * ```
      */
-    function raycast(from: Vector3, to: Vector3, groups: Hash[], options?: { all?: boolean }): { fraction: number; position: Vector3; normal: Vector3; id: Hash; group: Hash; request_id: number }[] | undefined;
+    function raycast(from: Vector3, to: Vector3, groups: Hash[], options?: { all?: boolean }): Omit<BuiltinMessages["ray_cast_response"], "request_id">[] | Omit<BuiltinMessages["ray_cast_response"], "request_id"> | undefined;
     /**
      * Ray casts are used to test for intersections against collision objects in the physics world.
      * Collision objects of types kinematic, dynamic and static are tested against. Trigger objects
@@ -269,7 +269,51 @@ declare global {
      * });
      * ```
      */
-    function raycast_async(from: Vector3, to: Vector3, groups: Hash[], request_id?: number): void;
+    function raycast_async(from: Vector3, to: Vector3, groups: Hash[]): void;
+    /**
+     * Ray casts are used to test for intersections against collision objects in the physics world.
+     * Collision objects of types kinematic, dynamic and static are tested against. Trigger objects
+     * do not intersect with ray casts.
+     * Which collision objects to hit is filtered by their collision groups and can be configured
+     * through `groups`.
+     * The actual ray cast will be performed during the physics-update.
+     *
+     * - If an object is hit, the result will be reported via a ray_cast_response message.
+     * - If there is no object hit, the result will be reported via a ray_cast_missed message.
+     *
+     * NOTE: Ray casts will ignore collision objects that contain the starting point of the ray. This is a limitation in Box2D.
+     *
+     * @param from - the world position of the start of the ray
+     * @param to - the world position of the end of the ray
+     * @param groups - a lua table containing the hashed groups for which to test collisions against
+     * @param request_id - a number in range [0,255]. It will be sent back in the response for identification, 0 by default
+     * @example
+     * ```ts
+     * // How to perform a ray cast asynchronously:
+     * export default defineScript({
+     *   init() {
+     *     return { my_groups: [hash("my_group1"), hash("my_group2")] };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // request ray cast
+     *     const my_start = go.get_world_position();
+     *     const my_end = vmath.vector3(my_start.x, my_start.y - 100, my_start.z);
+     *     physics.raycast_async(my_start, my_end, self.my_groups);
+     *   },
+     *
+     *   on_message(self, message_id, message, sender) {
+     *     // check for the response
+     *     if (message_id === hash("ray_cast_response")) {
+     *       // act on the hit
+     *     } else if (message_id === hash("ray_cast_missed")) {
+     *       // act on the miss
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function raycast_async(from: Vector3, to: Vector3, groups: Hash[], request_id: number): void;
     /**
      * Only one physics world event listener can be set at a time.
      *

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

@@ -6,10 +6,12 @@ declare global {
    * Rendering API documentation
    */
   namespace render {
-    type constant_buffer = Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
+    type constant_buffer = Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<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;
+    type RenderTargetTextureType = typeof graphics.TEXTURE_TYPE_2D | typeof graphics.TEXTURE_TYPE_CUBE_MAP;
+    type RenderTargetParams = Record<string | number, unknown>;
     /**
      * The rendering context was lost. Rendering is paused and all graphics resources become invalid. Passed to the `render.set_listener` callback.
      */
@@ -104,7 +106,7 @@ declare global {
      * constants.light_colors[3] = vmath.vector4(1, 1, 1, 1);
      * ```
      */
-    function constant_buffer(): Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
+    function constant_buffer(): Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> };
     /**
      * Deletes a render target created by a render script.
      * You cannot delete a render target resource.
@@ -117,9 +119,12 @@ declare global {
      *     return { my_render_target: render.render_target("my_target", {}) };
      *   },
      *
-     *   final(self) {
-     *     // How to delete a render target:
-     *     render.delete_render_target(self.my_render_target);
+     *   // A render script has no final hook, so free the target on a message.
+     *   on_message(self, message_id) {
+     *     if (message_id === hash("release_target")) {
+     *       // How to delete a render target:
+     *       render.delete_render_target(self.my_render_target);
+     *     }
      *   },
      * });
      * ```
@@ -182,8 +187,11 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
      *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       format,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
      *     };
@@ -194,6 +202,7 @@ declare global {
      *   },
      *
      *   update(self, dt) {
+     *     if (self === undefined) return;
      *     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
      *     // material shader.
@@ -204,7 +213,7 @@ declare global {
      * });
      * ```
      */
-    function disable_texture(binding: Opaque<"texture"> | string | Hash | number): void;
+    function disable_texture(binding: 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
@@ -223,8 +232,11 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
      *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       format,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
      *     };
@@ -235,6 +247,7 @@ declare global {
      *   },
      *
      *   update(self, dt) {
+     *     if (self === undefined) return;
      *     render.set_compute("bloom");
      *     render.enable_texture(0, self.backing_texture);
      *     render.enable_texture(1, self.scene_rt);
@@ -251,7 +264,69 @@ declare global {
      * render.dispatch_compute(32, 32, 32, { constants });
      * ```
      */
-    function dispatch_compute(x: number, y: number, z: number, options?: { constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] } }): void;
+    function dispatch_compute(x: number, y: number, z: number, options?: { constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<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
+     * system constants buffer is used containing constants as defined in materials and set through
+     * go.set (or particlefx.set_constant) on visual components.
+     *
+     * @param predicate - predicate to draw for
+     * @param options - optional table with properties:
+     *
+     * `frustum`
+     * matrix4 A frustum matrix used to cull renderable items. (E.g. `local frustum = proj * view`). default=nil
+     * `frustum_planes`
+     * int Determines which sides of the frustum will be used. Default is render.FRUSTUM_PLANES_SIDES.
+     *
+     * - render.FRUSTUM_PLANES_SIDES : The left, right, top and bottom sides of the frustum.
+     * - render.FRUSTUM_PLANES_ALL : All 6 sides of the frustum.
+     *
+     * `constants`
+     * constant_buffer optional constants to use while rendering
+     * `sort_order`
+     * int How to sort draw order for world-ordered entries. Default uses the renderer's preferred world sorting (back-to-front).
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     // define a predicate matching anything with material tag "my_tag"
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // draw everything in the my_pred predicate
+     *     render.draw(self.my_pred);
+     *   },
+     * });
+     * ```
+     * @example
+     * Draw predicate with constants:
+     * ```ts
+     * function draw_tinted(self: { my_pred: Opaque<"render_predicate"> }) {
+     *   const constants = render.constant_buffer();
+     *   constants.tint = vmath.vector4(1, 1, 1, 1);
+     *   render.draw(self.my_pred, { constants });
+     * }
+     * ```
+     * @example
+     * Draw with predicate and frustum culling (without near+far planes):
+     * ```ts
+     * function draw_culled(self: { my_pred: Opaque<"render_predicate">; proj: Matrix4; view: Matrix4 }) {
+     *   const frustum = self.proj.mul(self.view);
+     *   render.draw(self.my_pred, { frustum });
+     * }
+     * ```
+     * @example
+     * Draw with predicate and frustum culling (with near+far planes):
+     * ```ts
+     * function draw_culled(self: { my_pred: Opaque<"render_predicate">; proj: Matrix4; view: Matrix4 }) {
+     *   const frustum = self.proj.mul(self.view);
+     *   render.draw(self.my_pred, { frustum, frustum_planes: render.FRUSTUM_PLANES_ALL });
+     * }
+     * ```
+     */
+    function draw(predicate: Opaque<"render_predicate">): 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
@@ -313,7 +388,7 @@ declare global {
      * }
      * ```
      */
-    function draw(predicate: Opaque<"render_predicate">, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] }; sort_order?: number }): void;
+    function draw(predicate: Opaque<"render_predicate">, options: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> }; sort_order?: number }): void;
     /**
      * Draws all 3d debug graphics such as lines drawn with "draw_line" messages and physics visualization.
      *
@@ -424,8 +499,11 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
      *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       format,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
      *     };
@@ -436,6 +514,7 @@ declare global {
      *   },
      *
      *   update(self, dt) {
+     *     if (self === undefined) return;
      *     // enable target so all drawing is done to it
      *     render.set_render_target(self.my_render_target);
      *
@@ -516,8 +595,11 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
      *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       format,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
      *     };
@@ -529,6 +611,7 @@ declare global {
      *   },
      *
      *   update(self, dt) {
+     *     if (self === undefined) return;
      *     // get the height of the render target color buffer
      *     const h = render.get_render_target_height(self.target_right, graphics.BUFFER_TYPE_COLOR0_BIT);
      *     // get the height of a render target resource
@@ -553,8 +636,11 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
      *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       format,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
      *     };
@@ -566,6 +652,7 @@ declare global {
      *   },
      *
      *   update(self, dt) {
+     *     if (self === undefined) return;
      *     // get the width of the render target color buffer
      *     const w = render.get_render_target_width(self.target_right, graphics.BUFFER_TYPE_COLOR0_BIT);
      *     // get the width of a render target resource
@@ -738,7 +825,7 @@ declare global {
      * render.set_blend_func_separate(graphics.BLEND_FACTOR_SRC_ALPHA, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, graphics.BLEND_FACTOR_ONE, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA);
      * ```
      */
-    function set_blend_func_separate(source_factor_color: number, destination_factor_color: number, source_factor_alpha: number, destination_factor_alpha: number): void;
+    function set_blend_func_separate(source_factor_color: graphics.BlendFactor, destination_factor_color: graphics.BlendFactor, source_factor_alpha: graphics.BlendFactor, destination_factor_alpha: graphics.BlendFactor): void;
     /**
      * Sets the current render camera to be used for rendering. If a render camera
      * has been set by the render script, the renderer will be using its projection and view matrix
@@ -969,8 +1056,86 @@ declare global {
      * // 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() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
+     *     const color_params = {
+     *       format,
+     *       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) {
+     *     if (self === undefined) return;
+     *     // set render target so all drawing is done to it
+     *     render.set_render_target(self.my_render_target, {
+     *       transient: [graphics.BUFFER_TYPE_DEPTH_BIT, graphics.BUFFER_TYPE_STENCIL_BIT],
+     *     });
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *
+     *     // set default render target. This also invalidates the depth and stencil buffers of the current target (self.my_render_target)
+     *     //  which can be an optimisation on some hardware
+     *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
+     *   },
+     * });
+     * ```
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // set render target by a render target resource identifier
+     *     render.set_render_target("my_rt_resource");
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *
+     *     // reset the render target to the default backbuffer
+     *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
+     *   },
+     * });
+     * ```
+     */
+    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT): void;
+    /**
+     * Sets a render target. Subsequent draw operations will be to the
+     * render target until it is replaced by a subsequent call to set_render_target.
+     * This function supports render targets created by a render script, or a render target resource.
+     *
+     * @param render_target - render target to set. render.RENDER_TARGET_DEFAULT to set the default render target
+     * @param options - optional table with behaviour parameters
+     *
+     * `transient`
+     * table Transient frame buffer types are only valid while the render target is active, i.e becomes undefined when a new target is set by a subsequent call to set_render_target.
+     * Default is all non-transient. Be aware that some hardware uses a combined depth stencil buffer and when this is the case both are considered non-transient if exclusively selected!
+     * A buffer type defined that doesn't exist in the render target is silently ignored.
+     *
+     * - `graphics.BUFFER_TYPE_COLOR0_BIT`
+     * - `graphics.BUFFER_TYPE_DEPTH_BIT`
+     * - `graphics.BUFFER_TYPE_STENCIL_BIT`
+     * @example
+     * 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
+     * ```ts
+     * // 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() {
+     *     // the engine registers a texture format only when the driver supports it
+     *     const format = graphics.TEXTURE_FORMAT_RGBA;
+     *     if (format === undefined) return undefined;
      *     const color_params = {
-     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       format,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
      *     };
@@ -981,6 +1146,7 @@ declare global {
      *   },
      *
      *   update(self, dt) {
+     *     if (self === undefined) return;
      *     // set render target so all drawing is done to it
      *     render.set_render_target(self.my_render_target, {
      *       transient: [graphics.BUFFER_TYPE_DEPTH_BIT, graphics.BUFFER_TYPE_STENCIL_BIT],
@@ -1015,7 +1181,7 @@ declare global {
      * });
      * ```
      */
-    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT, options?: { transient?: graphics.BufferType[] }): void;
+    function set_render_target(render_target: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT | undefined, 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.