@defold-typescript/types 0.48.0 → 0.50.0

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

@@ -0,0 +1,308 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Query and cast functions for the Defold-owned Box2D v2 world.
+   */
+  namespace b2d.world {
+    /**
+     * The return value is the fraction of `translation` that can be traveled before collision,
+     * or 1 if there is no hit.
+     *
+     * @param world - world
+     * @param capsule - mover capsule
+     * @param translation - capsule displacement
+     * @param filter - optional query filter
+     * @returns travel fraction before collision
+     */
+    function cast_mover(world: Opaque<"b2World">, capsule: b2d.mover_capsule, translation: Vector3, filter?: b2d.query_filter): number;
+    /**
+     * Cast a ray.
+     *
+     * @param world - world from b2d.get_world or b2d.body.get_world
+     * @param origin - world ray origin
+     * @param translation - world ray translation
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count
+     */
+    function cast_ray(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_cast_hit[], b2d.tree_stats]>;
+    /**
+     * The translation is the ray displacement from `origin`. Result order is not
+     * guaranteed by Box2D.
+     *
+     * @param world - world
+     * @param origin - ray start position
+     * @param translation - ray displacement
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function cast_ray(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_cast_hit[], b2d.tree_stats]>;
+    /**
+     * Cast a ray and return the closest hit.
+     *
+     * @param world - world from b2d.get_world or b2d.body.get_world
+     * @param origin - world ray origin
+     * @param translation - world ray translation
+     * @param filter - optional query filter
+     * @returns closest hit, or `nil`
+     */
+    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.fixture_cast_hit | undefined;
+    /**
+     * The translation is the ray displacement from `origin`.
+     *
+     * @param world - world
+     * @param origin - ray start position
+     * @param translation - ray displacement
+     * @param filter - optional query filter
+     * @returns closest hit, or `nil`
+     */
+    function cast_ray_closest(world: Opaque<"b2World">, origin: Vector3, translation: Vector3, filter?: b2d.query_filter): b2d.shape_cast_hit | undefined;
+    /**
+     * Uses Box2D v2 time-of-impact for fixture child shapes that support distance proxies.
+     * Grid fixture children are skipped.
+     *
+     * @param world - world from b2d.get_world or b2d.body.get_world
+     * @param shape - query shape
+     * @param translation - world shape translation
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count
+     */
+    function cast_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_cast_hit[], b2d.tree_stats]>;
+    /**
+     * The translation is the shape displacement.
+     *
+     * @param world - world
+     * @param shape - cast shape
+     * @param translation - shape displacement
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function cast_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, translation: Vector3, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_cast_hit[], b2d.tree_stats]>;
+    /**
+     * Collide a mover capsule against the world.
+     *
+     * @param world - world
+     * @param capsule - mover capsule
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     * @returns collision planes
+     */
+    function collide_mover(world: Opaque<"b2World">, capsule: b2d.mover_capsule, filter?: b2d.query_filter, max_results?: number): b2d.mover_plane[];
+    /**
+     * Enable or disable continuous collision.
+     *
+     * @param world - world
+     * @param enable - true to enable continuous collision
+     */
+    function enable_continuous(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Enable or disable world sleeping.
+     *
+     * @param world - world
+     * @param enable - true to allow sleeping
+     */
+    function enable_sleeping(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Enable or disable speculative collision.
+     *
+     * @param world - world
+     * @param enable - true to enable speculative collision
+     */
+    function enable_speculative(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Enable or disable warm starting.
+     *
+     * @param world - world
+     * @param enable - true to enable warm starting
+     */
+    function enable_warm_starting(world: Opaque<"b2World">, enable: boolean): void;
+    /**
+     * Apply an explosion impulse.
+     *
+     * @param world - world
+     * @param definition - explosion definition
+     */
+    function explode(world: Opaque<"b2World">, definition: b2d.explosion_definition): void;
+    /**
+     * Get the number of awake bodies.
+     *
+     * @param world - world
+     * @returns awake body count
+     */
+    function get_awake_body_count(world: Opaque<"b2World">): number;
+    /**
+     * Get world counters.
+     *
+     * @param world - world
+     * @returns world counters
+     */
+    function get_counters(world: Opaque<"b2World">): b2d.world_counters;
+    /**
+     * Get world gravity.
+     *
+     * @param world - world
+     * @returns gravity vector
+     */
+    function get_gravity(world: Opaque<"b2World">): Vector3;
+    /**
+     * Get the hit event threshold.
+     *
+     * @param world - world
+     * @returns hit event threshold in project units per second
+     */
+    function get_hit_event_threshold(world: Opaque<"b2World">): number;
+    /**
+     * Get the maximum linear speed.
+     *
+     * @param world - world
+     * @returns maximum linear speed in project units per second
+     */
+    function get_maximum_linear_speed(world: Opaque<"b2World">): number;
+    /**
+     * Get world profiling data.
+     *
+     * @param world - world
+     * @returns world profiling data
+     */
+    function get_profile(world: Opaque<"b2World">): b2d.world_profile;
+    /**
+     * Get the restitution threshold.
+     *
+     * @param world - world
+     * @returns restitution threshold in project units per second
+     */
+    function get_restitution_threshold(world: Opaque<"b2World">): number;
+    /**
+     * Get whether continuous collision is enabled.
+     *
+     * @param world - world
+     * @returns true if continuous collision is enabled
+     */
+    function is_continuous_enabled(world: Opaque<"b2World">): boolean;
+    /**
+     * The world is locked during callbacks and some simulation phases. Functions
+     * marked as locked during callbacks cannot be called while this returns true.
+     *
+     * @param world - world
+     * @returns true if the world is locked
+     */
+    function is_locked(world: Opaque<"b2World">): boolean;
+    /**
+     * Get whether world sleeping is enabled.
+     *
+     * @param world - world
+     * @returns true if sleeping is enabled
+     */
+    function is_sleeping_enabled(world: Opaque<"b2World">): boolean;
+    /**
+     * Check whether a world handle is valid.
+     *
+     * @param world - world
+     * @returns true if the world handle is valid
+     */
+    function is_valid(world: Opaque<"b2World">): boolean;
+    /**
+     * Get whether warm starting is enabled.
+     *
+     * @param world - world
+     * @returns true if warm starting is enabled
+     */
+    function is_warm_starting_enabled(world: Opaque<"b2World">): boolean;
+    /**
+     * Overlap an AABB.
+     *
+     * @param world - world from b2d.get_world or b2d.body.get_world
+     * @param aabb - query bounds
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count
+     * @returns `[fixtures, stats]`:
+     * - `fixtures` — overlapping fixtures. **⚠️ `index` is 1-based; passed to Defold unchanged.**
+     * - `stats` — broad-phase query statistics
+     */
+    function overlap_aabb(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
+    /**
+     * Find shapes overlapping an AABB.
+     *
+     * @param world - world
+     * @param aabb - query bounds
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function overlap_aabb(world: Opaque<"b2World">, aabb: b2d.aabb, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
+    /**
+     * Overlap a shape.
+     *
+     * @param world - world from b2d.get_world or b2d.body.get_world
+     * @param shape - query shape
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count
+     * @returns `[fixtures, stats]`:
+     * - `fixtures` — overlapping fixtures. **⚠️ `index` is 1-based; passed to Defold unchanged.**
+     * - `stats` — broad-phase query statistics
+     */
+    function overlap_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.fixture_info[], b2d.tree_stats]>;
+    /**
+     * Find shapes overlapping a shape proxy.
+     *
+     * @param world - world
+     * @param shape - query shape
+     * @param filter - optional query filter
+     * @param max_results - optional maximum result count. Omit or pass 0 for unlimited results.
+     */
+    function overlap_shape(world: Opaque<"b2World">, shape: { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; hx: number; hy: number; center?: Vector3; angle?: number } | { type: typeof b2d.shape.SHAPE_TYPE_POLYGON | typeof b2d.shape.SHAPE_TYPE_BOX; vertices: Vector3[] } | { type: typeof b2d.shape.SHAPE_TYPE_CIRCLE; radius: number; center?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CAPSULE; radius: number; center1: Vector3; center2: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_EDGE | typeof b2d.shape.SHAPE_TYPE_SEGMENT; v1: Vector3; v2: Vector3; v0?: Vector3; v3?: Vector3 } | { type: typeof b2d.shape.SHAPE_TYPE_CHAIN; vertices: Vector3[]; loop?: boolean; prev_vertex?: Vector3; next_vertex?: Vector3 }, filter?: b2d.query_filter, max_results?: number): LuaMultiReturn<[b2d.shape_info[], b2d.tree_stats]>;
+    /**
+     * Rebuild the static broad-phase tree.
+     *
+     * @param world - world
+     */
+    function rebuild_static_tree(world: Opaque<"b2World">): void;
+    /**
+     * Set contact solver tuning.
+     *
+     * @param world - world
+     * @param hertz - contact stiffness frequency in hertz
+     * @param damping_ratio - contact damping ratio
+     * @param pushout - pushout velocity in project units per second
+     */
+    function set_contact_tuning(world: Opaque<"b2World">, hertz: number, damping_ratio: number, pushout: number): void;
+    /**
+     * Set world gravity.
+     *
+     * @param world - world
+     * @param gravity - gravity vector
+     */
+    function set_gravity(world: Opaque<"b2World">, gravity: Vector3): void;
+    /**
+     * Set the hit event threshold.
+     *
+     * @param world - world
+     * @param threshold - hit event threshold in project units per second
+     */
+    function set_hit_event_threshold(world: Opaque<"b2World">, threshold: number): void;
+    /**
+     * Set joint solver tuning.
+     *
+     * @param world - world
+     * @param hertz - joint stiffness frequency in hertz
+     * @param damping_ratio - joint damping ratio
+     */
+    function set_joint_tuning(world: Opaque<"b2World">, hertz: number, damping_ratio: number): void;
+    /**
+     * Set the maximum linear speed.
+     *
+     * @param world - world
+     * @param speed - maximum linear speed in project units per second
+     */
+    function set_maximum_linear_speed(world: Opaque<"b2World">, speed: number): void;
+    /**
+     * Collisions below this relative speed use inelastic collision response.
+     *
+     * @param world - world
+     * @param threshold - restitution threshold in project units per second
+     */
+    function set_restitution_threshold(world: Opaque<"b2World">, threshold: number): void;
+  }
+}
+
+export {};

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

@@ -0,0 +1,192 @@
+/** @noSelfInFile */
+import type { Hash, Opaque } from "../../../src/core-types";
+
+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;
+    /**
+     * float32 Float, single precision, 4 bytes
+     */
+    const VALUE_TYPE_FLOAT32: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" };
+    /**
+     * int16 Signed integer, 2 bytes
+     */
+    const VALUE_TYPE_INT16: number & { readonly __brand: "buffer.VALUE_TYPE_INT16" };
+    /**
+     * int32 Signed integer, 4 bytes
+     */
+    const VALUE_TYPE_INT32: number & { readonly __brand: "buffer.VALUE_TYPE_INT32" };
+    /**
+     * int64 Signed integer, 8 bytes
+     */
+    const VALUE_TYPE_INT64: number & { readonly __brand: "buffer.VALUE_TYPE_INT64" };
+    /**
+     * int8 Signed integer, 1 byte
+     */
+    const VALUE_TYPE_INT8: number & { readonly __brand: "buffer.VALUE_TYPE_INT8" };
+    /**
+     * uint16 Unsigned integer, 2 bytes
+     */
+    const VALUE_TYPE_UINT16: number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" };
+    /**
+     * uint32 Unsigned integer, 4 bytes
+     */
+    const VALUE_TYPE_UINT32: number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" };
+    /**
+     * uint64 Unsigned integer, 8 bytes
+     */
+    const VALUE_TYPE_UINT64: number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" };
+    /**
+     * uint8 Unsigned integer, 1 byte
+     */
+    const VALUE_TYPE_UINT8: number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" };
+    /**
+     * Copy all data streams from one buffer to another, element wise.
+     * Each of the source streams must have a matching stream in the
+     * destination buffer. The streams must match in both type and size.
+     * The source and destination buffer can be the same.
+     *
+     * @param dst - the destination buffer
+     * @param dstoffset - the offset to start copying data to
+     * @param src - the source data buffer
+     * @param srcoffset - the offset to start copying data from
+     * @param count - the number of elements to copy
+     * @example
+     * ```ts
+     * // How to copy elements (e.g. vertices) from one buffer to another
+     * const element_count = 64;
+     * const srcbuffer = resource.get_buffer("/src.bufferc");
+     * const dstbuffer = resource.get_buffer("/dst.bufferc");
+     *
+     * // copy entire buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, element_count);
+     *
+     * // copy last 10 elements to the front of another buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, element_count - 10, 10);
+     * ```
+     */
+    function copy_buffer(dst: Opaque<"buffer">, dstoffset: number, src: Opaque<"buffer">, srcoffset: number, count: number): void;
+    /**
+     * Copy a specified amount of data from one stream to another.
+     * The value type and size must match between source and destination streams.
+     * The source and destination streams can be the same.
+     *
+     * @param dst - the destination stream
+     * @param dstoffset - the offset to start copying data to (measured in value type)
+     * @param src - the source data stream
+     * @param srcoffset - the offset to start copying data from (measured in value type)
+     * @param count - the number of values to copy (measured in value type)
+     * @example
+     * ```ts
+     * // How to update a texture of a sprite:
+     * const srcbuffer = resource.get_buffer("/src.bufferc");
+     * const dstbuffer = resource.get_buffer("/dst.bufferc");
+     *
+     * // 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());
+     * ```
+     */
+    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
+     * compound data, for instance a vertex buffer could contain separate streams for
+     * vertex position, color, normal etc.
+     *
+     * @param element_count - The number of elements the buffer should hold
+     * @param declaration - A table where each entry (table) describes a stream
+     *
+     * - hash | string `name`: The name 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() {
+     *     const size = 128;
+     *     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: buffer.VALUE_TYPE; count: number })[]): Opaque<"buffer">;
+    /**
+     * Get a copy of all the bytes from a specified stream as a Lua string.
+     *
+     * @param buffer - the source buffer
+     * @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): string;
+    /**
+     * Get a named metadata entry from a buffer along with its type.
+     *
+     * @param buf - the buffer to get the metadata from
+     * @param metadata_name - name of the metadata entry
+     * @example
+     * ```ts
+     * // How to get a metadata entry from a buffer
+     * const buf = resource.get_buffer("/my.bufferc");
+     *
+     * // retrieve a metadata entry named "somefloats" and its numeric type
+     * const [values, type] = buffer.get_metadata(buf, hash("somefloats"));
+     * if (values) print(`${values.length} values in 'somefloats'`);
+     * ```
+     */
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, buffer.VALUE_TYPE | undefined]>;
+    /**
+     * Get a specified stream from a buffer.
+     *
+     * @param buffer - the buffer to get the stream from
+     * @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; 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.
+     *
+     * @param buf - the buffer to set the metadata on
+     * @param metadata_name - name of the metadata entry
+     * @param values - actual metadata, an array of numeric values
+     * @param value_type - type of values when stored
+     * @example
+     * ```ts
+     * // How to set a metadata entry on a buffer
+     * const buf = resource.get_buffer("/my.bufferc");
+     *
+     * // create a new metadata entry with three floats
+     * buffer.set_metadata(buf, hash("somefloats"), [1.5, 3.2, 7.9], buffer.VALUE_TYPE_FLOAT32);
+     * // ...
+     * // update to a new set of values
+     * 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.VALUE_TYPE): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.2/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 {};