@defold-typescript/types 0.19.4 → 0.20.1

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

@@ -0,0 +1,348 @@
+/** @noSelfInFile */
+import type { Opaque, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for interacting with Box2D bodies.
+   */
+  namespace b2d.body {
+    type b2Body = Opaque<"b2Body">;
+    type b2World = Opaque<"b2World">;
+    /**
+     * Dynamic body
+     */
+    const B2_DYNAMIC_BODY: number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" };
+    /**
+     * Kinematic body
+     */
+    const B2_KINEMATIC_BODY: number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" };
+    /**
+     * Static (immovable) body
+     */
+    const B2_STATIC_BODY: number & { readonly __brand: "b2d.body.B2_STATIC_BODY" };
+    /**
+     * Apply an angular impulse.
+     *
+     * @param body - body
+     * @param impulse - impulse the angular impulse in units of kg*m*m/s
+     */
+    function apply_angular_impulse(body: Opaque<"b2Body">, impulse: number): void;
+    /**
+     * Apply a force at a world point. If the force is not
+     * applied at the center of mass, it will generate a torque and
+     * affect the angular velocity. This wakes up the body.
+     *
+     * @param body - body
+     * @param force - the world force vector, usually in Newtons (N).
+     * @param point - the world position of the point of application.
+     */
+    function apply_force(body: Opaque<"b2Body">, force: Vector3, point: Vector3): void;
+    /**
+     * Apply a force to the center of mass. This wakes up the body.
+     *
+     * @param body - body
+     * @param force - the world force vector, usually in Newtons (N).
+     */
+    function apply_force_to_center(body: Opaque<"b2Body">, force: Vector3): void;
+    /**
+     * Apply an impulse at a point. This immediately modifies the velocity.
+     * It also modifies the angular velocity if the point of application
+     * is not at the center of mass. This wakes up the body.
+     *
+     * @param body - body
+     * @param impulse - the world impulse vector, usually in N-seconds or kg-m/s.
+     * @param point - the world position of the point of application.
+     */
+    function apply_linear_impulse(body: Opaque<"b2Body">, impulse: Vector3, point: Vector3): void;
+    /**
+     * Apply a torque. This affects the angular velocity
+     * without affecting the linear velocity of the center of mass.
+     * This wakes up the body.
+     *
+     * @param body - body
+     * @param torque - torque about the z-axis (out of the screen), usually in N-m.
+     */
+    function apply_torque(body: Opaque<"b2Body">, torque: number): void;
+    /**
+     * You can disable sleeping on this body. If you disable sleeping, the body will be woken.
+     *
+     * @param body - body
+     * @param enable - if false, the body will never sleep, and consume more CPU
+     */
+    function enable_sleep(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Get the angle in radians.
+     *
+     * @param body - body
+     * @returns the current world rotation angle in radians.
+     */
+    function get_angle(body: Opaque<"b2Body">): number;
+    /**
+     * Get the angular damping of the body.
+     *
+     * @param body - body
+     * @returns the damping
+     */
+    function get_angular_damping(body: Opaque<"b2Body">): number;
+    /**
+     * Get the angular velocity.
+     *
+     * @param body - body
+     * @returns the angular velocity in radians/second.
+     */
+    function get_angular_velocity(body: Opaque<"b2Body">): number;
+    /**
+     * Get the gravity scale of the body.
+     *
+     * @param body - body
+     * @returns the scale
+     */
+    function get_gravity_scale(body: Opaque<"b2Body">): number;
+    /**
+     * Get the linear damping of the body.
+     *
+     * @param body - body
+     * @returns the damping
+     */
+    function get_linear_damping(body: Opaque<"b2Body">): number;
+    /**
+     * Get the linear velocity of the center of mass.
+     *
+     * @param body - body
+     * @returns the linear velocity of the center of mass.
+     */
+    function get_linear_velocity(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the world velocity of a local point.
+     *
+     * @param body - body
+     * @param local_point - a point in local coordinates.
+     * @returns the world velocity of a point.
+     */
+    function get_linear_velocity_from_local_point(body: Opaque<"b2Body">, local_point: Vector3): Vector3;
+    /**
+     * Get the world linear velocity of a world point attached to this body.
+     *
+     * @param body - body
+     * @param world_point - a point in world coordinates.
+     * @returns the world velocity of a point.
+     */
+    function get_linear_velocity_from_world_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Get the local position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the local position of the center of mass.
+     */
+    function get_local_center_of_mass(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Gets a local point relative to the body's origin given a world point.
+     *
+     * @param body - body
+     * @param world_point - a point in world coordinates.
+     * @returns the corresponding local point relative to the body's origin.
+     */
+    function get_local_point(body: Opaque<"b2Body">, world_point: Vector3): Vector3;
+    /**
+     * Gets a local vector given a world vector.
+     *
+     * @param body - body
+     * @param world_vector - a vector in world coordinates.
+     * @returns the corresponding local vector.
+     */
+    function get_local_vector(body: Opaque<"b2Body">, world_vector: Vector3): Vector3;
+    /**
+     * Get the total mass of the body.
+     *
+     * @param body - body
+     * @returns the mass, usually in kilograms (kg).
+     */
+    function get_mass(body: Opaque<"b2Body">): number;
+    /**
+     * Get the world body origin position.
+     *
+     * @param body - body
+     * @returns the world position of the body's origin.
+     */
+    function get_position(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the rotational inertia of the body about the local origin.
+     *
+     * @param body - body
+     * @returns the rotational inertia, usually in kg-m^2.
+     */
+    function get_rotational_inertia(body: Opaque<"b2Body">): number;
+    /**
+     * Get the type of this body.
+     *
+     * @param body - body
+     * @returns the body type
+     */
+    function get_type(body: Opaque<"b2Body">): (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" });
+    /**
+     * Get the parent world of this body.
+     *
+     * @param body - body
+     */
+    function get_world(body: Opaque<"b2Body">): Opaque<"b2World">;
+    /**
+     * Get the world position of the center of mass.
+     *
+     * @param body - body
+     * @returns Get the world position of the center of mass.
+     */
+    function get_world_center_of_mass(body: Opaque<"b2Body">): Vector3;
+    /**
+     * Get the world coordinates of a point given the local coordinates.
+     *
+     * @param body - body
+     * @param local_vector - localPoint a point on the body measured relative the the body's origin.
+     * @returns the same point expressed in world coordinates.
+     */
+    function get_world_point(body: Opaque<"b2Body">, local_vector: Vector3): Vector3;
+    /**
+     * Get the world coordinates of a vector given the local coordinates.
+     *
+     * @param body - body
+     * @param local_vector - a vector fixed in the body.
+     * @returns the same vector expressed in world coordinates.
+     */
+    function get_world_vector(body: Opaque<"b2Body">, local_vector: Vector3): Vector3;
+    /**
+     * Get the active state of the body.
+     *
+     * @param body - body
+     * @returns is the body active
+     */
+    function is_active(body: Opaque<"b2Body">): boolean;
+    /**
+     * Get the sleeping state of this body.
+     *
+     * @param body - body
+     * @returns true if the body is awake, false if it's sleeping.
+     */
+    function is_awake(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body in bullet mode
+     *
+     * @param body - body
+     * @returns true if the body is in bullet mode
+     */
+    function is_bullet(body: Opaque<"b2Body">): boolean;
+    /**
+     * Does this body have fixed rotation?
+     *
+     * @param body - body
+     * @returns is the rotation fixed
+     */
+    function is_fixed_rotation(body: Opaque<"b2Body">): boolean;
+    /**
+     * Is this body allowed to sleep
+     *
+     * @param body - body
+     * @returns true if the body is allowed to sleep
+     */
+    function is_sleeping_enabled(body: Opaque<"b2Body">): boolean;
+    /**
+     * This resets the mass properties to the sum of the mass properties of the fixtures.
+     * This normally does not need to be called unless you called SetMassData to override
+     *
+     * @param body - body
+     */
+    function reset_mass_data(body: Opaque<"b2Body">): void;
+    /**
+     * Set the active state of the body. An inactive body is not
+     * simulated and cannot be collided with or woken up.
+     * If you pass a flag of true, all fixtures will be added to the
+     * broad-phase.
+     * If you pass a flag of false, all fixtures will be removed from
+     * the broad-phase and all contacts will be destroyed.
+     * Fixtures and joints are otherwise unaffected. You may continue
+     * to create/destroy fixtures and joints on inactive bodies.
+     * Fixtures on an inactive body are implicitly inactive and will
+     * not participate in collisions, ray-casts, or queries.
+     * Joints connected to an inactive body are implicitly inactive.
+     * An inactive body is still owned by a b2World object and remains
+     * in the body list.
+     *
+     * @param body - body
+     * @param enable - true if the body should be active
+     */
+    function set_active(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set the angular damping of the body.
+     *
+     * @param body - body
+     * @param damping - the damping
+     */
+    function set_angular_damping(body: Opaque<"b2Body">, damping: number): void;
+    /**
+     * Set the angular velocity.
+     *
+     * @param body - body
+     * @param omega - the new angular velocity in radians/second.
+     */
+    function set_angular_velocity(body: Opaque<"b2Body">, omega: number): void;
+    /**
+     * Set the sleep state of the body. A sleeping body has very low CPU cost.
+     *
+     * @param body - body
+     * @param enable - flag set to false to put body to sleep, true to wake it.
+     */
+    function set_awake(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Should this body be treated like a bullet for continuous collision detection?
+     *
+     * @param body - body
+     * @param enable - if true, the body will be in bullet mode
+     */
+    function set_bullet(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set this body to have fixed rotation. This causes the mass to be reset.
+     *
+     * @param body - body
+     * @param enable - true if the rotation should be fixed
+     */
+    function set_fixed_rotation(body: Opaque<"b2Body">, enable: boolean): void;
+    /**
+     * Set the gravity scale of the body.
+     *
+     * @param body - body
+     * @param scale - the scale
+     */
+    function set_gravity_scale(body: Opaque<"b2Body">, scale: number): void;
+    /**
+     * Set the linear damping of the body.
+     *
+     * @param body - body
+     * @param damping - the damping
+     */
+    function set_linear_damping(body: Opaque<"b2Body">, damping: number): void;
+    /**
+     * Set the linear velocity of the center of mass.
+     *
+     * @param body - body
+     * @param velocity - the new linear velocity of the center of mass.
+     */
+    function set_linear_velocity(body: Opaque<"b2Body">, velocity: Vector3): void;
+    /**
+     * Set the position of the body's origin and rotation.
+     * This breaks any contacts and wakes the other bodies.
+     * Manipulating a body's transform may cause non-physical behavior.
+     *
+     * @param body - body
+     * @param position - the world position of the body's local origin.
+     * @param angle - the world position of the body's local origin.
+     */
+    function set_transform(body: Opaque<"b2Body">, position: Vector3, angle: number): void;
+    /**
+     * Set the type of this body. This may alter the mass and velocity.
+     *
+     * @param body - body
+     * @param type - the body type
+     */
+    function set_type(body: Opaque<"b2Body">, type: (number & { readonly __brand: "b2d.body.B2_DYNAMIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_KINEMATIC_BODY" }) | (number & { readonly __brand: "b2d.body.B2_STATIC_BODY" })): void;
+  }
+}
+
+export {};

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

@@ -0,0 +1,176 @@
+/** @noSelfInFile */
+import type { Hash, Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for manipulating buffers and streams
+   */
+  namespace buffer {
+    /**
+     * Float, single precision, 4 bytes
+     */
+    const VALUE_TYPE_FLOAT32: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" };
+    /**
+     * Signed integer, 2 bytes
+     */
+    const VALUE_TYPE_INT16: number & { readonly __brand: "buffer.VALUE_TYPE_INT16" };
+    /**
+     * Signed integer, 4 bytes
+     */
+    const VALUE_TYPE_INT32: number & { readonly __brand: "buffer.VALUE_TYPE_INT32" };
+    /**
+     * Signed integer, 8 bytes
+     */
+    const VALUE_TYPE_INT64: number & { readonly __brand: "buffer.VALUE_TYPE_INT64" };
+    /**
+     * Signed integer, 1 byte
+     */
+    const VALUE_TYPE_INT8: number & { readonly __brand: "buffer.VALUE_TYPE_INT8" };
+    /**
+     * Unsigned integer, 2 bytes
+     */
+    const VALUE_TYPE_UINT16: number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" };
+    /**
+     * Unsigned integer, 4 bytes
+     */
+    const VALUE_TYPE_UINT32: number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" };
+    /**
+     * Unsigned integer, 8 bytes
+     */
+    const VALUE_TYPE_UINT64: number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" };
+    /**
+     * 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
+     * // copy entire buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, srcbuffer.length);
+     *
+     * // copy last 10 elements to the front of another buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, srcbuffer.length - 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:
+     * // 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 }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: 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
+     *
+     * - constant `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) {
+     *     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;
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function create(element_count: number, declaration: { name?: Hash | string; type?: Opaque<"constant">; 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;
+    /**
+     * 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
+     * // 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, Opaque<"constant"> | 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 };
+    /**
+     * 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
+     * // 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: Opaque<"constant">): void;
+  }
+}
+
+export {};