@defold-typescript/types 0.19.4 → 0.20.0

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

@@ -0,0 +1,245 @@
+/** @noSelfInFile */
+import type { Matrix4, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Camera functions, messages and constants.
+   */
+  namespace camera {
+    /**
+     * 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).
+     */
+    const ORTHO_MODE_AUTO_COVER: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_COVER" };
+    /**
+     * 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).
+     */
+    const ORTHO_MODE_AUTO_FIT: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_FIT" };
+    /**
+     * 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): 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): 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
+     * 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): boolean;
+    /**
+     * get far z
+     *
+     * @param camera - camera id
+     * @returns the far z.
+     */
+    function get_far_z(camera?: Url | number): number;
+    /**
+     * get field of view
+     *
+     * @param camera - camera id
+     * @returns the field of view.
+     */
+    function get_fov(camera?: Url | number): number;
+    /**
+     * get near z
+     *
+     * @param camera - camera id
+     * @returns the near z.
+     */
+    function get_near_z(camera?: Url | number): 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): number;
+    /**
+     * get orthographic zoom
+     *
+     * @param camera - camera id
+     * @returns the zoom level when the camera uses orthographic projection.
+     */
+    function get_orthographic_zoom(camera?: Url | number): number;
+    /**
+     * get projection matrix
+     *
+     * @param camera - camera id
+     * @returns the projection matrix.
+     */
+    function get_projection(camera?: Url | number): Matrix4;
+    /**
+     * get view matrix
+     *
+     * @param camera - camera id
+     * @returns the view matrix.
+     */
+    function get_view(camera?: Url | number): 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) {
+     *         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): 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) {
+     *         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): 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 | 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 | 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 | 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 | undefined, fov: number): void;
+    /**
+     * set near z
+     *
+     * @param camera - camera id
+     * @param near_z - the near z.
+     */
+    function set_near_z(camera: Url | number | 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 | undefined, mode: number): void;
+    /**
+     * set orthographic zoom
+     *
+     * @param camera - camera id
+     * @param orthographic_zoom - the zoom level when the camera uses orthographic projection.
+     */
+    function set_orthographic_zoom(camera: Url | number | 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): Vector3;
+  }
+}
+
+export {};

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

@@ -0,0 +1,146 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, 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 {
+    /**
+     * loaded
+     */
+    const STATUS_LOADED: number & { readonly __brand: "collectionfactory.STATUS_LOADED" };
+    /**
+     * loading
+     */
+    const STATUS_LOADING: number & { readonly __brand: "collectionfactory.STATUS_LOADING" };
+    /**
+     * 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
+     * ```ts
+     * // How to spawn a collection of game objects:
+     * export default defineScript({
+     *   init(self) {
+     *     // 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 = {
+     *       [hash("/enemy_leader")]: { health: 1000.0 },
+     *       [hash("/enemy_1")]: { health: 200.0 },
+     *       [hash("/enemy_2")]: { health: 400.0, color: hash("green") },
+     *     };
+     *
+     *     self.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 = self.enemy_ids[hash("/enemy_leader")];
+     *     msg.post(leader_id, "attack");
+     *   },
+     * });
+     *
+     * // How to delete a spawned collection:
+     * go.delete(self.enemy_ids);
+     * ```
+     */
+    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): LuaMap<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
+     *
+     * - `collectionfactory.STATUS_UNLOADED`
+     *
+     * - `collectionfactory.STATUS_LOADING`
+     *
+     * - `collectionfactory.STATUS_LOADED`
+     */
+    function get_status(url?: string | Hash | Url): Opaque<"constant">;
+    /**
+     * 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`
+     * object The current object.
+     * `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: unknown, result: unknown) => 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): 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.12.4/collectionproxy.d.ts

@@ -0,0 +1,71 @@
+/** @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 {
+    /**
+     * It's impossible to change the collection if the collection is already loaded.
+     */
+    const RESULT_ALREADY_LOADED: number & { readonly __brand: "collectionproxy.RESULT_ALREADY_LOADED" };
+    /**
+     * It's impossible to change the collection while the collection proxy is loading.
+     */
+    const RESULT_LOADING: number & { readonly __brand: "collectionproxy.RESULT_LOADING" };
+    /**
+     * It's impossible to change the collection for a proxy that isn't excluded.
+     */
+    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, cproxy) {
+     *   const resources = collectionproxy.get_resources(cproxy);
+     *   for (const v of resources) {
+     *     print(`Resource: ${v}`);
+     *   }
+     * }
+     * ```
+     */
+    function get_resources(collectionproxy: Url): Hash[];
+    /**
+     * 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): LuaMultiReturn<[boolean, number]>;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/crash.d.ts

@@ -0,0 +1,143 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Native crash logging functions and constants.
+   */
+  namespace crash {
+    /**
+     * android build fingerprint
+     */
+    const SYSFIELD_ANDROID_BUILD_FINGERPRINT: number & { readonly __brand: "crash.SYSFIELD_ANDROID_BUILD_FINGERPRINT" };
+    /**
+     * system device language as reported by sys.get_sys_info
+     */
+    const SYSFIELD_DEVICE_LANGUAGE: number & { readonly __brand: "crash.SYSFIELD_DEVICE_LANGUAGE" };
+    /**
+     * device model as reported by sys.get_sys_info
+     */
+    const SYSFIELD_DEVICE_MODEL: number & { readonly __brand: "crash.SYSFIELD_DEVICE_MODEL" };
+    /**
+     * engine version as hash
+     */
+    const SYSFIELD_ENGINE_HASH: number & { readonly __brand: "crash.SYSFIELD_ENGINE_HASH" };
+    /**
+     * engine version as release number
+     */
+    const SYSFIELD_ENGINE_VERSION: number & { readonly __brand: "crash.SYSFIELD_ENGINE_VERSION" };
+    /**
+     * system language as reported by sys.get_sys_info
+     */
+    const SYSFIELD_LANGUAGE: number & { readonly __brand: "crash.SYSFIELD_LANGUAGE" };
+    /**
+     * device manufacturer as reported by sys.get_sys_info
+     */
+    const SYSFIELD_MANUFACTURER: number & { readonly __brand: "crash.SYSFIELD_MANUFACTURER" };
+    /**
+     * The max number of sysfields.
+     */
+    const SYSFIELD_MAX: number & { readonly __brand: "crash.SYSFIELD_MAX" };
+    /**
+     * system name as reported by sys.get_sys_info
+     */
+    const SYSFIELD_SYSTEM_NAME: number & { readonly __brand: "crash.SYSFIELD_SYSTEM_NAME" };
+    /**
+     * system version as reported by sys.get_sys_info
+     */
+    const SYSFIELD_SYSTEM_VERSION: number & { readonly __brand: "crash.SYSFIELD_SYSTEM_VERSION" };
+    /**
+     * system territory as reported by sys.get_sys_info
+     */
+    const SYSFIELD_TERRITORY: number & { readonly __brand: "crash.SYSFIELD_TERRITORY" };
+    /**
+     * The max number of user fields.
+     */
+    const USERFIELD_MAX: number & { readonly __brand: "crash.USERFIELD_MAX" };
+    /**
+     * The max size of a single user field.
+     */
+    const USERFIELD_SIZE: number & { readonly __brand: "crash.USERFIELD_SIZE" };
+    /**
+     * A table is returned containing the addresses of the call stack.
+     *
+     * @param handle - crash dump handle
+     * @returns table containing the backtrace
+     */
+    function get_backtrace(handle: number): Record<string | number, unknown>;
+    /**
+     * The format of read text blob is platform specific
+     * and not guaranteed
+     * but can be useful for manual inspection.
+     *
+     * @param handle - crash dump handle
+     * @returns string with the platform specific data
+     */
+    function get_extra_data(handle: number): string;
+    /**
+     * The function returns a table containing entries with sub-tables that
+     * have fields 'name' and 'address' set for all loaded modules.
+     *
+     * @param handle - crash dump handle
+     * @returns module table
+     */
+    function get_modules(handle: number): Record<string | number, unknown>;
+    /**
+     * read signal number from a crash report
+     *
+     * @param handle - crash dump handle
+     * @returns signal number
+     */
+    function get_signum(handle: number): number;
+    /**
+     * reads a system field from a loaded crash dump
+     *
+     * @param handle - crash dump handle
+     * @param index - system field enum. Must be less than crash.SYSFIELD_MAX
+     * @returns value recorded in the crash dump, or `nil` if it didn't exist
+     */
+    function get_sys_field(handle: number, index: number): string | unknown;
+    /**
+     * reads user field from a loaded crash dump
+     *
+     * @param handle - crash dump handle
+     * @param index - user data slot index
+     * @returns user data value recorded in the crash dump
+     */
+    function get_user_field(handle: number, index: number): string;
+    /**
+     * The crash dump will be removed from disk upon a successful
+     * load, so loading is one-shot.
+     *
+     * @returns handle to the loaded dump, or `nil` if no dump was found
+     */
+    function load_previous(): number | unknown;
+    /**
+     * releases a previously loaded crash dump
+     *
+     * @param handle - handle to loaded crash dump
+     */
+    function release(handle: number): void;
+    /**
+     * Crashes occuring before the path is set will be stored to a default engine location.
+     *
+     * @param path - file path to use
+     */
+    function set_file_path(path: string): void;
+    /**
+     * Store a user value that will get written to a crash dump when
+     * a crash occurs. This can be user id:s, breadcrumb data etc.
+     * There are 32 slots indexed from 0. Each slot stores at most 255 characters.
+     *
+     * @param index - slot index. 0-indexed
+     * @param value - string value to store
+     */
+    function set_user_field(index: number, value: string): void;
+    /**
+     * Performs the same steps as if a crash had just occured but
+     * allows the program to continue.
+     * The generated dump can be read by crash.load_previous
+     */
+    function write_dump(): void;
+  }
+}
+
+export {};