@defold-typescript/types 0.5.4 → 0.6.0

package/generated/render.d.ts

@@ -2,6 +2,15 @@
 import type { Hash, Matrix4, Opaque, Url } from "../src/core-types";
 
 declare global {
+  /**
+   * Rendering functions, messages and constants. The "render" namespace is
+   * accessible only from render scripts.
+   * The rendering API was originally built on top of OpenGL ES 2.0, and it uses a subset of the
+   * OpenGL computer graphics rendering API for rendering 2D and 3D computer
+   * graphics. Our current target is OpenGLES 3.0 with fallbacks to 2.0 on some platforms.
+   * [icon:attention] It is possible to create materials and write shaders that
+   * require features not in OpenGL ES 2.0, but those will not work cross platform.
+   */
   namespace render {
     type constant_buffer = Opaque<"constant_buffer">;
     type render_target = Opaque<"render_target">;
@@ -30,9 +39,12 @@ declare global {
      * - `graphics.BUFFER_TYPE_DEPTH_BIT`
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @example
-     * ```lua
-     * Clear the color buffer and the depth buffer.
-     * render.clear({[graphics.BUFFER_TYPE_COLOR0_BIT] = vmath.vector4(0, 0, 0, 0), [graphics.BUFFER_TYPE_DEPTH_BIT] = 1})
+     * ```ts
+     * // Clear the color buffer and the depth buffer.
+     * render.clear({
+     *   [graphics.BUFFER_TYPE_COLOR0_BIT]: vmath.vector4(0, 0, 0, 0),
+     *   [graphics.BUFFER_TYPE_DEPTH_BIT]: 1,
+     * });
      * ```
      */
     function clear(buffers: Record<string | number, unknown>): void;
@@ -42,31 +54,31 @@ declare global {
      *
      * @returns new constant buffer
      * @example
-     * ```lua
-     * Set a "tint" constant in a constant buffer in the render script:
-     * local constants = render.constant_buffer()
-     * constants.tint = vmath.vector4(1, 1, 1, 1)
-     *
-     * Then use the constant buffer when drawing a predicate:
-     * render.draw(self.my_pred, {constants = constants})
-     *
-     * The constant buffer also supports array values by specifying constants in a table:
-     * local constants = render.constant_buffer()
-     * constants.light_colors    = {}
-     * constants.light_colors[1] = vmath.vector4(1, 0, 0, 1)
-     * constants.light_colors[2] = vmath.vector4(0, 1, 0, 1)
-     * constants.light_colors[3] = vmath.vector4(0, 0, 1, 1)
-     *
-     * You can also create the table by passing the vectors directly when creating the table:
-     * local constants = render.constant_buffer()
-     * constants.light_colors    = {
-     *      vmath.vector4(1, 0, 0, 1)
-     *      vmath.vector4(0, 1, 0, 1)
-     *      vmath.vector4(0, 0, 1, 1)
-     * }
-     *
-     * -- Add more constant to the array
-     * constants.light_colors[4] = vmath.vector4(1, 1, 1, 1)
+     * ```ts
+     * // Set a "tint" constant in a constant buffer in the render script:
+     * const constants = render.constant_buffer();
+     * constants.tint = vmath.vector4(1, 1, 1, 1);
+     *
+     * // Then use the constant buffer when drawing a predicate:
+     * render.draw(self.my_pred, { constants });
+     *
+     * // The constant buffer also supports array values by specifying constants in an array:
+     * const constants2 = render.constant_buffer();
+     * constants2.light_colors = [];
+     * constants2.light_colors[0] = vmath.vector4(1, 0, 0, 1);
+     * constants2.light_colors[1] = vmath.vector4(0, 1, 0, 1);
+     * constants2.light_colors[2] = vmath.vector4(0, 0, 1, 1);
+     *
+     * // You can also create the array by passing the vectors directly:
+     * const constants3 = render.constant_buffer();
+     * constants3.light_colors = [
+     *   vmath.vector4(1, 0, 0, 1),
+     *   vmath.vector4(0, 1, 0, 1),
+     *   vmath.vector4(0, 0, 1, 1),
+     * ];
+     *
+     * // Add more constants to the array
+     * constants3.light_colors[3] = vmath.vector4(1, 1, 1, 1);
      * ```
      */
     function constant_buffer(): Opaque<"constant_buffer">;
@@ -76,9 +88,9 @@ declare global {
      *
      * @param render_target - render target to delete
      * @example
-     * ```lua
-     * How to delete a render target:
-     *  render.delete_render_target(self.my_render_target)
+     * ```ts
+     * // How to delete a render target:
+     * render.delete_render_target(self.my_render_target);
      * ```
      */
     function delete_render_target(render_target: Opaque<"render_target">): void;
@@ -88,11 +100,11 @@ declare global {
      * in the "game.project" setting.
      *
      * @example
-     * ```lua
-     * Enable material named "glow", then draw my_pred with it.
-     * render.enable_material("glow")
-     * render.draw(self.my_pred)
-     * render.disable_material()
+     * ```ts
+     * // Enable material named "glow", then draw my_pred with it.
+     * render.enable_material("glow");
+     * render.draw(self.my_pred);
+     * render.disable_material();
      * ```
      */
     function disable_material(): void;
@@ -107,10 +119,10 @@ declare global {
      * - `graphics.STATE_CULL_FACE`
      * - `graphics.STATE_POLYGON_OFFSET_FILL`
      * @example
-     * ```lua
-     * Disable face culling when drawing the tile predicate:
-     * render.disable_state(graphics.STATE_CULL_FACE)
-     * render.draw(self.tile_pred)
+     * ```ts
+     * // Disable face culling when drawing the tile predicate:
+     * render.disable_state(graphics.STATE_CULL_FACE);
+     * render.draw(self.tile_pred);
      * ```
      */
     function disable_state(state: Opaque<"constant">): void;
@@ -119,15 +131,17 @@ declare global {
      *
      * @param binding - texture binding, either by texture unit, string or hash that should be disabled
      * @example
-     * ```lua
-     * function 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
-     *     -- material shader.
-     *     render.draw(self.my_pred)
-     *     -- done, disable the texture
-     *     render.disable_texture(0)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   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
+     *     // material shader.
+     *     render.draw(self.my_pred);
+     *     // done, disable the texture
+     *     render.disable_texture(0);
+     *   },
+     * });
      * ```
      */
     function disable_texture(binding: Opaque<"texture"> | string | Hash): void;
@@ -145,26 +159,32 @@ declare global {
      * `constants`
      * constant_buffer optional constants to use while rendering
      * @example
-     * ```lua
-     * function init(self)
-     *     local color_params = { format = graphics.TEXTURE_FORMAT_RGBA,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height()}
-     *     self.scene_rt = render.render_target({[graphics.BUFFER_TYPE_COLOR0_BIT] = color_params})
-     * end
-     *
-     * function update(self, dt)
-     *     render.set_compute("bloom")
-     *     render.enable_texture(0, self.backing_texture)
-     *     render.enable_texture(1, self.scene_rt)
-     *     render.dispatch_compute(128, 128, 1)
-     *     render.set_compute()
-     * end
-     *
-     * Dispatch a compute program with a constant buffer:
-     * local constants = render.constant_buffer()
-     * constants.tint = vmath.vector4(1, 1, 1, 1)
-     * render.dispatch_compute(32, 32, 32, {constants = constants})
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       scene_rt: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     render.set_compute("bloom");
+     *     render.enable_texture(0, self.backing_texture);
+     *     render.enable_texture(1, self.scene_rt);
+     *     render.dispatch_compute(128, 128, 1);
+     *     render.set_compute();
+     *   },
+     * });
+     *
+     * // Dispatch a compute program with a constant buffer:
+     * const constants = render.constant_buffer();
+     * constants.tint = vmath.vector4(1, 1, 1, 1);
+     * render.dispatch_compute(32, 32, 32, { constants });
      * ```
      */
     function dispatch_compute(x: number, y: number, z: number, options?: { constants?: Opaque<"constant_buffer"> }): void;
@@ -187,29 +207,31 @@ declare global {
      * `sort_order`
      * int How to sort draw order for world-ordered entries. Default uses the renderer's preferred world sorting (back-to-front).
      * @example
-     * ```lua
-     * function init(self)
-     *     -- define a predicate matching anything with material tag "my_tag"
-     *     self.my_pred = render.predicate({hash("my_tag")})
-     * end
-     *
-     * function update(self, dt)
-     *     -- draw everything in the my_pred predicate
-     *     render.draw(self.my_pred)
-     * end
-     *
-     * Draw predicate with constants:
-     * local constants = render.constant_buffer()
-     * constants.tint = vmath.vector4(1, 1, 1, 1)
-     * render.draw(self.my_pred, {constants = constants})
-     *
-     * Draw with predicate and frustum culling (without near+far planes):
-     * local frustum = self.proj * self.view
-     * render.draw(self.my_pred, {frustum = frustum})
-     *
-     * Draw with predicate and frustum culling (with near+far planes):
-     * local frustum = self.proj * self.view
-     * render.draw(self.my_pred, {frustum = frustum, frustum_planes = render.FRUSTUM_PLANES_ALL})
+     * ```ts
+     * export default defineScript({
+     *   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);
+     *   },
+     * });
+     *
+     * // Draw predicate with constants:
+     * const constants = render.constant_buffer();
+     * constants.tint = vmath.vector4(1, 1, 1, 1);
+     * render.draw(self.my_pred, { constants });
+     *
+     * // Draw with predicate and frustum culling (without near+far planes):
+     * const frustum = self.proj.mul(self.view);
+     * render.draw(self.my_pred, { frustum });
+     *
+     * // Draw with predicate and frustum culling (with near+far planes):
+     * const frustum2 = self.proj.mul(self.view);
+     * render.draw(self.my_pred, { frustum: frustum2, frustum_planes: render.FRUSTUM_PLANES_ALL });
      * ```
      */
     function draw(predicate: number, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer">; sort_order?: number }): void;
@@ -224,11 +246,13 @@ declare global {
      * - render.FRUSTUM_PLANES_SIDES : The left, right, top and bottom sides of the frustum.
      * - render.FRUSTUM_PLANES_ALL : All sides of the frustum.
      * @example
-     * ```lua
-     * function update(self, dt)
-     *     -- draw debug visualization
-     *     render.draw_debug3d()
-     * end
+     * ```ts
+     * export default defineScript({
+     *   update(self, dt) {
+     *     // draw debug visualization
+     *     render.draw_debug3d();
+     *   },
+     * });
      * ```
      */
     function draw_debug3d(options?: { frustum?: Matrix4; frustum_planes?: number }): void;
@@ -240,11 +264,11 @@ declare global {
      *
      * @param material_id - material id to enable
      * @example
-     * ```lua
-     * Enable material named "glow", then draw my_pred with it.
-     * render.enable_material("glow")
-     * render.draw(self.my_pred)
-     * render.disable_material()
+     * ```ts
+     * // Enable material named "glow", then draw my_pred with it.
+     * render.enable_material("glow");
+     * render.draw(self.my_pred);
+     * render.disable_material();
      * ```
      */
     function enable_material(material_id: string | Hash): void;
@@ -259,11 +283,11 @@ declare global {
      * - `graphics.STATE_CULL_FACE`
      * - `graphics.STATE_POLYGON_OFFSET_FILL`
      * @example
-     * ```lua
-     * Enable stencil test when drawing the gui predicate, then disable it:
-     * render.enable_state(graphics.STATE_STENCIL_TEST)
-     * render.draw(self.gui_pred)
-     * render.disable_state(graphics.STATE_STENCIL_TEST)
+     * ```ts
+     * // Enable stencil test when drawing the gui predicate, then disable it:
+     * render.enable_state(graphics.STATE_STENCIL_TEST);
+     * render.draw(self.gui_pred);
+     * render.disable_state(graphics.STATE_STENCIL_TEST);
      * ```
      */
     function enable_state(state: Opaque<"constant">): void;
@@ -294,41 +318,48 @@ declare global {
      * - `graphics.BUFFER_TYPE_COLOR2_BIT`
      * - `graphics.BUFFER_TYPE_COLOR3_BIT`
      * @example
-     * ```lua
-     * function update(self, dt)
-     *     -- enable target so all drawing is done to it
-     *     render.set_render_target(self.my_render_target)
-     *
-     *     -- draw a predicate to the render target
-     *     render.draw(self.my_pred)
-     *
-     *     -- disable target
-     *     render.set_render_target(render.RENDER_TARGET_DEFAULT)
-     *
-     *     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.
-     *     render.draw(self.my_pred)
-     * end
-     *
-     * function update(self, dt)
-     *     -- enable render target by resource id
-     *     render.set_render_target('my_rt_resource')
-     *     render.draw(self.my_pred)
-     *     render.set_render_target(render.RENDER_TARGET_DEFAULT)
-     *
-     *     render.enable_texture(0, 'my_rt_resource', graphics.BUFFER_TYPE_COLOR0_BIT)
-     *     -- draw a predicate with the render target available as texture 0 in the predicate
-     *     -- material shader.
-     *     render.draw(self.my_pred)
-     * end
-     *
-     * function update(self, dt)
-     *     -- bind a texture to the texture unit 0
-     *     render.enable_texture(0, self.my_texture_handle)
-     *     -- bind the same texture to a named sampler
-     *     render.enable_texture("my_texture_sampler", self.my_texture_handle)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   update(self, dt) {
+     *     // enable target so all drawing is done to it
+     *     render.set_render_target(self.my_render_target);
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *
+     *     // disable target
+     *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
+     *
+     *     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.
+     *     render.draw(self.my_pred);
+     *   },
+     * });
+     *
+     * // Or enable a render target by resource id:
+     * export default defineScript({
+     *   update(self, dt) {
+     *     render.set_render_target("my_rt_resource");
+     *     render.draw(self.my_pred);
+     *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
+     *
+     *     render.enable_texture(0, "my_rt_resource", graphics.BUFFER_TYPE_COLOR0_BIT);
+     *     // draw a predicate with the render target available as texture 0 in the predicate
+     *     // material shader.
+     *     render.draw(self.my_pred);
+     *   },
+     * });
+     *
+     * // Or bind a texture handle directly:
+     * export default defineScript({
+     *   update(self, dt) {
+     *     // bind a texture to the texture unit 0
+     *     render.enable_texture(0, self.my_texture_handle);
+     *     // bind the same texture to a named sampler
+     *     render.enable_texture("my_texture_sampler", self.my_texture_handle);
+     *   },
+     * });
      * ```
      */
     function enable_texture(binding: number | string | Hash, handle_or_name: Opaque<"texture"> | string | Hash, buffer_type?: number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR1_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR2_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR3_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }): void;
@@ -339,9 +370,9 @@ declare global {
      *
      * @returns specified window height
      * @example
-     * ```lua
-     * Get the height of the window
-     * local h = render.get_height()
+     * ```ts
+     * // Get the height of the window
+     * const h = render.get_height();
      * ```
      */
     function get_height(): number;
@@ -355,11 +386,11 @@ declare global {
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @returns the height of the render target buffer texture
      * @example
-     * ```lua
-     * -- get the height of the render target color buffer
-     * local h = render.get_render_target_height(self.target_right, graphics.BUFFER_TYPE_COLOR0_BIT)
-     * -- get the height of a render target resource
-     * local w = render.get_render_target_height('my_rt_resource', graphics.BUFFER_TYPE_COLOR0_BIT)
+     * ```ts
+     * // 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
+     * const w = render.get_render_target_height("my_rt_resource", graphics.BUFFER_TYPE_COLOR0_BIT);
      * ```
      */
     function get_render_target_height(render_target: Opaque<"render_target">, buffer_type: number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR1_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR2_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR3_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }): number;
@@ -374,11 +405,11 @@ declare global {
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @returns the width of the render target buffer texture
      * @example
-     * ```lua
-     * -- get the width of the render target color buffer
-     * local w = render.get_render_target_width(self.target_right, graphics.BUFFER_TYPE_COLOR0_BIT)
-     * -- get the width of a render target resource
-     * local w = render.get_render_target_width('my_rt_resource', graphics.BUFFER_TYPE_COLOR0_BIT)
+     * ```ts
+     * // 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
+     * const w2 = render.get_render_target_width("my_rt_resource", graphics.BUFFER_TYPE_COLOR0_BIT);
      * ```
      */
     function get_render_target_width(render_target: Opaque<"render_target">, buffer_type: number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR1_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR2_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR3_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }): number;
@@ -389,9 +420,9 @@ declare global {
      *
      * @returns specified window width (number)
      * @example
-     * ```lua
-     * Get the width of the window.
-     * local w = render.get_width()
+     * ```ts
+     * // Get the width of the window.
+     * const w = render.get_width();
      * ```
      */
     function get_width(): number;
@@ -402,9 +433,9 @@ declare global {
      *
      * @returns actual window height
      * @example
-     * ```lua
-     * Get the actual height of the window
-     * local h = render.get_window_height()
+     * ```ts
+     * // Get the actual height of the window
+     * const h = render.get_window_height();
      * ```
      */
     function get_window_height(): number;
@@ -415,9 +446,9 @@ declare global {
      *
      * @returns actual window width
      * @example
-     * ```lua
-     * Get the actual width of the window
-     * local w = render.get_window_width()
+     * ```ts
+     * // Get the actual width of the window
+     * const w = render.get_window_width();
      * ```
      */
     function get_window_width(): number;
@@ -431,10 +462,10 @@ declare global {
      * @param tags - table of tags that the predicate should match. The tags can be of either hash or string type
      * @returns new predicate
      * @example
-     * ```lua
-     * Create a new render predicate containing all visual objects that
-     * have a material with material tags "opaque" AND "smoke".
-     * local p = render.predicate({hash("opaque"), hash("smoke")})
+     * ```ts
+     * // Create a new render predicate containing all visual objects that
+     * // have a material with material tags "opaque" AND "smoke".
+     * const p = render.predicate([hash("opaque"), hash("smoke")]);
      * ```
      */
     function predicate(tags: Record<string | number, unknown>): number;
@@ -492,66 +523,86 @@ declare global {
      * @param parameters - table of buffer parameters, see the description for available keys and values
      * @returns new render target
      * @example
-     * ```lua
-     * How to create a new render target and draw to it:
-     * function init(self)
-     *     -- render target buffer parameters
-     *     local color_params = { format = graphics.TEXTURE_FORMAT_RGBA,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height(),
-     *                            min_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            mag_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                            v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *     local depth_params = { format = graphics.TEXTURE_FORMAT_DEPTH,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height(),
-     *                            u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                            v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *     self.my_render_target = render.render_target({[graphics.BUFFER_TYPE_COLOR0_BIT] = color_params, [graphics.BUFFER_TYPE_DEPTH_BIT] = depth_params })
-     * end
-     *
-     * function update(self, dt)
-     *     -- enable target so all drawing is done to it
-     *     render.set_render_target(self.my_render_target)
-     *
-     *     -- draw a predicate to the render target
-     *     render.draw(self.my_pred)
-     * end
-     *
-     * How to create a render target with multiple outputs:
-     * function init(self)
-     *     -- render target buffer parameters
-     *     local color_params_rgba = { format = graphics.TEXTURE_FORMAT_RGBA,
-     *                                 width = render.get_window_width(),
-     *                                 height = render.get_window_height(),
-     *                                 min_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                                 mag_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                                 u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                                 v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *     local color_params_float = { format = graphics.TEXTURE_FORMAT_RG32F,
-     *                            width = render.get_window_width(),
-     *                            height = render.get_window_height(),
-     *                            min_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            mag_filter = graphics.TEXTURE_FILTER_LINEAR,
-     *                            u_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *                            v_wrap = graphics.TEXTURE_WRAP_CLAMP_TO_EDGE }
-     *
-     *     -- Create a render target with three color attachments
-     *     -- Note: No depth buffer is attached here
-     *     self.my_render_target = render.render_target({
-     *            [graphics.BUFFER_TYPE_COLOR0_BIT] = color_params_rgba,
-     *            [graphics.BUFFER_TYPE_COLOR1_BIT] = color_params_rgba,
-     *            [graphics.BUFFER_TYPE_COLOR2_BIT] = color_params_float, })
-     * end
-     *
-     * function update(self, dt)
-     *     -- enable target so all drawing is done to it
-     *     render.enable_render_target(self.my_render_target)
-     *
-     *     -- draw a predicate to the render target
-     *     render.draw(self.my_pred)
-     * end
+     * ```ts
+     * // How to create a new render target and draw to it:
+     * export default defineScript({
+     *   init() {
+     *     // render target buffer parameters
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *     const depth_params = {
+     *       format: graphics.TEXTURE_FORMAT_DEPTH,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({
+     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params,
+     *         [graphics.BUFFER_TYPE_DEPTH_BIT]: depth_params,
+     *       }),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // enable target so all drawing is done to it
+     *     render.set_render_target(self.my_render_target);
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *   },
+     * });
+     *
+     * // How to create a render target with multiple outputs:
+     * export default defineScript({
+     *   init() {
+     *     // render target buffer parameters
+     *     const color_params_rgba = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *     const color_params_float = {
+     *       format: graphics.TEXTURE_FORMAT_RG32F,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
+     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
+     *     };
+     *
+     *     // Create a render target with three color attachments
+     *     // Note: No depth buffer is attached here
+     *     return {
+     *       my_render_target: render.render_target({
+     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params_rgba,
+     *         [graphics.BUFFER_TYPE_COLOR1_BIT]: color_params_rgba,
+     *         [graphics.BUFFER_TYPE_COLOR2_BIT]: color_params_float,
+     *       }),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // enable target so all drawing is done to it
+     *     render.enable_render_target(self.my_render_target);
+     *
+     *     // draw a predicate to the render target
+     *     render.draw(self.my_pred);
+     *   },
+     * });
      * ```
      */
     function render_target(name: string, parameters: Record<string | number, unknown>): Opaque<"render_target">;
@@ -614,9 +665,9 @@ declare global {
      * @param source_factor - source factor
      * @param destination_factor - destination factor
      * @example
-     * ```lua
-     * Set the blend func to the most common one:
-     * render.set_blend_func(graphics.BLEND_FACTOR_SRC_ALPHA, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA)
+     * ```ts
+     * // Set the blend func to the most common one:
+     * render.set_blend_func(graphics.BLEND_FACTOR_SRC_ALPHA, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA);
      * ```
      */
     function set_blend_func(source_factor: number, destination_factor: number): void;
@@ -634,18 +685,18 @@ declare global {
      * `use_frustum`
      * boolean If true, the renderer will use the cameras view-projection matrix for frustum culling (default: false)
      * @example
-     * ```lua
-     * Set the current camera to be used for rendering
-     * render.set_camera("main:/my_go#camera")
-     * render.draw(self.my_pred)
-     * render.set_camera(nil)
-     *
-     * Use the camera frustum for frustum culling together with a specific frustum plane option for the draw command
-     * -- The camera frustum will take precedence over the frustum plane option in render.draw
-     * render.set_camera("main:/my_go#camera", { use_frustum = true })
-     * -- However, we can still customize the frustum planes regardless of the camera option!
-     * render.draw(self.my_pred, { frustum_planes = render.FRUSTUM_PLANES_ALL })
-     * render.set_camera()
+     * ```ts
+     * // Set the current camera to be used for rendering
+     * render.set_camera("main:/my_go#camera");
+     * render.draw(self.my_pred);
+     * render.set_camera(undefined);
+     *
+     * // Use the camera frustum for frustum culling together with a specific frustum plane option for the draw command
+     * // The camera frustum will take precedence over the frustum plane option in render.draw
+     * render.set_camera("main:/my_go#camera", { use_frustum: true });
+     * // However, we can still customize the frustum planes regardless of the camera option!
+     * render.draw(self.my_pred, { frustum_planes: render.FRUSTUM_PLANES_ALL });
+     * render.set_camera();
      * ```
      */
     function set_camera(camera?: Url | number, options?: { use_frustum?: boolean }): void;
@@ -658,9 +709,9 @@ declare global {
      * @param blue - blue mask
      * @param alpha - alpha mask
      * @example
-     * ```lua
-     * -- alpha cannot be written to frame buffer
-     * render.set_color_mask(true, true, true, false)
+     * ```ts
+     * // alpha cannot be written to frame buffer
+     * render.set_color_mask(true, true, true, false);
      * ```
      */
     function set_color_mask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void;
@@ -671,12 +722,12 @@ declare global {
      *
      * @param compute - compute id to use, or nil to disable
      * @example
-     * ```lua
-     * Enable compute program named "fractals", then dispatch it.
-     * render.set_compute("fractals")
-     * render.enable_texture(0, self.backing_texture)
-     * render.dispatch_compute(128, 128, 1)
-     * render.set_compute()
+     * ```ts
+     * // Enable compute program named "fractals", then dispatch it.
+     * render.set_compute("fractals");
+     * render.enable_texture(0, self.backing_texture);
+     * render.dispatch_compute(128, 128, 1);
+     * render.set_compute();
      * ```
      */
     function set_compute(compute?: string | Hash): void;
@@ -692,10 +743,10 @@ declare global {
      * - `graphics.FACE_TYPE_BACK`
      * - `graphics.FACE_TYPE_FRONT_AND_BACK`
      * @example
-     * ```lua
-     * How to enable polygon culling and set front face culling:
-     * render.enable_state(graphics.STATE_CULL_FACE)
-     * render.set_cull_face(graphics.FACE_TYPE_FRONT)
+     * ```ts
+     * // How to enable polygon culling and set front face culling:
+     * render.enable_state(graphics.STATE_CULL_FACE);
+     * render.set_cull_face(graphics.FACE_TYPE_FRONT);
      * ```
      */
     function set_cull_face(face_type: number): void;
@@ -717,10 +768,10 @@ declare global {
      *
      * @param func - depth test function, see the description for available values
      * @example
-     * ```lua
-     * Enable depth test and set the depth test function to "not equal".
-     * render.enable_state(graphics.STATE_DEPTH_TEST)
-     * render.set_depth_func(graphics.COMPARE_FUNC_NOTEQUAL)
+     * ```ts
+     * // Enable depth test and set the depth test function to "not equal".
+     * render.enable_state(graphics.STATE_DEPTH_TEST);
+     * render.set_depth_func(graphics.COMPARE_FUNC_NOTEQUAL);
      * ```
      */
     function set_depth_func(func: number): void;
@@ -731,9 +782,9 @@ declare global {
      *
      * @param depth - depth mask
      * @example
-     * ```lua
-     * How to turn off writing to the depth buffer:
-     * render.set_depth_mask(false)
+     * ```ts
+     * // How to turn off writing to the depth buffer:
+     * render.set_depth_mask(false);
      * ```
      */
     function set_depth_mask(depth: boolean): void;
@@ -750,18 +801,20 @@ declare global {
      * `event_type`
      * string Rendering event. Possible values: `render.CONTEXT_EVENT_CONTEXT_LOST`, `render.CONTEXT_EVENT_CONTEXT_RESTORED`
      * @example
-     * ```lua
-     * Set listener and handle render context events.
-     * --- custom.render_script
-     * function init(self)
-     *    render.set_listener(function(self, event_type)
-     *        if event_type == render.CONTEXT_EVENT_CONTEXT_LOST then
-     *            --- Some stuff when rendering context is lost
-     *        elseif event_type == render.CONTEXT_EVENT_CONTEXT_RESTORED then
-     *            --- Start reload resources, reload game, etc.
-     *        end
-     *    end)
-     * end
+     * ```ts
+     * // Set listener and handle render context events.
+     * // custom.render_script
+     * export default defineScript({
+     *   init() {
+     *     render.set_listener((self, event_type) => {
+     *       if (event_type === render.CONTEXT_EVENT_CONTEXT_LOST) {
+     *         // Some stuff when rendering context is lost
+     *       } else if (event_type === render.CONTEXT_EVENT_CONTEXT_RESTORED) {
+     *         // Start reload resources, reload game, etc.
+     *       }
+     *     });
+     *   },
+     * });
      * ```
      */
     function set_listener(callback?: (self: unknown, event_type: unknown) => void): void;
@@ -787,9 +840,9 @@ declare global {
      * @param factor - polygon offset factor
      * @param units - polygon offset units
      * @example
-     * ```lua
-     * render.enable_state(graphics.STATE_POLYGON_OFFSET_FILL)
-     * render.set_polygon_offset(1.0, 1.0)
+     * ```ts
+     * render.enable_state(graphics.STATE_POLYGON_OFFSET_FILL);
+     * render.set_polygon_offset(1.0, 1.0);
      * ```
      */
     function set_polygon_offset(factor: number, units: number): void;
@@ -798,10 +851,10 @@ declare global {
      *
      * @param matrix - projection matrix
      * @example
-     * ```lua
-     * How to set the projection to orthographic with world origo at lower left,
-     * width and height as set in project settings and depth (z) between -1 and 1:
-     * render.set_projection(vmath.matrix4_orthographic(0, render.get_width(), 0, render.get_height(), -1, 1))
+     * ```ts
+     * // How to set the projection to orthographic with world origo at lower left,
+     * // width and height as set in project settings and depth (z) between -1 and 1:
+     * render.set_projection(vmath.matrix4_orthographic(0, render.get_width(), 0, render.get_height(), -1, 1));
      * ```
      */
     function set_projection(matrix: Matrix4): void;
@@ -820,33 +873,37 @@ declare global {
      * - `graphics.BUFFER_TYPE_DEPTH_BIT`
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @example
-     * ```lua
-     * 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
-     * function update(self, dt)
-     *     -- 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)
-     *
-     * end
-     *
-     * function 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)
-     *
-     * end
+     * ```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 defineScript({
+     *   update(self, dt) {
+     *     // 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);
+     *   },
+     * });
+     *
+     * // Or set the render target by a render target resource identifier:
+     * export default defineScript({
+     *   update(self, dt) {
+     *     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">, options?: { transient?: Record<string | number, unknown> }): void;
@@ -858,10 +915,10 @@ declare global {
      * @param width - new render target width
      * @param height - new render target height
      * @example
-     * ```lua
-     * Resize render targets to the current window size:
-     * render.set_render_target_size(self.my_render_target, render.get_window_width(), render.get_window_height())
-     * render.set_render_target_size('my_rt_resource', render.get_window_width(), render.get_window_height())
+     * ```ts
+     * // Resize render targets to the current window size:
+     * render.set_render_target_size(self.my_render_target, render.get_window_width(), render.get_window_height());
+     * render.set_render_target_size("my_rt_resource", render.get_window_width(), render.get_window_height());
      * ```
      */
     function set_render_target_size(render_target: Opaque<"render_target">, width: number, height: number): void;
@@ -893,9 +950,9 @@ declare global {
      * @param ref - reference value for the stencil test
      * @param mask - mask that is ANDed with both the reference value and the stored stencil value when the test is done
      * @example
-     * ```lua
-     * -- let only 0's pass the stencil test
-     * render.set_stencil_func(graphics.COMPARE_FUNC_EQUAL, 0, 1)
+     * ```ts
+     * // let only 0's pass the stencil test
+     * render.set_stencil_func(graphics.COMPARE_FUNC_EQUAL, 0, 1);
      * ```
      */
     function set_stencil_func(func: number, ref: number, mask: number): void;
@@ -910,9 +967,9 @@ declare global {
      *
      * @param mask - stencil mask
      * @example
-     * ```lua
-     * -- set the stencil mask to all 1:s
-     * render.set_stencil_mask(0xff)
+     * ```ts
+     * // set the stencil mask to all 1:s
+     * render.set_stencil_mask(0xff);
      * ```
      */
     function set_stencil_mask(mask: number): void;
@@ -941,12 +998,12 @@ declare global {
      * @param dpfail - the stencil action when the stencil test passes
      * @param dppass - the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled
      * @example
-     * ```lua
-     * Set the stencil function to never pass and operator to always draw 1's
-     * on test fail.
-     * render.set_stencil_func(graphics.COMPARE_FUNC_NEVER, 1, 0xFF)
-     * -- always draw 1's on test fail
-     * render.set_stencil_op(graphics.STENCIL_OP_REPLACE, graphics.STENCIL_OP_KEEP, graphics.STENCIL_OP_KEEP)
+     * ```ts
+     * // Set the stencil function to never pass and operator to always draw 1's
+     * // on test fail.
+     * render.set_stencil_func(graphics.COMPARE_FUNC_NEVER, 1, 0xFF);
+     * // always draw 1's on test fail
+     * render.set_stencil_op(graphics.STENCIL_OP_REPLACE, graphics.STENCIL_OP_KEEP, graphics.STENCIL_OP_KEEP);
      * ```
      */
     function set_stencil_op(sfail: number, dpfail: number, dppass: number): void;
@@ -955,27 +1012,31 @@ declare global {
      *
      * @param matrix - view matrix to set
      * @example
-     * ```lua
-     * How to set the view and projection matrices according to
-     * the values supplied by a camera.
-     * function init(self)
-     *   self.view = vmath.matrix4()
-     *   self.projection = vmath.matrix4()
-     * end
-     *
-     * function update(self, dt)
-     *   -- set the view to the stored view value
-     *   render.set_view(self.view)
-     *   -- now we can draw with this view
-     * end
-     *
-     * function on_message(self, message_id, message)
-     *   if message_id == hash("set_view_projection") then
-     *      -- camera view and projection arrives here.
-     *      self.view = message.view
-     *      self.projection = message.projection
-     *   end
-     * end
+     * ```ts
+     * // How to set the view and projection matrices according to
+     * // the values supplied by a camera.
+     * export default defineScript({
+     *   init() {
+     *     return {
+     *       view: vmath.matrix4(),
+     *       projection: vmath.matrix4(),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // set the view to the stored view value
+     *     render.set_view(self.view);
+     *     // now we can draw with this view
+     *   },
+     *
+     *   on_message(self, message_id, message) {
+     *     if (message_id === hash("set_view_projection")) {
+     *       // camera view and projection arrives here.
+     *       self.view = message.view;
+     *       self.projection = message.projection;
+     *     }
+     *   },
+     * });
      * ```
      */
     function set_view(matrix: Matrix4): void;
@@ -987,9 +1048,9 @@ declare global {
      * @param width - viewport width
      * @param height - viewport height
      * @example
-     * ```lua
-     * -- Set the viewport to the window dimensions.
-     * render.set_viewport(0, 0, render.get_window_width(), render.get_window_height())
+     * ```ts
+     * // Set the viewport to the window dimensions.
+     * render.set_viewport(0, 0, render.get_window_width(), render.get_window_height());
      * ```
      */
     function set_viewport(x: number, y: number, width: number, height: number): void;