@defold-typescript/types 0.49.0 → 0.50.0

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

@@ -0,0 +1,300 @@
+/** @noSelfInFile */
+import type { Hash, Matrix4, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Messages to control camera components and camera focus.
+   */
+  namespace camera {
+    type ORTHO_MODE = typeof camera.ORTHO_MODE_AUTO_COVER | typeof camera.ORTHO_MODE_AUTO_FIT | typeof camera.ORTHO_MODE_FIXED;
+    /**
+     * auto-cover orthographic zoom mode Computes zoom so the original display area covers the entire window while preserving aspect ratio. Equivalent to using max(window_width/width, window_height/height). The result is multiplied by the user-controlled orthographic zoom.
+     */
+    const ORTHO_MODE_AUTO_COVER: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_COVER" };
+    /**
+     * auto-fit orthographic zoom mode Computes zoom so the original display area (game.project width/height) fits inside the window while preserving aspect ratio. Equivalent to using min(window_width/width, window_height/height). The result is multiplied by the user-controlled orthographic zoom.
+     */
+    const ORTHO_MODE_AUTO_FIT: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_FIT" };
+    /**
+     * fixed orthographic zoom mode Uses the manually set orthographic zoom value (camera.set_orthographic_zoom).
+     */
+    const ORTHO_MODE_FIXED: number & { readonly __brand: "camera.ORTHO_MODE_FIXED" };
+    /**
+     * Gets the effective aspect ratio of the camera. If auto aspect ratio is enabled,
+     * returns the aspect ratio calculated from the current render target dimensions.
+     * Otherwise returns the manually set aspect ratio.
+     *
+     * @param camera - camera id
+     * @returns the effective aspect ratio.
+     */
+    function get_aspect_ratio(camera?: Url | number | string | Hash): number;
+    /**
+     * Returns whether auto aspect ratio is enabled. When enabled, the camera automatically
+     * calculates aspect ratio from render target dimensions. When disabled, uses the
+     * manually set aspect ratio value.
+     *
+     * @param camera - camera id
+     * @returns true if auto aspect ratio is enabled
+     */
+    function get_auto_aspect_ratio(camera?: Url | number | string | Hash): boolean;
+    /**
+     * This function returns a table with all the camera URLs that have been
+     * registered in the render context.
+     *
+     * @returns a table with all camera URLs
+     * @example
+     * ```ts
+     * const predicate = render.predicate([hash("my_tag")]);
+     * for (const camera_id of camera.get_cameras()) {
+     *   render.set_camera(camera_id);
+     *   render.draw(predicate);
+     *   render.set_camera();
+     * }
+     * ```
+     */
+    function get_cameras(): Url[];
+    /**
+     * get enabled
+     *
+     * @param camera - camera id
+     * @returns true if the camera is enabled
+     */
+    function get_enabled(camera?: Url | number | string | Hash): boolean;
+    /**
+     * get far z
+     *
+     * @param camera - camera id
+     * @returns the far z.
+     */
+    function get_far_z(camera?: Url | number | string | Hash): number;
+    /**
+     * get field of view
+     *
+     * @param camera - camera id
+     * @returns the field of view.
+     */
+    function get_fov(camera?: Url | number | string | Hash): number;
+    /**
+     * get near z
+     *
+     * @param camera - camera id
+     * @returns the near z.
+     */
+    function get_near_z(camera?: Url | number | string | Hash): number;
+    /**
+     * Gets the orthographic zoom calculated from the current window and project dimensions
+     * in auto-fit and auto-cover modes. Returns 1.0 in fixed mode.
+     *
+     * @param camera - camera id
+     * @returns the calculated orthographic auto zoom.
+     */
+    function get_orthographic_auto_zoom(camera?: Url | number | string | Hash): number;
+    /**
+     * get orthographic zoom mode
+     *
+     * @param camera - camera id
+     * @returns one of camera.ORTHO_MODE_FIXED, camera.ORTHO_MODE_AUTO_FIT or
+     * camera.ORTHO_MODE_AUTO_COVER
+     */
+    function get_orthographic_mode(camera?: Url | number | string | Hash): camera.ORTHO_MODE;
+    /**
+     * Gets the positive user-controlled orthographic zoom multiplier. In auto-fit and auto-cover
+     * modes, this value is multiplied with camera.get_orthographic_auto_zoom(camera).
+     *
+     * @param camera - camera id
+     * @returns the positive zoom multiplier when the camera uses orthographic projection.
+     */
+    function get_orthographic_zoom(camera?: Url | number | string | Hash): number;
+    /**
+     * get projection matrix
+     *
+     * @param camera - camera id
+     * @returns the projection matrix.
+     */
+    function get_projection(camera?: Url | number | string | Hash): Matrix4;
+    /**
+     * get view matrix
+     *
+     * @param camera - camera id
+     * @returns the view matrix.
+     */
+    function get_view(camera?: Url | number | string | Hash): Matrix4;
+    /**
+     * Converts a screen-space 2D point with view depth to a 3D world point.
+     * z is the view depth in world units measured from the camera plane along the camera forward axis.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param pos - Screen-space position (x, y) with z as view depth in world units
+     * @param camera - optional camera id
+     * @returns the world coordinate
+     * @example
+     * ```ts
+     * // Place objects at the touch point with a random Z position, keeping them
+     * // within the visible view zone.
+     * export default defineScript({
+     *   on_input(self, action_id, action) {
+     *     if (action_id === hash("touch")) {
+     *       if (action.pressed && action.screen_x !== undefined && action.screen_y !== undefined) {
+     *         const perspective_camera = msg.url("#perspective_camera");
+     *         const random_z = math.random(
+     *           camera.get_near_z(perspective_camera) + 0.01,
+     *           camera.get_far_z(perspective_camera) - 0.01,
+     *         );
+     *         const world_position = camera.screen_to_world(
+     *           vmath.vector3(action.screen_x, action.screen_y, random_z),
+     *           perspective_camera,
+     *         );
+     *         go.set_position(world_position, "/go1");
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function screen_to_world(pos: Vector3, camera?: Url | number | string | Hash): Vector3;
+    /**
+     * Converts 2D screen coordinates (x,y) to the 3D world-space point on the camera's near plane for that pixel.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param x - X coordinate on screen.
+     * @param y - Y coordinate on screen.
+     * @param camera - optional camera id
+     * @returns the world coordinate on the camera near plane
+     * @example
+     * ```ts
+     * // Place objects at the touch point.
+     * export default defineScript({
+     *   on_input(self, action_id, action) {
+     *     if (action_id === hash("touch")) {
+     *       if (action.pressed && action.screen_x !== undefined && action.screen_y !== undefined) {
+     *         const world_position = camera.screen_xy_to_world(action.screen_x, action.screen_y);
+     *         go.set_position(world_position, "/go1");
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function screen_xy_to_world(x: number, y: number, camera?: Url | number | string | Hash): Vector3;
+    /**
+     * Sets the manual aspect ratio for the camera. This value is only used when
+     * auto aspect ratio is disabled. To disable auto aspect ratio and use this
+     * manual value, call camera.set_auto_aspect_ratio(camera, false).
+     *
+     * @param camera - camera id
+     * @param aspect_ratio - the manual aspect ratio value.
+     */
+    function set_aspect_ratio(camera: Url | number | string | Hash | undefined, aspect_ratio: number): void;
+    /**
+     * Enables or disables automatic aspect ratio calculation. When enabled (true),
+     * the camera automatically calculates aspect ratio from render target dimensions.
+     * When disabled (false), uses the manually set aspect ratio value.
+     *
+     * @param camera - camera id
+     * @param auto_aspect_ratio - true to enable auto aspect ratio
+     */
+    function set_auto_aspect_ratio(camera: Url | number | string | Hash | undefined, auto_aspect_ratio: boolean): void;
+    /**
+     * set far z
+     *
+     * @param camera - camera id
+     * @param far_z - the far z.
+     */
+    function set_far_z(camera: Url | number | string | Hash | undefined, far_z: number): void;
+    /**
+     * set field of view
+     *
+     * @param camera - camera id
+     * @param fov - the field of view.
+     */
+    function set_fov(camera: Url | number | string | Hash | undefined, fov: number): void;
+    /**
+     * set near z
+     *
+     * @param camera - camera id
+     * @param near_z - the near z.
+     */
+    function set_near_z(camera: Url | number | string | Hash | undefined, near_z: number): void;
+    /**
+     * set orthographic zoom mode
+     *
+     * @param camera - camera id
+     * @param mode - camera.ORTHO_MODE_FIXED, camera.ORTHO_MODE_AUTO_FIT or camera.ORTHO_MODE_AUTO_COVER
+     */
+    function set_orthographic_mode(camera: Url | number | string | Hash | undefined, mode: camera.ORTHO_MODE): void;
+    /**
+     * Sets the positive user-controlled orthographic zoom multiplier. In auto-fit and auto-cover
+     * modes, this value is multiplied with camera.get_orthographic_auto_zoom(camera).
+     *
+     * @param camera - camera id
+     * @param orthographic_zoom - the positive zoom multiplier when the camera uses orthographic projection.
+     */
+    function set_orthographic_zoom(camera: Url | number | string | Hash | undefined, orthographic_zoom: number): void;
+    /**
+     * Converts a 3D world position to screen-space coordinates with view depth.
+     * Returns a vector3 where x and y are in screen pixels and z is the view depth in world units
+     * measured from the camera plane along the camera forward axis. The returned z can be used with
+     * camera.screen_to_world to reconstruct the world position on the same pixel ray.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param world_pos - World-space position
+     * @param camera - optional camera id
+     * @returns Screen position (x,y in pixels, z is view depth)
+     * @example
+     * ```ts
+     * // Convert a game object position into a screen position.
+     * go.update_world_transform("/go1");
+     * const world_pos = go.get_world_position("/go1");
+     * const screen_pos = camera.world_to_screen(world_pos);
+     * ```
+     */
+    function world_to_screen(world_pos: Vector3, camera?: Url | number | string | Hash): Vector3;
+    interface properties {
+      /**
+       * The ratio between the frustum width and height. Used when calculating the
+       * projection of a perspective camera.
+       * The type of the property is number.
+       */
+      aspect_ratio: number;
+      /**
+       * Camera frustum far plane.
+       * The type of the property is float.
+       */
+      far_z: number;
+      /**
+       * Vertical field of view of the camera.
+       * The type of the property is float.
+       */
+      fov: number;
+      /**
+       * Camera frustum near plane.
+       * The type of the property is float.
+       */
+      near_z: number;
+      /**
+       * READ ONLY The zoom calculated from the current window and project dimensions
+       * in auto fit and auto cover modes. The value is 1.0 in fixed mode.
+       * The type of the property is float.
+       */
+      readonly orthographic_auto_zoom: number;
+      /**
+       * Positive zoom multiplier when using an orthographic projection. In auto fit and auto cover
+       * modes, this value is multiplied with the calculated orthographic_auto_zoom value.
+       * The type of the property is float.
+       */
+      orthographic_zoom: number;
+      /**
+       * READ ONLY The calculated projection matrix of the camera.
+       * The type of the property is matrix4.
+       */
+      readonly projection: Matrix4;
+      /**
+       * READ ONLY The calculated view matrix of the camera.
+       * The type of the property is matrix4.
+       */
+      readonly view: Matrix4;
+    }
+  }
+}
+
+export {};

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

@@ -0,0 +1,148 @@
+/** @noSelfInFile */
+import type { Hash, Quaternion, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for controlling collection factory components which are
+   * used to dynamically spawn collections into the runtime.
+   */
+  namespace collectionfactory {
+    type Status = typeof collectionfactory.STATUS_UNLOADED | typeof collectionfactory.STATUS_LOADING | typeof collectionfactory.STATUS_LOADED;
+    type STATUS = typeof collectionfactory.STATUS_LOADED | typeof collectionfactory.STATUS_LOADING | typeof collectionfactory.STATUS_UNLOADED;
+    /**
+     * The collection factory resources are loaded.
+     */
+    const STATUS_LOADED: number & { readonly __brand: "collectionfactory.STATUS_LOADED" };
+    /**
+     * The collection factory resources are loading.
+     */
+    const STATUS_LOADING: number & { readonly __brand: "collectionfactory.STATUS_LOADING" };
+    /**
+     * The collection factory resources are unloaded.
+     */
+    const STATUS_UNLOADED: number & { readonly __brand: "collectionfactory.STATUS_UNLOADED" };
+    /**
+     * The URL identifies the collectionfactory component that should do the spawning.
+     * Spawning is instant, but spawned game objects get their first update calls the following frame. The supplied parameters for position, rotation and scale
+     * will be applied to the whole collection when spawned.
+     * Script properties in the created game objects can be overridden through
+     * a properties-parameter table. The table should contain game object ids
+     * (hash) as keys and property tables as values to be used when initiating each
+     * spawned game object.
+     * See go.property for more information on script properties.
+     * The function returns a table that contains a key for each game object
+     * id (hash), as addressed if the collection file was top level, and the
+     * corresponding spawned instance id (hash) as value with a unique path
+     * prefix added to each instance.
+     * Calling collectionfactory.create create on a collection factory that is marked as dynamic without having loaded resources
+     * using collectionfactory.load will synchronously load and create resources which may affect application performance.
+     *
+     * @param url - the collection factory component to be used
+     * @param position - position to assign to the newly spawned collection
+     * @param rotation - rotation to assign to the newly spawned collection
+     * @param properties - table of script properties to propagate to any new game object instances
+     * @param scale - uniform scaling to apply to the newly spawned collection (must be greater than 0).
+     * @returns a table mapping the id:s from the collection to the new instance id:s
+     * @example
+     * How to spawn a collection of game objects:
+     * ```ts
+     * export default defineScript({
+     *   init() {
+     *     // Spawn a small group of enemies.
+     *     const pos = vmath.vector3(100, 12.5, 0);
+     *     const rot = vmath.quat_rotation_z(Math.PI / 2);
+     *     const scale = 0.5;
+     *     const props = new LuaMap<Hash, Record<string, unknown>>();
+     *     props.set(hash("/enemy_leader"), { health: 1000.0 });
+     *     props.set(hash("/enemy_1"), { health: 200.0 });
+     *     props.set(hash("/enemy_2"), { health: 400.0, color: hash("green") });
+     *
+     *     const enemy_ids = collectionfactory.create("#enemyfactory", pos, rot, props, scale);
+     *     // enemy_ids now map to the spawned instance ids:
+     *     //
+     *     // pprint(self.enemy_ids)
+     *     //
+     *     // DEBUG:SCRIPT:
+     *     // {
+     *     //   hash: [/enemy_leader] = hash: [/collection0/enemy_leader],
+     *     //   hash: [/enemy_1] = hash: [/collection0/enemy_1],
+     *     //   hash: [/enemy_2] = hash: [/collection0/enemy_2]
+     *     // }
+     *
+     *     // Send "attack" message to the leader. First look up its instance id.
+     *     const leader_id = enemy_ids.get(hash("/enemy_leader"));
+     *     if (leader_id !== undefined) {
+     *       msg.post(leader_id, "attack");
+     *     }
+     *     return { enemy_ids };
+     *   },
+     * });
+     * ```
+     * @example
+     * How to delete a spawned collection:
+     * ```ts
+     * function delete_enemies(self: { enemy_ids: Hash[] }) {
+     *   go.delete(self.enemy_ids);
+     * }
+     * ```
+     */
+    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: LuaMap<Hash, Record<string | number, unknown>> | Record<string, Record<string | number, unknown>>, scale?: number | Vector3): LuaTable<Hash, Hash>;
+    /**
+     * This returns status of the collection factory.
+     * Calling this function when the factory is not marked as dynamic loading always returns COMP_COLLECTION_FACTORY_STATUS_LOADED.
+     *
+     * @param url - the collection factory component to get status from
+     * @returns status of the collection factory component
+     */
+    function get_status(url: string | Hash | Url): collectionfactory.STATUS;
+    /**
+     * Resources loaded are referenced by the collection factory component until the existing (parent) collection is destroyed or collectionfactory.unload is called.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the collection factory component to load
+     * @param complete_function - function to call when resources are loaded.
+     *
+     * `self`
+     * script_instance The current script instance.
+     * `url`
+     * url url of the collection factory component
+     * `result`
+     * boolean True if resource were loaded successfully
+     * @example
+     * ```ts
+     * // How to load resources of a collection factory prototype.
+     * collectionfactory.load("#factory", (self, url, result) => {});
+     * ```
+     */
+    function load(url: string | Hash | Url, complete_function: (self: unknown, url: Url, result: boolean) => void): void;
+    /**
+     * Changes the prototype for the collection factory.
+     * Setting the prototype to "nil" will revert back to the original prototype.
+     *
+     * @param url - the collection factory component
+     * @param prototype - the path to the new prototype, or `nil`
+     * @example
+     * ```ts
+     * // How to unload the previous prototype's resources, and then spawn a new collection:
+     * collectionfactory.unload("#factory"); // unload the previous resources
+     * collectionfactory.set_prototype("#factory", "/main/levels/level1.collectionc");
+     * const ids = collectionfactory.create("#factory", go.get_world_position(), vmath.quat());
+     * ```
+     */
+    function set_prototype(url: string | Hash | Url, prototype: string | undefined): void;
+    /**
+     * This decreases the reference count for each resource loaded with collectionfactory.load. If reference is zero, the resource is destroyed.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the collection factory component to unload
+     * @example
+     * ```ts
+     * // How to unload resources of a collection factory prototype loaded with collectionfactory.load:
+     * collectionfactory.unload("#factory");
+     * ```
+     */
+    function unload(url: string | Hash | Url): void;
+  }
+}
+
+export {};

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

@@ -0,0 +1,109 @@
+/** @noSelfInFile */
+import type { Hash, Url } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Messages for controlling and interacting with collection proxies
+   * which are used to dynamically load collections into the runtime.
+   */
+  namespace collectionproxy {
+    /**
+     * Data delivered to a collectionproxy.load callback. The available
+     * field depends on the callback message identifier.
+     */
+    interface load_data {
+      /**
+       * Loading progress from 0 to 1 for `proxy_loading`.
+       */
+      progress?: number;
+      /**
+       * Error code for `proxy_error`.
+       */
+      code?: number;
+    }
+    type TIME_STEP_MODE = 0 | 1;
+    type RESULT = typeof collectionproxy.RESULT_ALREADY_LOADED | typeof collectionproxy.RESULT_LOADING | typeof collectionproxy.RESULT_NOT_EXCLUDED;
+    /**
+     * The collection proxy is already loaded, so its collection cannot be changed.
+     */
+    const RESULT_ALREADY_LOADED: number & { readonly __brand: "collectionproxy.RESULT_ALREADY_LOADED" };
+    /**
+     * The collection proxy is loading, so its collection cannot be changed.
+     */
+    const RESULT_LOADING: number & { readonly __brand: "collectionproxy.RESULT_LOADING" };
+    /**
+     * The collection proxy is not excluded from the bundle; only excluded proxies can change collections.
+     */
+    const RESULT_NOT_EXCLUDED: number & { readonly __brand: "collectionproxy.RESULT_NOT_EXCLUDED" };
+    /**
+     * return an indexed table of resources for a collection proxy where the
+     * referenced collection has been excluded using LiveUpdate. Each entry is a
+     * hexadecimal string that represents the data of the specific resource.
+     * This representation corresponds with the filename for each individual
+     * resource that is exported when you bundle an application with LiveUpdate
+     * functionality.
+     *
+     * @param collectionproxy - the collectionproxy to check for resources.
+     * @returns the resources, or an empty list if the
+     * collection was not excluded.
+     * @example
+     * ```ts
+     * function print_resources(self: unknown, cproxy: Url) {
+     *   const resources = collectionproxy.get_resources(cproxy);
+     *   for (const v of resources) {
+     *     print(`Resource: ${v}`);
+     *   }
+     * }
+     * ```
+     */
+    function get_resources(collectionproxy: Url | string | Hash): string[];
+    /**
+     * Loads the collection referenced by a collection proxy. The proxy is also
+     * initialized and the callback receives `proxy_loading`, `proxy_ready`, or
+     * `proxy_error` messages.
+     *
+     * @param url - the collection proxy component
+     * @param options - options table, currently unused
+     * @param callback - callback
+     * @example
+     * ```ts
+     * collectionproxy.load("#proxy", undefined, (self, message_id, message, sender) => {
+     *   if (message_id === hash("proxy_ready")) {
+     *     print("proxy is ready");
+     *   } else if (message_id === hash("proxy_loading")) {
+     *     print("progress", message.progress);
+     *   } else if (message_id === hash("proxy_error")) {
+     *     print("error", message.code);
+     *   }
+     * });
+     * ```
+     */
+    function load(url: string | Hash | Url, options: {} | undefined, callback: (self: unknown, message_id: Hash, message: Record<string | number, unknown>, sender: Url) => void): void;
+    /**
+     * The collection should be loaded by the collection proxy.
+     * Setting the collection to "nil" will revert it back to the original collection.
+     * The collection proxy shouldn't be loaded and should have the 'Exclude' checkbox checked.
+     * This functionality is designed to simplify the management of Live Update resources.
+     *
+     * @param url - the collection proxy component
+     * @param prototype - the path to the new collection, or `nil`
+     * @example
+     * ```ts
+     * // The example assumes the script belongs to an instance with a
+     * // collection-proxy-component with id "proxy".
+     * const [ok, error] = collectionproxy.set_collection("/go#collectionproxy", "/LU/3.collectionc");
+     * if (ok) {
+     *   print("The collection has been changed to /LU/3.collectionc");
+     * } else {
+     *   print("Error changing collection to /LU/3.collectionc ", error);
+     * }
+     * msg.post("/go#collectionproxy", "load");
+     * msg.post("/go#collectionproxy", "init");
+     * msg.post("/go#collectionproxy", "enable");
+     * ```
+     */
+    function set_collection(url: string | Hash | Url, prototype: string | undefined): LuaMultiReturn<[boolean, collectionproxy.RESULT]>;
+  }
+}
+
+export {};

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

@@ -0,0 +1,107 @@
+/** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for interacting with compute programs.
+   */
+  namespace compute {
+    /**
+     * Returns a table of all the shader constants in the compute program.
+     *
+     * @param path - The path to the resource
+     * @returns Information about the shader constants.
+     * @example
+     * ```ts
+     * const constants = compute.get_constants("/my_compute.computec");
+     * ```
+     */
+    function get_constants(path: Hash | string): material.constant_info[];
+    /**
+     * Returns a table of all the texture samplers in the compute program. This function will return all the texture samplers
+     * that are available, even the ones that have not been specified in the compute resource.
+     *
+     * @param path - The path to the resource
+     * @returns Information about the texture samplers.
+     * @example
+     * ```ts
+     * const samplers = compute.get_samplers("/my_compute.computec");
+     * ```
+     */
+    function get_samplers(path: Hash | string): material.sampler_info[];
+    /**
+     * Returns a table of all the textures from the compute program.
+     *
+     * @param path - The path to the resource
+     * @returns Information about the compute textures.
+     * @example
+     * ```ts
+     * const textures = compute.get_textures("/my_compute.computec");
+     * ```
+     */
+    function get_textures(path: Hash | string): material.texture_info[];
+    /**
+     * Sets shader constants in a compute program, if the constants exist.
+     *
+     * @param path - The path to the resource
+     * @param constants - Constant options keyed by constant name. Partial updates are supported.
+     * @example
+     * ```ts
+     * // Set a shader constant in a compute program
+     * export default defineScript({
+     *   init() {
+     *     return { my_view_proj: vmath.matrix4() };
+     *   },
+     *
+     *   update(self) {
+     *     // update the 'tint' constant
+     *     compute.set_constants("/my_compute.computec", {
+     *       tint: { value: vmath.vector4(1, 0, 0, 1) },
+     *     });
+     *     // change the type of the 'view_proj' constant to CONSTANT_TYPE_USER_MATRIX4 so the renderer can set our custom data
+     *     compute.set_constants("/my_compute.computec", {
+     *       view_proj: { value: self.my_view_proj, type: material.CONSTANT_TYPE_USER_MATRIX4 },
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    function set_constants(path: Hash | string, constants: LuaMap<string | Hash, material.constant_options> | Record<string, material.constant_options>): void;
+    /**
+     * Sets texture samplers in a compute program, if the samplers exist. Use this function to change the settings of texture samplers.
+     * To set actual textures that should be bound to the samplers, use the `compute.set_textures` function instead.
+     *
+     * @param path - The path to the resource
+     * @param samplers - Sampler options keyed by sampler name. Partial updates are supported.
+     * @example
+     * ```ts
+     * compute.set_samplers("/my_compute.computec", { texture_sampler: { u_wrap: graphics.TEXTURE_WRAP_REPEAT, v_wrap: graphics.TEXTURE_WRAP_MIRRORED_REPEAT } });
+     * ```
+     */
+    function set_samplers(path: Hash | string, samplers: LuaMap<string | Hash, material.sampler_options> | Record<string, material.sampler_options>): void;
+    /**
+     * Sets textures in a compute program, if the samplers exist.
+     *
+     * @param path - The path to the resource
+     * @param textures - A table keyed by sampler name with texture resources as values.
+     * @example
+     * ```ts
+     * // Set a texture in a compute program from a resource
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_texture: resource.texture() },
+     *
+     *   init(self) {
+     *     compute.set_textures("/my_compute.computec", {
+     *       my_texture: self.my_texture,
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    function set_textures(path: Hash | string, textures: LuaMap<string | Hash, string | Hash> | Record<string, string | Hash>): void;
+  }
+}
+
+export {};