@defold-typescript/types 0.49.0 → 0.50.0

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

@@ -0,0 +1,121 @@
+/** @noSelfInFile */
+import type { Hash, 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 {
+    type Status = typeof factory.STATUS_UNLOADED | typeof factory.STATUS_LOADING | typeof factory.STATUS_LOADED;
+    type STATUS = typeof factory.STATUS_LOADED | typeof factory.STATUS_LOADING | typeof factory.STATUS_UNLOADED;
+    /**
+     * The factory resources are loaded.
+     */
+    const STATUS_LOADED: number & { readonly __brand: "factory.STATUS_LOADED" };
+    /**
+     * The factory resources are loading.
+     */
+    const STATUS_LOADING: number & { readonly __brand: "factory.STATUS_LOADING" };
+    /**
+     * The factory resources are 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
+     * How to create a new game object:
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     // create a new game object and provide property values
+     *     const created = factory.create("#factory", undefined, undefined, { my_value: 1 });
+     *     // communicate with the object
+     *     msg.post(created, "hello");
+     *   },
+     * });
+     * ```
+     * @example
+     * And then let the new game object have a script attached:
+     * ```ts
+     * 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?: LuaMap<string | Hash, unknown> | Record<string, 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
+     */
+    function get_status(url: string | Hash | Url): factory.STATUS;
+    /**
+     * 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`
+     * script_instance The current script instance.
+     * `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: Url, result: boolean) => 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 | undefined): 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.13.2/font.d.ts

@@ -0,0 +1,123 @@
+/** @noSelfInFile */
+import type { Hash } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions, messages and properties used to manipulate font resources.
+   */
+  namespace font {
+    /**
+     * Associated font file information
+     */
+    interface file_info {
+      /**
+       * path to the `.ttf` or `.otf` font file
+       */
+      path: string;
+      /**
+       * hashed font-file path
+       */
+      path_hash: Hash;
+    }
+    /**
+     * Font resource information
+     */
+    interface info {
+      /**
+       * path hash of the `.fontc` resource
+       */
+      path: Hash;
+      /**
+       * associated font files
+       */
+      fonts: font.file_info[];
+    }
+    /**
+     * associates a TTF or OTF resource to a .fontc file.
+     *
+     * @param fontc - The path to the .fontc resource
+     * @param font - The path to the .ttf or .otf 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, font: string | Hash): void;
+    /**
+     * Gets information about a font, such as the associated font files
+     *
+     * @param fontc - The path to the .fontc resource
+     * @returns font resource information
+     */
+    function get_info(fontc: string | Hash): font.info;
+    /**
+     * 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`
+     * script_instance The current script instance.
+     * `request_id`
+     * integer 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: number, result: boolean, errstring?: string) => void): number;
+    /**
+     * associates a TTF or OTF resource to a .fontc file
+     *
+     * @param fontc - The path to the .fontc resource
+     * @param font - The path to the .ttf or .otf 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, font: string | Hash): void;
+    /**
+     * Named object styles are resolved by text layouts without reshaping text.
+     * A `link` tag uses `link` by default. Callers may select another named style,
+     * such as `link:hover` or `link:active`, in response to input.
+     * Font collections initially define these named styles. Each default contains
+     * a normalized RGBA face-color multiplier and no effects. The default `link`
+     * style also uses a solid underline, which remains when hover or active colors
+     * are applied:
+     *
+     * - `link`: `(0.10, 0.45, 0.90, 1.0)`, solid underline
+     * - `link:hover`: `(0.30, 0.65, 1.00, 1.0)`
+     * - `link:active`: `(0.05, 0.30, 0.70, 1.0)`
+     *
+     * The definition is an opening-only sequence of rich-text tags. Tags are
+     * implicitly closed in reverse order. Calling this function replaces the
+     * named render properties and effects. Resource-defined decorations, such as
+     * the default `link` underline, remain unchanged.
+     *
+     * @param fontc - The path to the `.fontc` resource.
+     * @param name - Style name, for example `link:hover`.
+     * @param style - Opening-only render-style markup.
+     * @example
+     * ```ts
+     * font.set_style("/fonts/ui.fontc", "link:hover", "<color=#66b3ff><outline color=#000000 size=1><shake amplitude=0.2>");
+     * ```
+     */
+    function set_style(fontc: string | Hash, name: string, style: string): void;
+  }
+}
+
+export {};