@defold-typescript/types 0.50.1 → 0.52.0

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

@@ -54,7 +54,7 @@ declare global {
       /**
        * Script buffer containing the decompressed image data.
        */
-      buffer: Opaque<"buffer">;
+      buffer: Opaque<"buffer"> & { length: LuaLengthMethod<number> };
     }
     /**
      * Image loading options
@@ -122,7 +122,7 @@ declare global {
      * }
      * ```
      */
-    function get_astc_header(buffer: string): image.astc_header | undefined;
+    function get_astc_header(buffer: string): image.astc_header;
     /**
      * Load image (PNG or JPEG) from buffer.
      *
@@ -141,7 +141,59 @@ declare global {
      * });
      * ```
      */
-    function load(buffer: string, options?: boolean | image.load_options): image.load_result | undefined;
+    function load(buffer: string): image.load_result | undefined;
+    /**
+     * Load image (PNG or JPEG) from buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - Optional loading parameters. A boolean is accepted for backwards compatibility and controls `premultiply_alpha`.
+     * @returns loaded image, or `nil` if loading fails
+     * @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: boolean | image.load_options): image.load_result | undefined;
+    /**
+     * Load image (PNG or JPEG) from a string buffer.
+     *
+     * @param buffer - image data buffer
+     * @param options - Optional loading parameters. A boolean is accepted for backwards compatibility and controls `premultiply_alpha`.
+     * @returns loaded image, or `nil` if loading fails
+     * @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): image.load_buffer_result | undefined;
     /**
      * Load image (PNG or JPEG) from a string buffer.
      *
@@ -174,7 +226,7 @@ declare global {
      * });
      * ```
      */
-    function load_buffer(buffer: string, options?: boolean | image.load_options): image.load_buffer_result | undefined;
+    function load_buffer(buffer: string, options: boolean | image.load_options): image.load_buffer_result | undefined;
   }
 }
 

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

@@ -53,10 +53,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.2/liveupdate.d.ts

@@ -6,7 +6,7 @@ declare global {
    * Functions and constants to access resources.
    */
   namespace liveupdate {
-    type LIVEUPDATE = typeof liveupdate.LIVEUPDATE_BUNDLED_RESOURCE_MISMATCH | typeof liveupdate.LIVEUPDATE_ENGINE_VERSION_MISMATCH | typeof liveupdate.LIVEUPDATE_FORMAT_ERROR | typeof liveupdate.LIVEUPDATE_INVAL | typeof liveupdate.LIVEUPDATE_INVALID_HEADER | typeof liveupdate.LIVEUPDATE_INVALID_RESOURCE | typeof liveupdate.LIVEUPDATE_IO_ERROR | typeof liveupdate.LIVEUPDATE_MEM_ERROR | typeof liveupdate.LIVEUPDATE_OK | typeof liveupdate.LIVEUPDATE_SCHEME_MISMATCH | typeof liveupdate.LIVEUPDATE_SIGNATURE_MISMATCH | typeof liveupdate.LIVEUPDATE_UNKNOWN | typeof liveupdate.LIVEUPDATE_VERSION_MISMATCH;
+    type LIVEUPDATE = typeof liveupdate.LIVEUPDATE_BUNDLED_RESOURCE_MISMATCH | typeof liveupdate.LIVEUPDATE_ENGINE_VERSION_MISMATCH | typeof liveupdate.LIVEUPDATE_FORMAT_ERROR | typeof liveupdate.LIVEUPDATE_INVAL | typeof liveupdate.LIVEUPDATE_INVALID_HEADER | typeof liveupdate.LIVEUPDATE_INVALID_RESOURCE | typeof liveupdate.LIVEUPDATE_IO_ERROR | typeof liveupdate.LIVEUPDATE_MEM_ERROR | typeof liveupdate.LIVEUPDATE_OK | typeof liveupdate.LIVEUPDATE_SCHEME_MISMATCH | typeof liveupdate.LIVEUPDATE_SIGNATURE_MISMATCH | typeof liveupdate.LIVEUPDATE_UNKNOWN | typeof liveupdate.LIVEUPDATE_VERSION_MISMATCH | typeof liveupdate.LIVEUPDATE_NOT_INITIALIZED;
     /**
      * Mismatch between between expected bundled resources and actual bundled resources. The manifest expects a resource to be in the bundle, but it was not found in the bundle. This is typically the case when a non-excluded resource was modified between publishing the bundle and publishing the manifest.
      */
@@ -39,6 +39,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" };
     /**
      * Operation completed successfully.
      */

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

@@ -78,7 +78,7 @@ declare global {
       /**
        * Sampler texture type.
        */
-      type: graphics.TEXTURE_TYPE;
+      type: graphics.TEXTURE_TYPE | 6 | 7 | 8 | 9 | 10;
       /**
        * Horizontal wrap mode.
        */
@@ -348,7 +348,7 @@ declare global {
      * Returns a table of all the textures from the material.
      *
      * @param path - The path to the resource
-     * @returns material texture information
+     * @returns material texture information. 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
@@ -363,7 +363,7 @@ declare global {
      * });
      * ```
      */
-    function get_textures(path: Hash | string): material.texture_info[];
+    function get_textures(path: Hash | string): LuaMap<number, material.texture_info>;
     /**
      * 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.2/model.d.ts

@@ -164,10 +164,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);
@@ -184,7 +183,7 @@ declare global {
      * });
      * ```
      */
-    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: go.PLAYBACK, play_properties?: model.play_properties, complete_function?: (self: unknown, message_id: Hash, message: BuiltinMessages["model_animation_done"], sender: Url) => void): void;
+    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: go.PLAYBACK, play_properties?: model.play_properties, 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.
@@ -238,7 +237,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.2/particlefx.d.ts

@@ -128,7 +128,26 @@ declare global {
      * });
      * ```
      */
-    function stop(url: string | Hash | Url, options?: particlefx.stop_options): 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 used when stopping the particle fx
+     * @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: particlefx.stop_options): void;
     interface properties {
       /**
        * The animation used during rendering by an emitter in a particle FX component.

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

@@ -6,7 +6,7 @@ declare global {
    * Collision object physics API documentation
    */
   namespace physics {
-    type event = BuiltinMessages["contact_point_event"] | BuiltinMessages["collision_event"] | BuiltinMessages["trigger_event"] | BuiltinMessages["ray_cast_response"] | BuiltinMessages["ray_cast_missed"];
+    type event = BuiltinMessages["contact_point_event"] & { type: Hash<"contact_point_event"> } | BuiltinMessages["collision_event"] & { type: Hash<"collision_event"> } | BuiltinMessages["trigger_event"] & { type: Hash<"trigger_event"> } | BuiltinMessages["ray_cast_response"] & { type: Hash<"ray_cast_response"> } | BuiltinMessages["ray_cast_missed"] & { type: Hash<"ray_cast_missed"> };
     /**
      * The available fields depend on the joint type.
      */
@@ -366,7 +366,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')
      * }
      *
@@ -391,7 +391,7 @@ declare global {
      * });
      * ```
      */
-    function raycast(from: Vector3, to: Vector3, groups: Hash[], options?: physics.raycast_options): BuiltinMessages["ray_cast_response"][] | BuiltinMessages["ray_cast_response"] | undefined;
+    function raycast(from: Vector3, to: Vector3, groups: Hash[], options?: physics.raycast_options): 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
@@ -435,7 +435,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.2/render.d.ts

@@ -15,7 +15,7 @@ declare global {
        */
       use_frustum?: boolean;
     }
-    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> };
     /**
      * Debug-draw options
      */
@@ -36,7 +36,7 @@ declare global {
       /**
        * Constants used by the compute program. The values are copied when `render.dispatch_compute()` is called.
        */
-      constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
+      constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> };
     }
     /**
      * Render draw options
@@ -53,13 +53,13 @@ declare global {
       /**
        * Constants used while rendering. The values are copied when `render.draw()` is called.
        */
-      constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
+      constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | ConstantArray<Vector4> | ConstantArray<Matrix4> };
       /**
        * World-entry sort order. The default is the renderer's preferred back-to-front order.
        */
       sort_order?: render.SORT;
     }
-    type render_predicate = number;
+    type render_predicate = Opaque<"render_predicate">;
     type render_target = Opaque<"render_target">;
     /**
      * Render-target attachment parameters
@@ -114,6 +114,8 @@ declare global {
     }
     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 = render.render_target_params;
     type CONTEXT_EVENT = typeof render.CONTEXT_EVENT_CONTEXT_LOST | typeof render.CONTEXT_EVENT_CONTEXT_RESTORED;
     type FRUSTUM_PLANES = typeof render.FRUSTUM_PLANES_ALL | typeof render.FRUSTUM_PLANES_SIDES;
     type RENDER_TARGET_FLAG = typeof render.TEXTURE_BIT;
@@ -218,7 +220,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.
@@ -231,9 +233,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);
+     *     }
      *   },
      * });
      * ```
@@ -287,7 +292,7 @@ declare global {
      * });
      * ```
      */
-    function disable_state(state: graphics.STATE): void;
+    function disable_state(state: graphics.State): void;
     /**
      * Disables a texture that has previourly been enabled.
      *
@@ -296,8 +301,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(),
      *     };
@@ -308,6 +316,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.
@@ -318,7 +327,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
@@ -334,8 +343,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(),
      *     };
@@ -346,6 +358,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);
@@ -411,7 +424,56 @@ declare global {
      * }
      * ```
      */
-    function draw(predicate: Opaque<"render_predicate">, options?: render.draw_options): void;
+    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
+     * 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 draw options
+     * @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">, options: render.draw_options): void;
     /**
      * Draws all 3d debug graphics such as lines drawn with "draw_line" messages and physics visualization.
      *
@@ -478,7 +540,7 @@ declare global {
      * });
      * ```
      */
-    function enable_state(state: graphics.STATE): void;
+    function enable_state(state: graphics.State): void;
     /**
      * Sets the specified texture handle for a render target attachment or a regular texture
      * that should be used for rendering. The texture can be bound to either a texture unit
@@ -499,8 +561,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(),
      *     };
@@ -511,6 +576,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);
      *
@@ -591,8 +657,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(),
      *     };
@@ -604,6 +673,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
@@ -628,8 +698,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(),
      *     };
@@ -641,6 +714,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
@@ -763,7 +837,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
@@ -959,8 +1033,77 @@ 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. Omit it, pass `nil`, or use render.RENDER_TARGET_DEFAULT to set the default render target
+     * @param options - optional render-target activation options
+     * @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(),
      *     };
@@ -971,6 +1114,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],
@@ -1005,7 +1149,7 @@ declare global {
      * });
      * ```
      */
-    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT, options?: render.set_render_target_options): void;
+    function set_render_target(render_target: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT | undefined, options: render.set_render_target_options): void;
     /**
      * Sets the render target size for a render target created from
      * either a render script, or from a render target resource.