@defold-typescript/types 0.48.0 → 0.50.0

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

@@ -0,0 +1,287 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Model API documentation
+   */
+  namespace model {
+    /**
+     * Axis-aligned bounding box
+     */
+    interface aabb {
+      /**
+       * minimum local-space bounds
+       */
+      min: Vector3;
+      /**
+       * maximum local-space bounds
+       */
+      max: Vector3;
+    }
+    /**
+     * Model animation playback properties
+     */
+    interface play_properties {
+      /**
+       * duration of a linear blend from the current animation
+       */
+      blend_duration?: number;
+      /**
+       * normalized initial animation cursor
+       */
+      offset?: number;
+      /**
+       * positive animation playback rate
+       */
+      playback_rate?: number;
+    }
+    /**
+     * 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.
+     *
+     * @param url - the model
+     * @returns model bounds; an empty model returns zero vectors
+     * @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): model.aabb;
+    /**
+     * Returns a table of numbers with one entry per morph target on the first mesh of the model that has morph targets.
+     * Values reflect the rig state at call time (after animation, and any active script override from model.set_blend_weights).
+     *
+     * @param url - the model component
+     * @returns array of weight values, or empty table if the model has no morph targets
+     * @example
+     * ```ts
+     * const w = model.get_blend_weights("#model");
+     * w.forEach((weight, i) => {
+     *   print(i + 1, weight);
+     * });
+     * // change the data in the table and then set the weights again
+     * w[0] = 0.75;
+     * w[1] = 0.25;
+     * model.set_blend_weights("#model", w);
+     * ```
+     */
+    function get_blend_weights(url: string | Hash | Url): number[];
+    /**
+     * 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.
+     *
+     * @param url - the model
+     * @returns mesh bounds keyed by mesh identifier
+     * @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): LuaTable<Hash, model.aabb>;
+    /**
+     * 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
+     * // shared weapon data, e.g. required from your own module
+     * const game = { data: { weapons: { Sword: { damage: 10 } } } };
+     *
+     * export default defineScript({
+     *   init() {
+     *     if (model.get_mesh_enabled("#model", "Sword")) {
+     *       // set properties specific for the sword
+     *       return { weapon_properties: game.data.weapons["Sword"] };
+     *     }
+     *     return { weapon_properties: undefined };
+     *   },
+     * });
+     * ```
+     */
+    function get_mesh_enabled(url: string | Hash | Url, mesh_id: string | Hash): 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
+     * @param play_properties - optional playback properties
+     * @param complete_function - function to call when the animation has completed.
+     *
+     * `self`
+     * script_instance The current script instance.
+     * `message_id`
+     * hash The name of the completion message, `"model_animation_done"`.
+     * `message`
+     * message.model.model_animation_done Information about the completion.
+     * `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:
+     * const url = msg.url("#model");
+     *
+     * function anim_done(self: unknown, message_id: unknown, message: unknown, sender: unknown) {
+     *   if (message_id === hash("model_animation_done")) {
+     *     const { animation_id } = message as { animation_id: Hash };
+     *     if (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 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: go.PLAYBACK, play_properties?: model.play_properties, complete_function?: (self: unknown, message_id: Hash, message: BuiltinMessages["model_animation_done"], sender: Url) => void): void;
+    /**
+     * Resets a shader constant for a model component.
+     * The constant must be defined in the material assigned to the model.
+     * Resetting a constant through this function implies that the value defined in the material will be used.
+     * Which model to reset a constant for is identified by the URL.
+     *
+     * @param url - the model that should have a constant reset.
+     * @param constant - name of the constant.
+     * @example
+     * ```ts
+     * model.reset_constant("#model", "tint");
+     * ```
+     */
+    function reset_constant(url: string | Hash | Url, constant: string | Hash): void;
+    /**
+     * Copies numeric values from `weights` into each morph target slot for every mesh on the model that has morph targets.
+     * At most as many weights are applied as each mesh has morph targets; extra entries in the table are ignored.
+     * Missing weights leave the tail zero-filled for meshes with more targets than entries.
+     * The override is re-applied every frame after animations run, until cleared by omitting `weights` or passing `nil`.
+     * To reset the weights, use `model.set_blend_weights(url)` or `model.set_blend_weights(url, nil)`.
+     *
+     * @param url - the model component
+     * @param weights - array of weight values (1-based indices). Omit or pass `nil` to clear the override and return morphs to animation only
+     * @example
+     * ```ts
+     * // set the weights for the first 4 morph targets
+     * model.set_blend_weights("#model", [0, 1, 0.5, 0]);
+     * // clear the override, animation will continue if the weights are driven by an animation
+     * model.set_blend_weights("#model"); // clear script override
+     * ```
+     */
+    function set_blend_weights(url: string | Hash | Url, weights?: number[]): 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, 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 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
+       */
+      texture0: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture1: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture2: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture3: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture4: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture5: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture6: Hash;
+      /**
+       * The texture hash id of the model. Used for getting/setting model texture for unit 0-7
+       */
+      texture7: Hash;
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/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.13.2/particlefx.d.ts

@@ -0,0 +1,155 @@
+/** @noSelfInFile */
+import type { Hash, Matrix4, Url, Vector4 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions and properties for controlling particle effect component playback and
+   * shader constants.
+   */
+  namespace particlefx {
+    /**
+     * Options used when stopping particle effects.
+     */
+    interface stop_options {
+      /**
+       * Instantly clear spawned particles.
+       */
+      clear?: boolean;
+    }
+    type EMITTER_STATE = typeof particlefx.EMITTER_STATE_POSTSPAWN | typeof particlefx.EMITTER_STATE_PRESPAWN | typeof particlefx.EMITTER_STATE_SLEEPING | typeof particlefx.EMITTER_STATE_SPAWNING;
+    /**
+     * postspawn state 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" };
+    /**
+     * prespawn state 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" };
+    /**
+     * sleeping state 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" };
+    /**
+     * spawning state 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.
+     * @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_.
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.play("#particlefx", (self, id, emitter, state) => {
+     *       if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
+     *         // exhaust is done spawning particles...
+     *       }
+     *     });
+     *   },
+     * });
+     * ```
+     */
+    function play(url: string | Hash | Url, emitter_state_function?: (self: unknown, id: Hash, emitter: Hash, state: particlefx.EMITTER_STATE) => 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 | Matrix4): 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 used when stopping the particle fx
+     * @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?: particlefx.stop_options): 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 {};