@defold-typescript/types 0.49.0 → 0.50.0

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

@@ -0,0 +1,1153 @@
+/** @noSelfInFile */
+import type { Hash, Matrix4, Opaque, Url, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Rendering API documentation
+   */
+  namespace render {
+    /**
+     * 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: undefined;
+    /**
+     * Depth sort far-to-near (default; good for transparent passes).
+     */
+    const SORT_BACK_TO_FRONT: number & { readonly __brand: "render.SORT_BACK_TO_FRONT" };
+    /**
+     * Depth sort near-to-far (good for opaque passes to reduce overdraw).
+     */
+    const SORT_FRONT_TO_BACK: number & { readonly __brand: "render.SORT_FRONT_TO_BACK" };
+    /**
+     * 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.
+     *
+     * @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
+     * // Clear the color buffer and the depth buffer.
+     * const buffers = new LuaMap<render.ClearBufferKey, number | Vector4>();
+     * buffers.set(graphics.BUFFER_TYPE_COLOR0_BIT, vmath.vector4(0, 0, 0, 0));
+     * buffers.set(graphics.BUFFER_TYPE_DEPTH_BIT, 1);
+     * render.clear(buffers);
+     * ```
+     */
+    function clear(buffers: LuaMap<render.ClearBufferKey, number | Vector4>): void;
+    /**
+     * Constant buffers are used to set shader program variables and are optionally passed to the `render.draw()` function.
+     * The buffer's constant elements can be indexed like an ordinary Lua table, but you can't iterate over them with pairs() or ipairs().
+     *
+     * @returns new constant buffer
+     * @example
+     * Set a "tint" constant in a constant buffer in the render script:
+     * ```ts
+     * const constants = render.constant_buffer();
+     * constants.tint = vmath.vector4(1, 1, 1, 1);
+     * ```
+     * @example
+     * Then use the constant buffer when drawing a predicate:
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     const constants = render.constant_buffer();
+     *     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"> & { [name: string]: Vector4 | Matrix4 | Vector4[] | Matrix4[] };
+    /**
+     * Deletes a render target created by a render script.
+     * You cannot delete a render target resource.
+     *
+     * @param render_target - render target to delete
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     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);
+     *   },
+     * });
+     * ```
+     */
+    function delete_render_target(render_target: Opaque<"render_target">): void;
+    /**
+     * If a material is currently enabled, disable it.
+     * The name of the material must be specified in the ".render" resource set
+     * in the "game.project" setting.
+     *
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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;
+    /**
+     * Disables a render state.
+     *
+     * @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
+     * export default defineRenderScript({
+     *   init() {
+     *     return { tile_pred: render.predicate([hash("tile")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // Disable face culling when drawing the tile predicate:
+     *     render.disable_state(graphics.STATE_CULL_FACE);
+     *     render.draw(self.tile_pred);
+     *   },
+     * });
+     * ```
+     */
+    function disable_state(state: graphics.STATE): void;
+    /**
+     * Disables a texture that has previourly been enabled.
+     *
+     * @param binding - texture binding, either by texture unit, string or hash that should be disabled
+     * @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
+     *     // material shader.
+     *     render.draw(self.my_pred);
+     *     // done, disable the texture
+     *     render.disable_texture(0);
+     *   },
+     * });
+     * ```
+     */
+    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
+     * as a layout qualifier, these two sets of parameters forms the number of invocations the compute shader will execute.
+     * 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 the compute program.
+     *
+     * @param x - global work group size X
+     * @param y - global work group size Y
+     * @param z - global work group size Z
+     * @param options - optional compute-dispatch options
+     * @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 {
+     *       backing_texture: resource.get_texture_info("/main/backing.texturec").handle,
+     *       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();
+     *   },
+     * });
+     * ```
+     * @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?: 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
+     * 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.
+     *
+     * @param options - optional debug-draw options
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   update(self, dt) {
+     *     // draw debug visualization
+     *     render.draw_debug3d();
+     *   },
+     * });
+     * ```
+     */
+    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.
+     * The name of the material must be specified in the ".render" resource set
+     * in the "game.project" setting.
+     *
+     * @param material_id - material id to enable
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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;
+    /**
+     * Enables a particular render state. The state will be enabled until disabled.
+     *
+     * @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
+     * export default defineRenderScript({
+     *   init() {
+     *     return { gui_pred: render.predicate([hash("gui")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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: 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
+     * or to a sampler name by a hash or a string.
+     * A texture can be bound to multiple units and sampler names at the same time,
+     * the actual binding will be applied to the shaders when a shader program is bound.
+     * When mixing binding using both units and sampler names, you might end up in situations
+     * where two different textures will be applied to the same bind location in the shader.
+     * In this case, the texture set to the named sampler will take precedence over the unit.
+     * Note that you can bind multiple sampler names to the same texture, in case you want to reuse
+     * the same texture for differnt use-cases. It is however recommended that you use the same name
+     * everywhere for the textures that should be shared across different materials.
+     *
+     * @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 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);
+     *
+     *     // 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);
+     *   },
+     * });
+     * ```
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   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);
+     *   },
+     * });
+     * ```
+     * @example
+     * ```ts
+     * 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);
+     *     // 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 | 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
+     * or user input.
+     *
+     * @returns specified window height
+     * @example
+     * ```ts
+     * // Get the height of the window
+     * const h = render.get_height();
+     * ```
+     */
+    function get_height(): number;
+    /**
+     * Returns the specified buffer height from a render target.
+     *
+     * @param render_target - render target from which to retrieve the buffer height
+     * @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
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       target_right: render.render_target("right", {
+     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params,
+     *       }),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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"> | string | Hash, buffer_type: graphics.BUFFER_TYPE): number;
+    /**
+     * Returns the specified buffer width from a render target.
+     *
+     * @param render_target - render target from which to retrieve the buffer width
+     * @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
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     const color_params = {
+     *       format: graphics.TEXTURE_FORMAT_RGBA,
+     *       width: render.get_window_width(),
+     *       height: render.get_window_height(),
+     *     };
+     *     return {
+     *       target_right: render.render_target("right", {
+     *         [graphics.BUFFER_TYPE_COLOR0_BIT]: color_params,
+     *       }),
+     *     };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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"> | 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
+     * @example
+     * ```ts
+     * // Get the width of the window.
+     * const w = render.get_width();
+     * ```
+     */
+    function get_width(): number;
+    /**
+     * Returns the actual physical window height.
+     * Note that this value might differ from the logical height that is set in the
+     * "game.project" settings.
+     *
+     * @returns actual window height
+     * @example
+     * ```ts
+     * // Get the actual height of the window
+     * const h = render.get_window_height();
+     * ```
+     */
+    function get_window_height(): number;
+    /**
+     * Returns the actual physical window width.
+     * Note that this value might differ from the logical width that is set in the
+     * "game.project" settings.
+     *
+     * @returns actual window width
+     * @example
+     * ```ts
+     * // Get the actual width of the window
+     * const w = render.get_window_width();
+     * ```
+     */
+    function get_window_width(): number;
+    /**
+     * This function returns a new render predicate for objects with materials matching
+     * the provided material tags. The provided tags are combined into a bit mask
+     * for the predicate. If multiple tags are provided, the predicate matches materials
+     * with all tags ANDed together.
+     * The current limit to the number of tags that can be defined is `64`.
+     *
+     * @param tags - table of tags that the predicate should match. The tags can be of either hash or string type
+     * @returns new predicate
+     * @example
+     * ```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: (string | Hash)[]): Opaque<"render_predicate">;
+    /**
+     * Sets the blend equation with separate equations for the color and alpha channels.
+     *
+     * @param equation_color - color blend equation
+     * @param equation_alpha - alpha blend equation
+     * @example
+     * ```ts
+     * render.set_blend_equation_separate(graphics.BLEND_EQUATION_ADD, graphics.BLEND_EQUATION_REVERSE_SUBTRACT);
+     * ```
+     */
+    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
+     * pixel values with the destination pixel values already in the frame buffer.
+     * Blending is initially disabled.
+     * `source_factor` specifies which method is used to scale the source color components.
+     * `destination_factor` specifies which method is used to scale the destination color
+     * components.
+     * Source color components are referred to as (Rs,Gs,Bs,As).
+     * Destination color components are referred to as (Rd,Gd,Bd,Ad).
+     * The color specified by setting the blendcolor is referred to as (Rc,Gc,Bc,Ac).
+     * 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`.
+     * 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
+     * drawing with transparency when the drawn objects are sorted from farthest to nearest.
+     * It is also useful for drawing antialiased points and lines in arbitrary order.
+     *
+     * @param source_factor - source factor
+     * @param destination_factor - destination factor
+     * @example
+     * ```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: graphics.BLEND_FACTOR, destination_factor: graphics.BLEND_FACTOR): void;
+    /**
+     * Sets the blend function with separate blend factors for the color and alpha channels.
+     *
+     * @param source_factor_color - source color blend factor
+     * @param destination_factor_color - destination color blend factor
+     * @param source_factor_alpha - source alpha blend factor
+     * @param destination_factor_alpha - destination alpha blend factor
+     * @example
+     * ```ts
+     * 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;
+    /**
+     * 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
+     * during rendering. If a projection and/or view matrix has been set by the render script,
+     * they will not be used until the current render camera has been reset by calling `render.set_camera()`.
+     * If the 'use_frustum' flag in the options table has been set to true, the renderer will automatically use the
+     * camera frustum for frustum culling regardless of what frustum is being passed into the render.draw() function.
+     * 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 camera options
+     * @example
+     * Set the current camera to be used for rendering
+     * ```ts
+     * 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 | 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`.
+     *
+     * @param red - red mask
+     * @param green - green mask
+     * @param blue - blue mask
+     * @param alpha - alpha mask
+     * @example
+     * ```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;
+    /**
+     * The name of the compute program must be specified in the ".render" resource set
+     * in the "game.project" setting. If nil (or no arguments) are passed to this function,
+     * the current compute program will instead be disabled.
+     *
+     * @param compute - compute id to use, or nil to disable
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { backing_texture: "my_texture_resource" };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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;
+    /**
+     * Specifies whether front- or back-facing polygons can be culled
+     * when polygon culling is enabled. Polygon culling is initially disabled.
+     * If mode is `graphics.FACE_TYPE_FRONT_AND_BACK`, no polygons are drawn, but other
+     * primitives such as points and lines are drawn. The initial value for
+     * `face_type` is `graphics.FACE_TYPE_BACK`.
+     *
+     * @param face_type - face type
+     * @example
+     * ```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: 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.
+     * The depth function is initially set to `graphics.COMPARE_FUNC_LESS`.
+     *
+     * @param func - depth test function, see the description for available values
+     * @example
+     * ```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: 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`).
+     * The mask is initially `true`.
+     *
+     * @param depth - depth mask
+     * @example
+     * ```ts
+     * // How to turn off writing to the depth buffer:
+     * render.set_depth_mask(false);
+     * ```
+     */
+    function set_depth_mask(depth: boolean): void;
+    /**
+     * 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.
+     * @example
+     * ```ts
+     * // Set listener and handle render context events.
+     * // custom.render_script
+     * export default defineRenderScript({
+     *   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: 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
+     * is offset from its interpolated value (depending on the depth value of the
+     * appropriate vertices). Polygon offset can be used when drawing decals, rendering
+     * hidden-line images etc.
+     * `factor` specifies a scale factor that is used to create a variable depth
+     * 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` × `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].
+     * `r` is the smallest value that is guaranteed to produce a resolvable difference.
+     * It's value is an implementation-specific constant.
+     * The offset is added before the depth test is performed and before the
+     * value is written into the depth buffer.
+     *
+     * @param factor - polygon offset factor
+     * @param units - polygon offset units
+     * @example
+     * ```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;
+    /**
+     * Sets the projection matrix to use when rendering.
+     *
+     * @param matrix - projection matrix
+     * @example
+     * ```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;
+    /**
+     * 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() {
+     *     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, {
+     *       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, 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.
+     *
+     * @param render_target - render target to set size for
+     * @param width - new render target width
+     * @param height - new render target height
+     * @example
+     * ```ts
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_render_target: render.render_target("my_target", {}) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     // 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"> | 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.
+     * Second, geometry and images are rendered but using the stencil planes to mask out
+     * 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.
+     * 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.
+     *
+     * @param func - stencil test function, see the description for available values
+     * @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
+     * ```ts
+     * // let only 0's pass the stencil test
+     * render.set_stencil_func(graphics.COMPARE_FUNC_EQUAL, 0, 1);
+     * ```
+     */
+    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
+     * bits in the stencil buffer, specify the mask.
+     * Where a `1` bit appears in the mask, the corresponding
+     * bit in the stencil buffer can be written. Where a `0` bit appears in the mask,
+     * the corresponding bit in the stencil buffer is never written.
+     * The mask is initially all `1`'s.
+     *
+     * @param mask - stencil mask
+     * @example
+     * ```ts
+     * // set the stencil mask to all 1:s
+     * render.set_stencil_mask(0xff);
+     * ```
+     */
+    function set_stencil_mask(mask: number): void;
+    /**
+     * 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.
+     * To control the test, call render.set_stencil_func.
+     * This function takes three arguments that control what happens to the stored stencil
+     * 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.
+     * `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`.
+     *
+     * @param sfail - action to take when the stencil test fails
+     * @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
+     * ```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: graphics.STENCIL_OP, dpfail: graphics.STENCIL_OP, dppass: graphics.STENCIL_OP): void;
+    /**
+     * Sets the view matrix to use when rendering.
+     *
+     * @param matrix - view matrix to set
+     * @example
+     * ```ts
+     * // How to set the view and projection matrices according to
+     * // the values supplied by a camera.
+     * export default defineRenderScript({
+     *   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") &&
+     *       types.is_matrix4(message.view) &&
+     *       types.is_matrix4(message.projection)
+     *     ) {
+     *       // camera view and projection arrives here.
+     *       self.view = message.view;
+     *       self.projection = message.projection;
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function set_view(matrix: Matrix4): void;
+    /**
+     * Set the render viewport to the specified rectangle.
+     *
+     * @param x - left corner
+     * @param y - bottom corner
+     * @param width - viewport width
+     * @param height - viewport height
+     * @example
+     * ```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;
+  }
+}
+
+export {};