@defold-typescript/types 0.39.0 → 0.41.0

package/generated/buffer.d.ts

@@ -6,41 +6,44 @@ declare global {
    * Functions for manipulating buffers and streams
    */
   namespace buffer {
+    type buffer_data = Opaque<"buffer">;
+    type buffer_stream = Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> };
     type ValueType = typeof buffer.VALUE_TYPE_FLOAT32 | typeof buffer.VALUE_TYPE_INT16 | typeof buffer.VALUE_TYPE_INT32 | typeof buffer.VALUE_TYPE_INT64 | typeof buffer.VALUE_TYPE_INT8 | typeof buffer.VALUE_TYPE_UINT16 | typeof buffer.VALUE_TYPE_UINT32 | typeof buffer.VALUE_TYPE_UINT64 | typeof buffer.VALUE_TYPE_UINT8;
+    type VALUE_TYPE = typeof buffer.VALUE_TYPE_FLOAT32 | typeof buffer.VALUE_TYPE_INT16 | typeof buffer.VALUE_TYPE_INT32 | typeof buffer.VALUE_TYPE_INT64 | typeof buffer.VALUE_TYPE_INT8 | typeof buffer.VALUE_TYPE_UINT16 | typeof buffer.VALUE_TYPE_UINT32 | typeof buffer.VALUE_TYPE_UINT64 | typeof buffer.VALUE_TYPE_UINT8;
     /**
-     * Float, single precision, 4 bytes
+     * float32 Float, single precision, 4 bytes
      */
     const VALUE_TYPE_FLOAT32: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" };
     /**
-     * Signed integer, 2 bytes
+     * int16 Signed integer, 2 bytes
      */
     const VALUE_TYPE_INT16: number & { readonly __brand: "buffer.VALUE_TYPE_INT16" };
     /**
-     * Signed integer, 4 bytes
+     * int32 Signed integer, 4 bytes
      */
     const VALUE_TYPE_INT32: number & { readonly __brand: "buffer.VALUE_TYPE_INT32" };
     /**
-     * Signed integer, 8 bytes
+     * int64 Signed integer, 8 bytes
      */
     const VALUE_TYPE_INT64: number & { readonly __brand: "buffer.VALUE_TYPE_INT64" };
     /**
-     * Signed integer, 1 byte
+     * int8 Signed integer, 1 byte
      */
     const VALUE_TYPE_INT8: number & { readonly __brand: "buffer.VALUE_TYPE_INT8" };
     /**
-     * Unsigned integer, 2 bytes
+     * uint16 Unsigned integer, 2 bytes
      */
     const VALUE_TYPE_UINT16: number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" };
     /**
-     * Unsigned integer, 4 bytes
+     * uint32 Unsigned integer, 4 bytes
      */
     const VALUE_TYPE_UINT32: number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" };
     /**
-     * Unsigned integer, 8 bytes
+     * uint64 Unsigned integer, 8 bytes
      */
     const VALUE_TYPE_UINT64: number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" };
     /**
-     * Unsigned integer, 1 byte
+     * uint8 Unsigned integer, 1 byte
      */
     const VALUE_TYPE_UINT8: number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" };
     /**
@@ -88,10 +91,10 @@ declare global {
      * // copy entire stream
      * const srcstream = buffer.get_stream(srcbuffer, hash("xyz"));
      * const dststream = buffer.get_stream(dstbuffer, hash("xyz"));
-     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length);
+     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length());
      * ```
      */
-    function copy_stream(dst: Opaque<"bufferstream"> & { [index: number]: number }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: number }, srcoffset: number, count: number): void;
+    function copy_stream(dst: Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> }, srcoffset: number, count: number): void;
     /**
      * Create a new data buffer containing a specified set of streams. A data buffer
      * can contain one or more streams with typed data. This is useful for managing
@@ -102,33 +105,34 @@ declare global {
      * @param declaration - A table where each entry (table) describes a stream
      *
      * - hash | string `name`: The name of the stream
-     *
-     * - constant `type`: The data type of the stream
-     *
+     * - buffer.VALUE_TYPE `type`: The data type of the stream
      * - number `count`: The number of values each element should hold
      * @returns the new buffer
      * @example
      * ```ts
      * // How to create and initialize a buffer
      * export default defineScript({
-     *   init(self) {
+     *   init() {
      *     const size = 128;
-     *     self.image = buffer.create(size * size, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
-     *     self.imagestream = buffer.get_stream(self.image, hash("rgb"));
-     *
-     *     for (let y = 0; y < self.height; y++) {
-     *       for (let x = 0; x < self.width; x++) {
-     *         const index = y * self.width * 3 + x * 3;
-     *         self.imagestream[index + 0] = self.r;
-     *         self.imagestream[index + 1] = self.g;
-     *         self.imagestream[index + 2] = self.b;
+     *     const [width, height] = [size, size];
+     *     const [r, g, b] = [0xff, 0x80, 0x10];
+     *     const image = buffer.create(size * size, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
+     *     const imagestream = buffer.get_stream(image, hash("rgb"));
+     *
+     *     for (let y = 0; y < height; y++) {
+     *       for (let x = 0; x < width; x++) {
+     *         const index = y * width * 3 + x * 3;
+     *         imagestream[index + 0] = r;
+     *         imagestream[index + 1] = g;
+     *         imagestream[index + 2] = b;
      *       }
      *     }
+     *     return { image, imagestream };
      *   },
      * });
      * ```
      */
-    function create(element_count: number, declaration: { name?: Hash | string; type?: Opaque<"constant">; count?: number }): Opaque<"buffer">;
+    function create(element_count: number, declaration: ({ name: Hash | string; type: buffer.VALUE_TYPE; count: number })[]): Opaque<"buffer">;
     /**
      * Get a copy of all the bytes from a specified stream as a Lua string.
      *
@@ -136,7 +140,7 @@ declare global {
      * @param stream_name - the name of the stream
      * @returns the buffer data as a Lua string
      */
-    function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash): string;
+    function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash | string): string;
     /**
      * Get a named metadata entry from a buffer along with its type.
      *
@@ -152,7 +156,7 @@ declare global {
      * if (values) print(`${values.length} values in 'somefloats'`);
      * ```
      */
-    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.ValueType | undefined]>;
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.VALUE_TYPE | undefined]>;
     /**
      * Get a specified stream from a buffer.
      *
@@ -160,7 +164,7 @@ declare global {
      * @param stream_name - the stream name
      * @returns the data stream
      */
-    function get_stream(buffer: Opaque<"buffer">, stream_name: Hash | string): Opaque<"bufferstream"> & { [index: number]: number };
+    function get_stream(buffer: Opaque<"buffer">, stream_name: Hash | string): Opaque<"bufferstream"> & { [index: number]: number; length: LuaLengthMethod<number> };
     /**
      * Creates or updates a metadata array entry on a buffer.
      * The value type and count given when updating the entry should match those used when first creating it.
@@ -181,7 +185,7 @@ declare global {
      * buffer.set_metadata(buf, hash("somefloats"), [-2.5, 10.0, 32.2], buffer.VALUE_TYPE_FLOAT32);
      * ```
      */
-    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: buffer.ValueType): void;
+    function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: buffer.VALUE_TYPE): void;
   }
 }
 

package/generated/builtin-messages.d.ts

@@ -25,7 +25,10 @@ declare global {
     model_animation_done: { animation_id: Hash; playback: number };
     play_animation: { id: Hash };
     play_sound: { delay?: number; gain?: number; play_id?: number; start_time?: number; start_frame?: number };
+    proxy_error: { code: number };
     proxy_loaded: Record<string, never>;
+    proxy_loading: { progress: number };
+    proxy_ready: Record<string, never>;
     proxy_unloaded: Record<string, never>;
     ray_cast_missed: { group: Hash; request_id: number };
     ray_cast_response: { fraction: number; position: Vector3; normal: Vector3; id: Hash; group: Hash; request_id: number };
@@ -35,7 +38,7 @@ declare global {
     release_input_focus: Record<string, never>;
     resize: { height: number; width: number };
     resume_rendering: Record<string, never>;
-    set_camera: { aspect_ratio: number; fov: number; near_z: number; far_z: number; orthographic_projection: boolean; orthographic_zoom: number; orthographic_mode: number };
+    set_camera: { aspect_ratio: number; fov: number; near_z: number; far_z: number; orthographic_projection: number; orthographic_zoom: number; orthographic_mode: number };
     set_gain: { gain: number };
     set_parent: { parent_id?: Hash; keep_world_transform?: 0 | 1 };
     set_time_step: { factor: number; mode: number };
@@ -47,6 +50,9 @@ declare global {
     start_record: { file_name: string; frame_period: number; fps: number };
     stop_record: Record<string, never>;
     stop_sound: Record<string, never>;
+    text_object_clicked: { id: Hash; type: Hash; src: string };
+    text_object_hovered: { id: Hash; type: Hash; src: string };
+    text_object_unhovered: { id: Hash; type: Hash; src: string };
     toggle_physics_debug: Record<string, never>;
     toggle_profile: Record<string, never>;
     trigger_event: { enter: boolean; a: Record<string | number, unknown>; b: Record<string | number, unknown> };

package/generated/bullet3d.d.ts

@@ -0,0 +1,91 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Url } from "../src/core-types";
+
+declare global {
+  /**
+   * Native-style access to the Bullet 3D world and collision objects owned by
+   * Defold. World creation, destruction and stepping remain controlled by Defold.
+   * The backend name refers to three-dimensional physics.
+   *
+   * World, collision-object and rigid-body userdata are borrowed handles to
+   * Defold-owned objects. Shape userdata are borrowed logical child-slot handles
+   * attached to a collision object. Constraint userdata identify auxiliary native
+   * objects owned by this Lua API; destroy them explicitly when no longer needed.
+   * They are also destroyed automatically when a required body or world is
+   * destroyed.
+   *
+   * A collision-object, rigid-body or shape handle becomes invalid when its
+   * collision object is deleted or reloaded. A world handle remains valid across
+   * collision-object reloads, but becomes invalid when its collection and physics
+   * world are destroyed. The corresponding `is_valid()` function is safe for
+   * checking a retained handle; every other operation rejects an invalid handle.
+   */
+  namespace bullet3d {
+    type btCollisionObject = Opaque<"btCollisionObject" | "btRigidBody">;
+    type btDiscreteDynamicsWorld = Opaque<"btDiscreteDynamicsWorld">;
+    type btRigidBody = Opaque<"btRigidBody">;
+    /**
+     * Bullet version information
+     */
+    interface version_info {
+      /**
+       * full Bullet version string
+       */
+      version: string;
+      /**
+       * compact numeric Bullet version
+       */
+      number: number;
+      /**
+       * major version number
+       */
+      major: number;
+      /**
+       * minor version number
+       */
+      minor: number;
+    }
+    /**
+     * This returns both rigid bodies and ghost trigger objects.
+     * This function raises an error unless the collection uses 3D physics.
+     *
+     * @param url - collision object component URL
+     * @returns the collision object, or `nil`
+     */
+    function get_collision_object(url: string | Hash | Url): Opaque<"btCollisionObject" | "btRigidBody"> | undefined;
+    /**
+     * Trigger components are ghost objects, so this function returns `nil` for them.
+     * This function raises an error unless the collection uses 3D physics.
+     *
+     * @param url - collision object component URL
+     * @returns the rigid body handle, or `nil`
+     * @example
+     * ```ts
+     * const world = bullet3d.get_world();
+     * const body = bullet3d.get_rigid_body("#collisionobject");
+     * if (world !== undefined && body !== undefined && bullet3d.rigid_body.is_valid(body)) {
+     *   bullet3d.rigid_body.apply_central_impulse(body, vmath.vector3(0, 10, 0));
+     * }
+     *
+     * // A trigger is a collision object, not a rigid body.
+     * const trigger = bullet3d.get_collision_object("#trigger");
+     * assert(trigger !== undefined && bullet3d.get_rigid_body("#trigger") === undefined);
+     * ```
+     */
+    function get_rigid_body(url: string | Hash | Url): Opaque<"btRigidBody"> | undefined;
+    /**
+     * Get the Bullet version
+     *
+     * @returns version information
+     */
+    function get_version(): bullet3d.version_info;
+    /**
+     * This function raises an error unless the collection uses 3D physics.
+     *
+     * @returns the world, or `nil` if the collection has no physics world
+     */
+    function get_world(): bullet3d.btDiscreteDynamicsWorld | undefined;
+  }
+}
+
+export {};