@defold-typescript/types 0.39.0 → 0.41.0

package/generated/render.d.ts

@@ -6,13 +6,135 @@ declare global {
    * Rendering API documentation
    */
   namespace render {
-    type constant_buffer = Opaque<"constant_buffer">;
+    /**
+     * Render-camera options
+     */
+    interface camera_options {
+      /**
+       * Use the camera view-projection matrix for frustum culling. The default is false.
+       */
+      use_frustum?: boolean;
+    }
+    type constant_buffer = Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
+    /**
+     * Debug-draw options
+     */
+    interface debug_draw_options {
+      /**
+       * Frustum matrix used for culling renderable items.
+       */
+      frustum?: Matrix4;
+      /**
+       * Frustum planes used for culling. The default is render.FRUSTUM_PLANES_SIDES.
+       */
+      frustum_planes?: render.FRUSTUM_PLANES;
+    }
+    /**
+     * Compute-dispatch options
+     */
+    interface dispatch_options {
+      /**
+       * 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[] };
+    }
+    /**
+     * Render draw options
+     */
+    interface draw_options {
+      /**
+       * Frustum matrix used for culling renderable items.
+       */
+      frustum?: Matrix4;
+      /**
+       * Frustum planes used for culling. The default is render.FRUSTUM_PLANES_SIDES.
+       */
+      frustum_planes?: render.FRUSTUM_PLANES;
+      /**
+       * Constants used while rendering. The values are copied when `render.draw()` is called.
+       */
+      constants?: Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | 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_target = Opaque<"render_target">;
+    /**
+     * Render-target attachment parameters
+     */
+    interface render_target_buffer_params {
+      /**
+       * Attachment texture format.
+       */
+      format: graphics.TEXTURE_FORMAT;
+      /**
+       * Attachment width.
+       */
+      width: number;
+      /**
+       * Attachment height.
+       */
+      height: number;
+      /**
+       * Minification filter.
+       */
+      min_filter?: graphics.TEXTURE_FILTER;
+      /**
+       * Magnification filter.
+       */
+      mag_filter?: graphics.TEXTURE_FILTER;
+      /**
+       * Horizontal wrap mode.
+       */
+      u_wrap?: graphics.TEXTURE_WRAP;
+      /**
+       * Vertical wrap mode.
+       */
+      v_wrap?: graphics.TEXTURE_WRAP;
+      /**
+       * Depth wrap mode.
+       */
+      w_wrap?: graphics.TEXTURE_WRAP;
+      /**
+       * Attachment creation flags, applicable only to depth and stencil buffers.
+       */
+      flags?: render.RENDER_TARGET_FLAG | number;
+    }
+    type render_target_params = { sample_count?: number } & { [key: number]: render.render_target_buffer_params };
+    /**
+     * Render-target activation options
+     */
+    interface set_render_target_options {
+      /**
+       * Buffers whose contents become undefined after the target is deactivated. Missing buffers are ignored; combined depth-stencil buffers remain non-transient unless both are selected.
+       */
+      transient?: graphics.BUFFER_TYPE[];
+    }
     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 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;
+    type SORT = typeof render.SORT_BACK_TO_FRONT | typeof render.SORT_FRONT_TO_BACK | typeof render.SORT_NONE;
+    /**
+     * rendering context was lost; rendering pauses and graphics resources become invalid
+     */
+    const CONTEXT_EVENT_CONTEXT_LOST: number & { readonly __brand: "render.CONTEXT_EVENT_CONTEXT_LOST" };
+    /**
+     * rendering context was restored; rendering remains paused while resources can be reloaded
+     */
+    const CONTEXT_EVENT_CONTEXT_RESTORED: number & { readonly __brand: "render.CONTEXT_EVENT_CONTEXT_RESTORED" };
+    /**
+     * All six frustum planes.
+     */
     const FRUSTUM_PLANES_ALL: number & { readonly __brand: "render.FRUSTUM_PLANES_ALL" };
+    /**
+     * Left, right, top, and bottom frustum planes.
+     */
     const FRUSTUM_PLANES_SIDES: number & { readonly __brand: "render.FRUSTUM_PLANES_SIDES" };
-    const RENDER_TARGET_DEFAULT: number & { readonly __brand: "render.RENDER_TARGET_DEFAULT" };
+    const RENDER_TARGET_DEFAULT: undefined;
     /**
      * Depth sort far-to-near (default; good for transparent passes).
      */
@@ -25,6 +147,10 @@ declare global {
      * No per-call sorting; draw entries in insertion order.
      */
     const SORT_NONE: number & { readonly __brand: "render.SORT_NONE" };
+    /**
+     * Create a texture-backed depth or stencil attachment.
+     */
+    const TEXTURE_BIT: number & { readonly __brand: "render.TEXTURE_BIT" };
     /**
      * Clear buffers in the currently enabled render target with specified value. If the render target has been created with multiple
      * color attachments, all buffers will be cleared with the same value.
@@ -32,9 +158,7 @@ declare global {
      * @param buffers - table with keys specifying which buffers to clear and values set to clear values. Available keys are:
      *
      * - `graphics.BUFFER_TYPE_COLOR0_BIT`
-     *
      * - `graphics.BUFFER_TYPE_DEPTH_BIT`
-     *
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @example
      * ```ts
@@ -52,42 +176,44 @@ declare global {
      *
      * @returns new constant buffer
      * @example
+     * Set a "tint" constant in a constant buffer in the render script:
      * ```ts
-     * export default defineRenderScript({
-     *   init() {
-     *     return { my_pred: render.predicate([hash("my_tag")]) };
-     *   },
-     *
-     *   update(self, dt) {
-     *     // 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);
-     *   },
-     * });
+     * const constants = render.constant_buffer();
+     * constants.tint = vmath.vector4(1, 1, 1, 1);
+     * ```
+     * @example
+     * Then use the constant buffer when drawing a predicate:
+     * ```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
+     * The constant buffer also supports array values by specifying constants in a table:
+     * ```ts
+     * const constants = render.constant_buffer();
+     * constants.light_colors = [];
+     * constants.light_colors[0] = vmath.vector4(1, 0, 0, 1);
+     * constants.light_colors[1] = vmath.vector4(0, 1, 0, 1);
+     * constants.light_colors[2] = vmath.vector4(0, 0, 1, 1);
+     * ```
+     * @example
+     * You can also create the table by passing the vectors directly when creating the table:
+     * ```ts
+     * const 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 constants to the array
+     * constants.light_colors[3] = vmath.vector4(1, 1, 1, 1);
      * ```
      */
-    function constant_buffer(): Opaque<"constant_buffer">;
+    function constant_buffer(): Opaque<"constant_buffer"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
     /**
      * Deletes a render target created by a render script.
      * You cannot delete a render target resource.
@@ -136,15 +262,10 @@ declare global {
      * @param state - state to disable
      *
      * - `graphics.STATE_DEPTH_TEST`
-     *
      * - `graphics.STATE_STENCIL_TEST`
-     *
      * - `graphics.STATE_BLEND`
-     *
      * - `graphics.STATE_ALPHA_TEST` ( not available on iOS and Android)
-     *
      * - `graphics.STATE_CULL_FACE`
-     *
      * - `graphics.STATE_POLYGON_OFFSET_FILL`
      * @example
      * ```ts
@@ -161,7 +282,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.
      *
@@ -169,6 +290,18 @@ declare global {
      * @example
      * ```ts
      * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
      *   update(self, dt) {
      *     render.enable_texture(0, self.my_render_target, graphics.BUFFER_TYPE_COLOR0_BIT);
      *     // draw a predicate with the render target available as texture 0 in the predicate
@@ -180,7 +313,7 @@ declare global {
      * });
      * ```
      */
-    function disable_texture(binding: Opaque<"texture"> | string | Hash): void;
+    function disable_texture(binding: Opaque<"texture"> | string | Hash | number): void;
     /**
      * Dispatches the currently enabled compute program. The dispatch call takes three arguments x,y,z which constitutes
      * the 'global working group' of the compute dispatch. Together with the 'local working group' specified in the compute shader
@@ -191,10 +324,7 @@ declare global {
      * @param x - global work group size X
      * @param y - global work group size Y
      * @param z - global work group size Z
-     * @param options - optional table with properties:
-     *
-     * `constants`
-     * constant_buffer optional constants to use while rendering
+     * @param options - optional compute-dispatch options
      * @example
      * ```ts
      * export default defineRenderScript({
@@ -205,6 +335,7 @@ declare global {
      *       height: render.get_window_height(),
      *     };
      *     return {
+     *       backing_texture: resource.get_texture_info("/main/backing.texturec").handle,
      *       scene_rt: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
      *     };
      *   },
@@ -217,14 +348,16 @@ declare global {
      *     render.set_compute();
      *   },
      * });
-     *
-     * // Dispatch a compute program with a constant buffer:
+     * ```
+     * @example
+     * Dispatch a compute program with a constant buffer:
+     * ```ts
      * 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;
+    function dispatch_compute(x: number, y: number, z: number, options?: render.dispatch_options): 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
@@ -232,21 +365,7 @@ declare global {
      * 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).
+     * @param options - optional draw options
      * @example
      * ```ts
      * export default defineRenderScript({
@@ -258,37 +377,40 @@ declare global {
      *   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 });
      *   },
      * });
      * ```
+     * @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: number, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer">; sort_order?: number }): void;
+    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.
      *
-     * @param options - optional table with properties:
-     *
-     * `frustum`
-     * matrix4 A frustum matrix used to cull renderable items. (E.g. `local frustum = proj * view`). May be 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 sides of the frustum.
+     * @param options - optional debug-draw options
      * @example
      * ```ts
      * export default defineRenderScript({
@@ -299,7 +421,7 @@ declare global {
      * });
      * ```
      */
-    function draw_debug3d(options?: { frustum?: Matrix4; frustum_planes?: number }): void;
+    function draw_debug3d(options?: render.debug_draw_options): void;
     /**
      * If another material was already enabled, it will be automatically disabled
      * and the specified material is used instead.
@@ -330,15 +452,10 @@ declare global {
      * @param state - state to enable
      *
      * - `graphics.STATE_DEPTH_TEST`
-     *
      * - `graphics.STATE_STENCIL_TEST`
-     *
      * - `graphics.STATE_BLEND`
-     *
      * - `graphics.STATE_ALPHA_TEST` ( not available on iOS and Android)
-     *
      * - `graphics.STATE_CULL_FACE`
-     *
      * - `graphics.STATE_POLYGON_OFFSET_FILL`
      * @example
      * ```ts
@@ -356,7 +473,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
@@ -372,29 +489,22 @@ declare global {
      *
      * @param binding - texture binding, either by texture unit, string or hash for the sampler name that the texture should be bound to
      * @param handle_or_name - render target or texture handle that should be bound, or a named resource in the "Render Resource" table in the currently assigned .render file
-     * @param buffer_type - optional buffer type from which to enable the texture. Note that this argument only applies to render targets. Defaults to `graphics.BUFFER_TYPE_COLOR0_BIT`. These values are supported:
-     *
-     * - `graphics.BUFFER_TYPE_COLOR0_BIT`
-     *
-     * If The render target has been created as depth and/or stencil textures, these buffer types can be used:
-     *
-     * - `graphics.BUFFER_TYPE_DEPTH_BIT`
-     *
-     * - `graphics.BUFFER_TYPE_STENCIL_BIT`
-     *
-     * If the render target has been created with multiple color attachments, these buffer types can be used
-     * to enable those textures as well. Currently 4 color attachments are supported:
-     *
-     * - `graphics.BUFFER_TYPE_COLOR0_BIT`
-     *
-     * - `graphics.BUFFER_TYPE_COLOR1_BIT`
-     *
-     * - `graphics.BUFFER_TYPE_COLOR2_BIT`
-     *
-     * - `graphics.BUFFER_TYPE_COLOR3_BIT`
+     * @param buffer_type - optional render-target attachment. Defaults to `graphics.BUFFER_TYPE_COLOR0_BIT`. Depth and stencil attachments must have been created as textures; color attachments beyond the first require a render target with multiple color attachments (up to four are supported).
      * @example
      * ```ts
      * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
      *   update(self, dt) {
      *     // enable target so all drawing is done to it
      *     render.set_render_target(self.my_render_target);
@@ -416,6 +526,10 @@ declare global {
      * ```ts
      * // Or enable a render target by resource id:
      * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
      *   update(self, dt) {
      *     render.set_render_target("my_rt_resource");
      *     render.draw(self.my_pred);
@@ -432,6 +546,10 @@ declare global {
      * ```ts
      * // Or bind a texture handle directly:
      * export default defineRenderScript({
+     *   init() {
+     *     return { my_texture_handle: resource.get_texture_info("/main/my_texture.texturec").handle };
+     *   },
+     *
      *   update(self, dt) {
      *     // bind a texture to the texture unit 0
      *     render.enable_texture(0, self.my_texture_handle);
@@ -441,7 +559,7 @@ declare global {
      * });
      * ```
      */
-    function enable_texture(binding: number | string | Hash, handle_or_name: Opaque<"texture"> | string | Hash, buffer_type?: graphics.BufferType): void;
+    function enable_texture(binding: number | string | Hash, handle_or_name: Opaque<"texture"> | string | Hash | Opaque<"render_target"> | number, buffer_type?: graphics.BUFFER_TYPE): void;
     /**
      * Returns the logical window height that is set in the "game.project" settings.
      * Note that the actual window pixel size can change, either by device constraints
@@ -462,9 +580,7 @@ declare global {
      * @param buffer_type - which type of buffer to retrieve the height from
      *
      * - `graphics.BUFFER_TYPE_COLOR0_BIT`
-     *
      * - `graphics.BUFFER_TYPE_DEPTH_BIT`
-     *
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @returns the height of the render target buffer texture
      * @example
@@ -497,7 +613,7 @@ declare global {
      * });
      * ```
      */
-    function get_render_target_height(render_target: Opaque<"render_target">, buffer_type: graphics.BufferType): number;
+    function get_render_target_height(render_target: Opaque<"render_target"> | string | Hash, buffer_type: graphics.BUFFER_TYPE): number;
     /**
      * Returns the specified buffer width from a render target.
      *
@@ -505,11 +621,8 @@ declare global {
      * @param buffer_type - which type of buffer to retrieve the width from
      *
      * - `graphics.BUFFER_TYPE_COLOR0_BIT`
-     *
      * - `graphics.BUFFER_TYPE_COLOR[x]_BIT` (x: [0..3], if supported!)
-     *
      * - `graphics.BUFFER_TYPE_DEPTH_BIT`
-     *
      * - `graphics.BUFFER_TYPE_STENCIL_BIT`
      * @returns the width of the render target buffer texture
      * @example
@@ -542,13 +655,13 @@ declare global {
      * });
      * ```
      */
-    function get_render_target_width(render_target: Opaque<"render_target">, buffer_type: graphics.BufferType): number;
+    function get_render_target_width(render_target: Opaque<"render_target"> | string | Hash, buffer_type: graphics.BUFFER_TYPE): number;
     /**
      * Returns the logical window width that is set in the "game.project" settings.
      * Note that the actual window pixel size can change, either by device constraints
      * or user input.
      *
-     * @returns specified window width (number)
+     * @returns specified window width
      * @example
      * ```ts
      * // Get the width of the window.
@@ -598,7 +711,7 @@ declare global {
      * const p = render.predicate([hash("opaque"), hash("smoke")]);
      * ```
      */
-    function predicate(tags: (string | Hash)[]): number;
+    function predicate(tags: (string | Hash)[]): Opaque<"render_predicate">;
     /**
      * Sets the blend equation with separate equations for the color and alpha channels.
      *
@@ -609,7 +722,7 @@ declare global {
      * render.set_blend_equation_separate(graphics.BLEND_EQUATION_ADD, graphics.BLEND_EQUATION_REVERSE_SUBTRACT);
      * ```
      */
-    function set_blend_equation_separate(equation_color: number, equation_alpha: number): void;
+    function set_blend_equation_separate(equation_color: graphics.BLEND_EQUATION, equation_alpha: graphics.BLEND_EQUATION): void;
     /**
      * Specifies the arithmetic used when computing pixel values that are written to the frame
      * buffer. In RGBA mode, pixels can be drawn using a function that blends the source RGBA
@@ -624,64 +737,11 @@ declare global {
      * The source scale factor is referred to as (sR,sG,sB,sA).
      * The destination scale factor is referred to as (dR,dG,dB,dA).
      * The color values have integer values between 0 and (kR,kG,kB,kA), where kc = 2mc - 1 and mc is the number of bitplanes for that color. I.e for 8 bit color depth, color values are between `0` and `255`.
-     * Available factor constants and corresponding scale factors:
-     *
-     * Factor constant
-     * Scale factor (fR,fG,fB,fA)
-     *
-     * `graphics.BLEND_FACTOR_ZERO`
-     * (0,0,0,0)
-     *
-     * `graphics.BLEND_FACTOR_ONE`
-     * (1,1,1,1)
-     *
-     * `graphics.BLEND_FACTOR_SRC_COLOR`
-     * (Rs/kR,Gs/kG,Bs/kB,As/kA)
-     *
-     * `graphics.BLEND_FACTOR_ONE_MINUS_SRC_COLOR`
-     * (1,1,1,1) - (Rs/kR,Gs/kG,Bs/kB,As/kA)
-     *
-     * `graphics.BLEND_FACTOR_DST_COLOR`
-     * (Rd/kR,Gd/kG,Bd/kB,Ad/kA)
-     *
-     * `graphics.BLEND_FACTOR_ONE_MINUS_DST_COLOR`
-     * (1,1,1,1) - (Rd/kR,Gd/kG,Bd/kB,Ad/kA)
-     *
-     * `graphics.BLEND_FACTOR_SRC_ALPHA`
-     * (As/kA,As/kA,As/kA,As/kA)
-     *
-     * `graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA`
-     * (1,1,1,1) - (As/kA,As/kA,As/kA,As/kA)
-     *
-     * `graphics.BLEND_FACTOR_DST_ALPHA`
-     * (Ad/kA,Ad/kA,Ad/kA,Ad/kA)
-     *
-     * `graphics.BLEND_FACTOR_ONE_MINUS_DST_ALPHA`
-     * (1,1,1,1) - (Ad/kA,Ad/kA,Ad/kA,Ad/kA)
-     *
-     * `graphics.BLEND_FACTOR_CONSTANT_COLOR`
-     * (Rc,Gc,Bc,Ac)
-     *
-     * `graphics.BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR`
-     * (1,1,1,1) - (Rc,Gc,Bc,Ac)
-     *
-     * `graphics.BLEND_FACTOR_CONSTANT_ALPHA`
-     * (Ac,Ac,Ac,Ac)
-     *
-     * `graphics.BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA`
-     * (1,1,1,1) - (Ac,Ac,Ac,Ac)
-     *
-     * `graphics.BLEND_FACTOR_SRC_ALPHA_SATURATE`
-     * (i,i,i,1) where i = min(As, kA - Ad) /kA
-     *
      * The blended RGBA values of a pixel comes from the following equations:
      *
      * - Rd = min(kR, Rs * sR + Rd * dR)
-     *
      * - Gd = min(kG, Gs * sG + Gd * dG)
-     *
      * - Bd = min(kB, Bs * sB + Bd * dB)
-     *
      * - Ad = min(kA, As * sA + Ad * dA)
      *
      * Blend function `(graphics.BLEND_FACTOR_SRC_ALPHA, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA)` is useful for
@@ -696,7 +756,7 @@ declare global {
      * 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;
+    function set_blend_func(source_factor: graphics.BLEND_FACTOR, destination_factor: graphics.BLEND_FACTOR): void;
     /**
      * Sets the blend function with separate blend factors for the color and alpha channels.
      *
@@ -720,34 +780,29 @@ declare global {
      * Note that the frustum plane option in render.draw can still be used together with the camera.
      *
      * @param camera - camera id to use, or nil to reset
-     * @param options - optional table with properties:
-     *
-     * `use_frustum`
-     * boolean If true, the renderer will use the cameras view-projection matrix for frustum culling (default: false)
+     * @param options - optional camera options
      * @example
+     * Set the current camera to be used for rendering
      * ```ts
-     * export default defineRenderScript({
-     *   init() {
-     *     return { my_pred: render.predicate([hash("my_tag")]) };
-     *   },
-     *
-     *   update(self, dt) {
-     *     // 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 draw_through_camera(self: { my_pred: Opaque<"render_predicate"> }) {
+     *   render.set_camera("main:/my_go#camera");
+     *   render.draw(self.my_pred);
+     *   render.set_camera(undefined);
+     * }
+     * ```
+     * @example
+     * Use the camera frustum for frustum culling together with a specific frustum plane option for the draw command
+     * ```ts
+     * function draw_through_camera(self: { my_pred: Opaque<"render_predicate"> }) {
+     *   // 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;
+    function set_camera(camera?: Url | number | string | Hash, options?: render.camera_options): void;
     /**
      * Specifies whether the individual color components in the frame buffer is enabled for writing (`true`) or disabled (`false`). For example, if `blue` is `false`, nothing is written to the blue component of any pixel in any of the color buffers, regardless of the drawing operation attempted. Note that writing are either enabled or disabled for entire color components, not the individual bits of a component.
      * The component masks are all initially `true`.
@@ -795,12 +850,6 @@ declare global {
      * `face_type` is `graphics.FACE_TYPE_BACK`.
      *
      * @param face_type - face type
-     *
-     * - `graphics.FACE_TYPE_FRONT`
-     *
-     * - `graphics.FACE_TYPE_BACK`
-     *
-     * - `graphics.FACE_TYPE_FRONT_AND_BACK`
      * @example
      * ```ts
      * // How to enable polygon culling and set front face culling:
@@ -808,30 +857,12 @@ declare global {
      * render.set_cull_face(graphics.FACE_TYPE_FRONT);
      * ```
      */
-    function set_cull_face(face_type: number): void;
+    function set_cull_face(face_type: graphics.FACE_TYPE): void;
     /**
      * Specifies the function that should be used to compare each incoming pixel
      * depth value with the value present in the depth buffer.
      * The comparison is performed only if depth testing is enabled and specifies
      * the conditions under which a pixel will be drawn.
-     * Function constants:
-     *
-     * - `graphics.COMPARE_FUNC_NEVER` (never passes)
-     *
-     * - `graphics.COMPARE_FUNC_LESS` (passes if the incoming depth value is less than the stored value)
-     *
-     * - `graphics.COMPARE_FUNC_LEQUAL` (passes if the incoming depth value is less than or equal to the stored value)
-     *
-     * - `graphics.COMPARE_FUNC_GREATER` (passes if the incoming depth value is greater than the stored value)
-     *
-     * - `graphics.COMPARE_FUNC_GEQUAL` (passes if the incoming depth value is greater than or equal to the stored value)
-     *
-     * - `graphics.COMPARE_FUNC_EQUAL` (passes if the incoming depth value is equal to the stored value)
-     *
-     * - `graphics.COMPARE_FUNC_NOTEQUAL` (passes if the incoming depth value is not equal to the stored value)
-     *
-     * - `graphics.COMPARE_FUNC_ALWAYS` (always passes)
-     *
      * The depth function is initially set to `graphics.COMPARE_FUNC_LESS`.
      *
      * @param func - depth test function, see the description for available values
@@ -842,7 +873,7 @@ declare global {
      * render.set_depth_func(graphics.COMPARE_FUNC_NOTEQUAL);
      * ```
      */
-    function set_depth_func(func: number): void;
+    function set_depth_func(func: graphics.COMPARE_FUNC): void;
     /**
      * Specifies whether the depth buffer is enabled for writing. The supplied mask governs
      * if depth buffer writing is enabled (`true`) or disabled (`false`).
@@ -857,18 +888,10 @@ declare global {
      */
     function set_depth_mask(depth: boolean): void;
     /**
-     * Set or remove listener. Currenly only only two type of events can arrived:
-     * `render.CONTEXT_EVENT_CONTEXT_LOST` - when rendering context lost. Rending paused and all graphics resources become invalid.
-     * `render.CONTEXT_EVENT_CONTEXT_RESTORED` - when rendering context was restored. Rendering still paused and graphics resources still
-     * invalid but can be reloaded.
+     * Set or remove the rendering-context event listener.
      *
      * @param callback - A callback that receives all render related events.
      * Pass `nil` if want to remove listener.
-     *
-     * `self`
-     * object The render script
-     * `event_type`
-     * string Rendering event. Possible values: `render.CONTEXT_EVENT_CONTEXT_LOST`, `render.CONTEXT_EVENT_CONTEXT_RESTORED`
      * @example
      * ```ts
      * // Set listener and handle render context events.
@@ -886,7 +909,7 @@ declare global {
      * });
      * ```
      */
-    function set_listener(callback?: (self: unknown, event_type: unknown) => void): void;
+    function set_listener(callback?: (self: unknown, event_type: render.CONTEXT_EVENT) => void): void;
     /**
      * Sets the scale and units used to calculate depth values.
      * If `graphics.STATE_POLYGON_OFFSET_FILL` is enabled, each fragment's depth value
@@ -897,7 +920,7 @@ declare global {
      * offset for each polygon. The initial value is `0`.
      * `units` is multiplied by an implementation-specific value to create a
      * constant depth offset. The initial value is `0`.
-     * The value of the offset is computed as `factor` &times; `DZ` + `r` &times; `units`
+     * The value of the offset is computed as `factor` × `DZ` + `r` × `units`
      * `DZ` is a measurement of the depth slope of the polygon which is the change in z (depth)
      * values divided by the change in either x or y coordinates, as you traverse a polygon.
      * The depth values are in window coordinates, clamped to the range [0, 1].
@@ -932,19 +955,8 @@ declare global {
      * 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`
+     * @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
@@ -952,6 +964,18 @@ declare global {
      * // How to set a render target and draw to it and then switch back to the default render target
      * // The render target defines the depth/stencil buffers as transient, when set_render_target is called the next time the buffers may be invalidated and allow for optimisations depending on driver support
      * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       my_render_target: render.render_target({ [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params }),
+     *       my_pred: render.predicate([hash("my_tag")]),
+     *     };
+     *   },
+     *
      *   update(self, dt) {
      *     // set render target so all drawing is done to it
      *     render.set_render_target(self.my_render_target, {
@@ -971,6 +995,10 @@ declare global {
      * ```ts
      * // Or set the render target by a render target resource identifier:
      * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
      *   update(self, dt) {
      *     render.set_render_target("my_rt_resource");
      *
@@ -983,7 +1011,7 @@ declare global {
      * });
      * ```
      */
-    function set_render_target(render_target: Opaque<"render_target">, options?: { transient?: Record<string | number, unknown> }): void;
+    function set_render_target(render_target?: Opaque<"render_target"> | string | Hash | typeof render.RENDER_TARGET_DEFAULT, options?: 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.
@@ -1006,7 +1034,7 @@ declare global {
      * });
      * ```
      */
-    function set_render_target_size(render_target: Opaque<"render_target">, width: number, height: number): void;
+    function set_render_target_size(render_target: Opaque<"render_target"> | string | Hash, width: number, height: number): void;
     /**
      * Stenciling is similar to depth-buffering as it enables and disables drawing on a
      * per-pixel basis. First, GL drawing primitives are drawn into the stencil planes.
@@ -1014,30 +1042,13 @@ declare global {
      * where to draw.
      * The stencil test discards a pixel based on the outcome of a comparison between the
      * reference value `ref` and the corresponding value in the stencil buffer.
-     * `func` specifies the comparison function. See the table below for values.
+     * `func` specifies the comparison function.
      * The initial value is `graphics.COMPARE_FUNC_ALWAYS`.
      * `ref` specifies the reference value for the stencil test. The value is clamped to
      * the range [0, 2n-1], where n is the number of bitplanes in the stencil buffer.
      * The initial value is `0`.
      * `mask` is ANDed with both the reference value and the stored stencil value when the test
      * is done. The initial value is all `1`'s.
-     * Function constant:
-     *
-     * - `graphics.COMPARE_FUNC_NEVER` (never passes)
-     *
-     * - `graphics.COMPARE_FUNC_LESS` (passes if (ref & mask) < (stencil & mask))
-     *
-     * - `graphics.COMPARE_FUNC_LEQUAL` (passes if (ref & mask) <= (stencil & mask))
-     *
-     * - `graphics.COMPARE_FUNC_GREATER` (passes if (ref & mask) > (stencil & mask))
-     *
-     * - `graphics.COMPARE_FUNC_GEQUAL` (passes if (ref & mask) >= (stencil & mask))
-     *
-     * - `graphics.COMPARE_FUNC_EQUAL` (passes if (ref & mask) = (stencil & mask))
-     *
-     * - `graphics.COMPARE_FUNC_NOTEQUAL` (passes if (ref & mask) != (stencil & mask))
-     *
-     * - `graphics.COMPARE_FUNC_ALWAYS` (always passes)
      *
      * @param func - stencil test function, see the description for available values
      * @param ref - reference value for the stencil test
@@ -1048,7 +1059,7 @@ declare global {
      * render.set_stencil_func(graphics.COMPARE_FUNC_EQUAL, 0, 1);
      * ```
      */
-    function set_stencil_func(func: number, ref: number, mask: number): void;
+    function set_stencil_func(func: graphics.COMPARE_FUNC, ref: number, mask: number): void;
     /**
      * The stencil mask controls the writing of individual bits in the stencil buffer.
      * The least significant `n` bits of the parameter `mask`, where `n` is the number of
@@ -1074,24 +1085,6 @@ declare global {
      * value while stenciling is enabled. If the stencil test fails, no change is made to the
      * pixel's color or depth buffers, and `sfail` specifies what happens to the stencil buffer
      * contents.
-     * Operator constants:
-     *
-     * - `graphics.STENCIL_OP_KEEP` (keeps the current value)
-     *
-     * - `graphics.STENCIL_OP_ZERO` (sets the stencil buffer value to 0)
-     *
-     * - `graphics.STENCIL_OP_REPLACE` (sets the stencil buffer value to `ref`, as specified by render.set_stencil_func)
-     *
-     * - `graphics.STENCIL_OP_INCR` (increments the stencil buffer value and clamp to the maximum representable unsigned value)
-     *
-     * - `graphics.STENCIL_OP_INCR_WRAP` (increments the stencil buffer value and wrap to zero when incrementing the maximum representable unsigned value)
-     *
-     * - `graphics.STENCIL_OP_DECR` (decrements the current stencil buffer value and clamp to 0)
-     *
-     * - `graphics.STENCIL_OP_DECR_WRAP` (decrements the current stencil buffer value and wrap to the maximum representable unsigned value when decrementing zero)
-     *
-     * - `graphics.STENCIL_OP_INVERT` (bitwise inverts the current stencil buffer value)
-     *
      * `dppass` and `dpfail` specify the stencil buffer actions depending on whether subsequent
      * depth buffer tests succeed (dppass) or fail (dpfail).
      * The initial value for all operators is `graphics.STENCIL_OP_KEEP`.
@@ -1108,7 +1101,7 @@ declare global {
      * 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;
+    function set_stencil_op(sfail: graphics.STENCIL_OP, dpfail: graphics.STENCIL_OP, dppass: graphics.STENCIL_OP): void;
     /**
      * Sets the view matrix to use when rendering.
      *
@@ -1132,7 +1125,11 @@ declare global {
      *   },
      *
      *   on_message(self, message_id, message) {
-     *     if (message_id === hash("set_view_projection")) {
+     *     if (
+     *       message_id === hash("set_view_projection") &&
+     *       types.is_matrix4(message.view) &&
+     *       types.is_matrix4(message.projection)
+     *     ) {
      *       // camera view and projection arrives here.
      *       self.view = message.view;
      *       self.projection = message.projection;