@defold-typescript/types 0.19.4 → 0.20.0

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

@@ -0,0 +1,205 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions and messages for interacting with model components.
+   */
+  namespace model {
+    /**
+     * Cancels all animation on a model component.
+     *
+     * @param url - the model for which to cancel the animation
+     */
+    function cancel(url: string | Hash | Url): void;
+    /**
+     * Get AABB of the whole model in local coordinate space.
+     * AABB information return as a table with `min` and `max` fields, where `min` and `max` has type `vmath.vector3`.
+     *
+     * @param url - the model
+     * @returns A table containing AABB of the model. If model has no meshes - return vmath.vector3(0,0,0) for min and max fields.
+     * @example
+     * ```ts
+     * model.get_aabb("#model"); // => { min = vmath.vector3(-2.5, -3.0, 0), max = vmath.vector3(1.5, 5.5, 0) }
+     * model.get_aabb("#empty"); // => { min = vmath.vector3(0, 0, 0), max = vmath.vector3(0, 0, 0) }
+     * ```
+     */
+    function get_aabb(url: string | Hash | Url): { min: Vector3; max: Vector3 };
+    /**
+     * Gets the id of the game object that corresponds to a model skeleton bone.
+     * The returned game object can be used for parenting and transform queries.
+     * This function has complexity `O(n)`, where `n` is the number of bones in the model skeleton.
+     * Game objects corresponding to a model skeleton bone can not be individually deleted.
+     *
+     * @param url - the model to query
+     * @param bone_id - id of the corresponding bone
+     * @returns id of the game object
+     * @example
+     * ```ts
+     * // The following examples assume that the model component has id "model".
+     * // How to parent the game object of the calling script to the "right_hand" bone
+     * // of the model in a player game object:
+     * export default defineScript({
+     *   init(self) {
+     *     const parent = model.get_go("player#model", "right_hand");
+     *     msg.post(".", "set_parent", { parent_id: parent });
+     *   },
+     * });
+     * ```
+     */
+    function get_go(url: string | Hash | Url, bone_id: string | Hash): Hash;
+    /**
+     * Get AABB of all meshes.
+     * AABB information return as a table with `min` and `max` fields, where `min` and `max` has type `vmath.vector3`.
+     *
+     * @param url - the model
+     * @returns A table containing info about all AABB in the format
+     * @example
+     * ```ts
+     * model.get_mesh_aabb("#model"); // => { hash("Sword") = { min = vmath.vector3(-0.5, -0.5, 0), max = vmath.vector3(0.5, 0.5, 0) }, hash("Shield") = { min = vmath.vector3(-0.5, -0.5, -0.5), max = vmath.vector3(0.5, 0.5, 0.5) } }
+     * ```
+     */
+    function get_mesh_aabb(url: string | Hash | Url): LuaMap<Hash, { min: Vector3; max: Vector3 }>;
+    /**
+     * Get the enabled state of a mesh
+     *
+     * @param url - the model
+     * @param mesh_id - the id of the mesh
+     * @returns true if the mesh is visible, false otherwise
+     * @example
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     if (model.get_mesh_enabled("#model", "Sword")) {
+     *       // set properties specific for the sword
+     *       self.weapon_properties = game.data.weapons["Sword"];
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function get_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash | Url): boolean;
+    /**
+     * Plays an animation on a model component with specified playback
+     * mode and parameters.
+     * An optional completion callback function can be provided that will be called when
+     * the animation has completed playing. If no function is provided,
+     * a model_animation_done message is sent to the script that started the animation.
+     * The callback is not called (or message sent) if the animation is
+     * cancelled with model.cancel. The callback is called (or message sent) only for
+     * animations that play with the following playback modes:
+     *
+     * - `go.PLAYBACK_ONCE_FORWARD`
+     *
+     * - `go.PLAYBACK_ONCE_BACKWARD`
+     *
+     * - `go.PLAYBACK_ONCE_PINGPONG`
+     *
+     * @param url - the model for which to play the animation
+     * @param anim_id - id of the animation to play
+     * @param playback - playback mode of the animation
+     *
+     * - `go.PLAYBACK_ONCE_FORWARD`
+     *
+     * - `go.PLAYBACK_ONCE_BACKWARD`
+     *
+     * - `go.PLAYBACK_ONCE_PINGPONG`
+     *
+     * - `go.PLAYBACK_LOOP_FORWARD`
+     *
+     * - `go.PLAYBACK_LOOP_BACKWARD`
+     *
+     * - `go.PLAYBACK_LOOP_PINGPONG`
+     * @param play_properties - optional table with properties
+     * Play properties table:
+     *
+     * `blend_duration`
+     * number Duration of a linear blend between the current and new animation.
+     * `offset`
+     * number The normalized initial value of the animation cursor when the animation starts playing.
+     * `playback_rate`
+     * number The rate with which the animation will be played. Must be positive.
+     * @param complete_function - function to call when the animation has completed.
+     *
+     * `self`
+     * object The current object.
+     * `message_id`
+     * hash The name of the completion message, `"model_animation_done"`.
+     * `message`
+     * table Information about the completion:
+     *
+     * - hash `animation_id` - the animation that was completed.
+     *
+     * - constant `playback` - the playback mode for the animation.
+     *
+     * `sender`
+     * url The invoker of the callback: the model component.
+     * @example
+     * ```ts
+     * // The following examples assume that the model has id "model".
+     * // How to play the "jump" animation followed by the "run" animation:
+     * function anim_done(self, message_id, message, sender) {
+     *   if (message_id === hash("model_animation_done")) {
+     *     if (message.animation_id === hash("jump")) {
+     *       // open animation done, chain with "run"
+     *       const properties = { blend_duration: 0.2 };
+     *       model.play_anim(url, "run", go.PLAYBACK_LOOP_FORWARD, properties, anim_done);
+     *     }
+     *   }
+     * }
+     *
+     * export default defineScript({
+     *   init(self) {
+     *     const url = msg.url("#model");
+     *     const play_properties = { blend_duration: 0.1 };
+     *     // first blend during 0.1 sec into the jump, then during 0.2 s into the run animation
+     *     model.play_anim(url, "jump", go.PLAYBACK_ONCE_FORWARD, play_properties, anim_done);
+     *   },
+     * });
+     * ```
+     */
+    function play_anim(url: string | Hash | Url, anim_id: string | Hash, playback: Opaque<"constant">, play_properties?: { blend_duration?: number; offset?: number; playback_rate?: number }, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void): void;
+    /**
+     * Enable or disable visibility of a mesh
+     *
+     * @param url - the model
+     * @param mesh_id - the id of the mesh
+     * @param enabled - true if the mesh should be visible, false if it should be hideen
+     * @example
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     model.set_mesh_enabled("#model", "Sword", false); // hide the sword
+     *     model.set_mesh_enabled("#model", "Axe", true); // show the axe
+     *   },
+     * });
+     * ```
+     */
+    function set_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash | Url, enabled: boolean): void;
+    interface properties {
+      /**
+       * The current animation set on the component. The type of the property is hash.
+       */
+      animation: Hash;
+      /**
+       * The normalized animation cursor. The type of the property is number.
+       * Please note that model events may not fire as expected when the cursor is manipulated directly.
+       */
+      cursor: number;
+      /**
+       * The material used when rendering the model. The type of the property is hash.
+       */
+      material: Hash;
+      /**
+       * The animation playback rate. A multiplier to the animation playback rate. The type of the property is number.
+       */
+      playback_rate: number;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      textureN: Hash;
+    }
+  }
+}
+
+export {};

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

@@ -0,0 +1,10 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Functions for passing messages and constructing URL objects.
+   */
+  namespace msg {
+  }
+}
+
+export {};

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

@@ -0,0 +1,166 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions and properties for controlling particle effect component playback and
+   * shader constants.
+   */
+  namespace particlefx {
+    /**
+     * The emitter is not spawning any particles, but has particles that are still alive.
+     */
+    const EMITTER_STATE_POSTSPAWN: number & { readonly __brand: "particlefx.EMITTER_STATE_POSTSPAWN" };
+    /**
+     * The emitter will be in this state when it has been started but before spawning any particles. Normally the emitter is in this state for a short time, depending on if a start delay has been set for this emitter or not.
+     */
+    const EMITTER_STATE_PRESPAWN: number & { readonly __brand: "particlefx.EMITTER_STATE_PRESPAWN" };
+    /**
+     * The emitter does not have any living particles and will not spawn any particles in this state.
+     */
+    const EMITTER_STATE_SLEEPING: number & { readonly __brand: "particlefx.EMITTER_STATE_SLEEPING" };
+    /**
+     * The emitter is spawning particles.
+     */
+    const EMITTER_STATE_SPAWNING: number & { readonly __brand: "particlefx.EMITTER_STATE_SPAWNING" };
+    /**
+     * Starts playing a particle FX component.
+     * Particle FX started this way need to be manually stopped through `particlefx.stop()`.
+     * Which particle FX to play is identified by the URL.
+     * A particle FX will continue to emit particles even if the game object the particle FX component belonged to is deleted. You can call `particlefx.stop()` to stop it from emitting more particles.
+     *
+     * @param url - the particle fx that should start playing.
+     * @param emitter_state_function - optional callback function that will be called when an emitter attached to this particlefx changes state.
+     *
+     * `self`
+     * object The current object
+     * `id`
+     * hash The id of the particle fx component
+     * `emitter`
+     * hash The id of the emitter
+     * `state`
+     * constant the new state of the emitter:
+     *
+     * - `particlefx.EMITTER_STATE_SLEEPING`
+     *
+     * - `particlefx.EMITTER_STATE_PRESPAWN`
+     *
+     * - `particlefx.EMITTER_STATE_SPAWNING`
+     *
+     * - `particlefx.EMITTER_STATE_POSTSPAWN`
+     * @example
+     * ```ts
+     * // How to play a particle fx when a game object is created.
+     * // The callback receives the hash of the path to the particlefx, the hash of the id
+     * // of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
+     * function emitter_state_change(self, id, emitter, state) {
+     *   if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
+     *     // exhaust is done spawning particles...
+     *   }
+     * }
+     *
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.play("#particlefx", emitter_state_change);
+     *   },
+     * });
+     * ```
+     */
+    function play(url: string | Hash | Url, emitter_state_function?: (self: unknown, id: unknown, emitter: unknown, state: unknown) => void): void;
+    /**
+     * Resets a shader constant for a particle FX component emitter.
+     * The constant must be defined in the material assigned to the emitter.
+     * Resetting a constant through this function implies that the value defined in the material will be used.
+     * Which particle FX to reset a constant for is identified by the URL.
+     *
+     * @param url - the particle FX that should have a constant reset
+     * @param emitter - the id of the emitter
+     * @param constant - the name of the constant
+     * @example
+     * ```ts
+     * // The following examples assume that the particle FX has id "particlefx", it
+     * // contains an emitter with the id "emitter" and that the default-material in
+     * // builtins is used, which defines the constant "tint".
+     * // If you assign a custom material to the sprite, you can reset the constants
+     * // defined there in the same manner.
+     * // How to reset the tinting of particles from an emitter:
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.reset_constant("#particlefx", "emitter", "tint");
+     *   },
+     * });
+     * ```
+     */
+    function reset_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash): void;
+    /**
+     * Sets a shader constant for a particle FX component emitter.
+     * The constant must be defined in the material assigned to the emitter.
+     * Setting a constant through this function will override the value set for that constant in the material.
+     * The value will be overridden until particlefx.reset_constant is called.
+     * Which particle FX to set a constant for is identified by the URL.
+     *
+     * @param url - the particle FX that should have a constant set
+     * @param emitter - the id of the emitter
+     * @param constant - the name of the constant
+     * @param value - the value of the constant
+     * @example
+     * ```ts
+     * // The following examples assume that the particle FX has id "particlefx", it
+     * // contains an emitter with the id "emitter" and that the default-material in
+     * // builtins is used, which defines the constant "tint".
+     * // If you assign a custom material to the sprite, you can reset the constants
+     * // defined there in the same manner.
+     * // How to tint particles from an emitter red:
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.set_constant("#particlefx", "emitter", "tint", vmath.vector4(1, 0, 0, 1));
+     *   },
+     * });
+     * ```
+     */
+    function set_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash, value: Vector4): void;
+    /**
+     * Stops a particle FX component from playing.
+     * Stopping a particle FX does not remove already spawned particles.
+     * Which particle FX to stop is identified by the URL.
+     *
+     * @param url - the particle fx that should stop playing
+     * @param options - Options when stopping the particle fx. Supported options:
+     *
+     * - boolean `clear`: instantly clear spawned particles
+     * @example
+     * ```ts
+     * // How to stop a particle fx when a game object is deleted and immediately also
+     * // clear any spawned particles:
+     * export default defineScript({
+     *   final(self) {
+     *     particlefx.stop("#particlefx", { clear: true });
+     *   },
+     * });
+     * ```
+     */
+    function stop(url: string | Hash | Url, options?: { clear?: boolean }): void;
+    interface properties {
+      /**
+       * The animation used during rendering by an emitter in a particle FX component.
+       * The property type is a hash and refers to a valid animation in an atlas or a tile source resource.
+       * If the animation isn't found, and error will be thrown.
+       */
+      animation: Hash;
+      /**
+       * The image used during rendering by an emitter in a particle FX component.
+       * The property type is a hash and refers to an image resource (atlas or tile source).
+       * Note: When setting the image, if the currently playing animation of the emitter
+       * isn't found in the new image, the animation will be set to the first animation found.
+       */
+      image: Hash;
+      /**
+       * The material used during rendering by an emitter in a particle FX component.
+       * The property type is a hash and refers to a material resource.
+       */
+      material: Hash;
+    }
+  }
+}
+
+export {};