@defold-typescript/types 0.19.3 → 0.20.0

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

@@ -0,0 +1,123 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Quaternion, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for controlling factory components which are used to
+   * dynamically spawn game objects into the runtime.
+   */
+  namespace factory {
+    /**
+     * loaded
+     */
+    const STATUS_LOADED: number & { readonly __brand: "factory.STATUS_LOADED" };
+    /**
+     * loading
+     */
+    const STATUS_LOADING: number & { readonly __brand: "factory.STATUS_LOADING" };
+    /**
+     * unloaded
+     */
+    const STATUS_UNLOADED: number & { readonly __brand: "factory.STATUS_UNLOADED" };
+    /**
+     * The URL identifies which factory should create the game object.
+     * If the game object is created inside of the frame (e.g. from an update callback), the game object will be created instantly, but none of its component will be updated in the same frame.
+     * Properties defined in scripts in the created game object can be overridden through the properties-parameter below.
+     * See go.property for more information on script properties.
+     * Calling factory.create on a factory that is marked as dynamic without having loaded resources
+     * using factory.load will synchronously load and create resources which may affect application performance.
+     *
+     * @param url - the factory that should create a game object.
+     * @param position - the position of the new game object, the position of the game object calling `factory.create()` is used by default, or if the value is `nil`.
+     * @param rotation - the rotation of the new game object, the rotation of the game object calling `factory.create()` is used by default, or if the value is `nil`.
+     * @param properties - the properties defined in a script attached to the new game object.
+     * @param scale - the scale of the new game object (must be greater than 0), the scale of the game object containing the factory is used by default, or if the value is `nil`
+     * @returns the global id of the spawned game object
+     * @example
+     * ```ts
+     * // How to create a new game object:
+     * export default defineScript({
+     *   init(self) {
+     *     // create a new game object and provide property values
+     *     self.my_created_object = factory.create("#factory", undefined, undefined, { my_value: 1 });
+     *     // communicate with the object
+     *     msg.post(self.my_created_object, "hello");
+     *   },
+     * });
+     *
+     * // And then let the new game object have a script attached:
+     * go.property("my_value", 0);
+     *
+     * export default defineScript({
+     *   init(self) {
+     *     // do something with self.my_value which is now one
+     *   },
+     * });
+     * ```
+     */
+    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): Hash;
+    /**
+     * This returns status of the factory.
+     * Calling this function when the factory is not marked as dynamic loading always returns
+     * factory.STATUS_LOADED.
+     *
+     * @param url - the factory component to get status from
+     * @returns status of the factory component
+     *
+     * - `factory.STATUS_UNLOADED`
+     *
+     * - `factory.STATUS_LOADING`
+     *
+     * - `factory.STATUS_LOADED`
+     */
+    function get_status(url?: string | Hash | Url): Opaque<"constant">;
+    /**
+     * Resources are referenced by the factory component until the existing (parent) collection is destroyed or factory.unload is called.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the factory component to load
+     * @param complete_function - function to call when resources are loaded.
+     *
+     * `self`
+     * object The current object.
+     * `url`
+     * url url of the factory component
+     * `result`
+     * boolean True if resources were loaded successfully
+     * @example
+     * ```ts
+     * // How to load resources of a factory prototype.
+     * factory.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 factory.
+     *
+     * @param url - the 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 game object:
+     * factory.unload("#factory"); // unload the previous resources
+     * factory.set_prototype("#factory", "/main/levels/enemyA.goc");
+     * const id = factory.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 factory.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 factory component to unload
+     * @example
+     * ```ts
+     * // How to unload resources of a factory prototype loaded with factory.load:
+     * factory.unload("#factory");
+     * ```
+     */
+    function unload(url?: string | Hash | Url): void;
+  }
+}
+
+export {};

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

@@ -0,0 +1,81 @@
+/** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions, messages and properties used to manipulate font resources.
+   */
+  namespace font {
+    /**
+     * associates a ttf resource to a .fontc file.
+     *
+     * @param fontc - The path to the .fontc resource
+     * @param ttf - The path to the .ttf resource
+     * @example
+     * ```ts
+     * const font_hash = hash("/assets/fonts/roboto.fontc");
+     * const ttf_hash = hash("/assets/fonts/Roboto/Roboto-Bold.ttf");
+     * font.add_font(font_hash, ttf_hash);
+     * ```
+     */
+    function add_font(fontc: string | Hash, ttf: string | Hash): void;
+    /**
+     * Gets information about a font, such as the associated font files
+     *
+     * @param fontc - The path to the .fontc resource
+     * @returns the information table contains these fields:
+     *
+     * `path`
+     * hash The path hash of the current file.
+     * `fonts`
+     *
+     * table An array of associated font (e.g. .ttf) files. Each item is a table that contains:
+     *
+     * `path`
+     * string The path of the font file
+     * `path_hash`
+     * hash The path of the font file
+     */
+    function get_info(fontc: string | Hash): { path: Hash; fonts: { path: string; path_hash: Hash }[] };
+    /**
+     * prepopulates the font glyph cache with rasterised glyphs
+     *
+     * @param fontc - The path to the .fontc resource
+     * @param text - The text to layout
+     * @param callback - (optional) A callback function that is called after the request is finished
+     *
+     * `self`
+     * object The current object.
+     * `request_id`
+     * number The request id
+     * `result`
+     * boolean True if request was succesful
+     * `errstring`
+     * string `nil` if the request was successful
+     * @returns Returns the asynchronous request id
+     * @example
+     * ```ts
+     * const font_hash = hash("/assets/fonts/roboto.fontc");
+     * font.prewarm_text(font_hash, "Some text", (self, request_id, result, errstring) => {
+     *   // cache is warm, show the text!
+     * });
+     * ```
+     */
+    function prewarm_text(fontc: string | Hash, text: string, callback?: (self: unknown, request_id: unknown, result: unknown, errstring: unknown) => void): number;
+    /**
+     * associates a ttf resource to a .fontc file
+     *
+     * @param fontc - The path to the .fontc resource
+     * @param ttf - The path to the .ttf resource
+     * @example
+     * ```ts
+     * const font_hash = hash("/assets/fonts/roboto.fontc");
+     * const ttf_hash = hash("/assets/fonts/Roboto/Roboto-Bold.ttf");
+     * font.remove_font(font_hash, ttf_hash);
+     * ```
+     */
+    function remove_font(fontc: string | Hash, ttf: string | Hash): void;
+  }
+}
+
+export {};