@ts-defold/types 1.2.40 → 1.2.42

package/index.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="lua-types/5.1" />
 /// <reference types="@typescript-to-lua/language-extensions" />
 
-// DEFOLD. stable version 1.6.4 (fcec9500fd438e365d4e4f6cec24b99afb907247)
+// DEFOLD. stable version 1.8.0 (ef07c036b8f7d34f4b1d7fcc355ce46a92d2dcc8)
 // =^..^=   =^..^=   =^..^=    =^..^=    =^..^=    =^..^=    =^..^= //
 
 
@@ -223,6 +223,338 @@ declare namespace socket {
 // =^..^=   =^..^=   =^..^=    =^..^=    =^..^=    =^..^=    =^..^= //
 
 
+declare namespace b2d {
+
+	/**
+	* Get the Box2D body from a collision object
+	* @param url  the url to the game object collision component
+	* @return body  the body if successful. Otherwise `nil`.
+	*/
+	export function get_body(url: url): any
+
+	/**
+	* Get the Box2D world from the current collection
+	* @return world  the world if successful. Otherwise `nil`.
+	*/
+	export function get_world(): any
+
+}
+// =^..^=   =^..^=   =^..^=    =^..^=    =^..^=    =^..^=    =^..^= //
+
+
+declare namespace b2d.body {
+
+	/**
+	* Dynamic body
+	*/
+	export let B2_DYNAMIC_BODY: any
+
+	/**
+	* Kinematic body
+	*/
+	export let B2_KINEMATIC_BODY: any
+
+	/**
+	* Static (immovable) body
+	*/
+	export let B2_STATIC_BODY: any
+
+	/**
+	* Apply an angular impulse.
+	* @param impulse  impulse the angular impulse in units of kg*m*m/s
+	*/
+	export function apply_angular_impulse(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 force  the world force vector, usually in Newtons (N).
+	* @param point  the world position of the point of application.
+	*/
+	export function apply_force(force: vmath.vector3, point: vmath.vector3): void
+
+	/**
+	* Apply a force to the center of mass. This wakes up the body.
+	* @param force  the world force vector, usually in Newtons (N).
+	*/
+	export function apply_force_to_center(force: vmath.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 impulse  the world impulse vector, usually in N-seconds or kg-m/s.
+	* @param point  the world position of the point of application.
+	*/
+	export function apply_linear_impulse(impulse: vmath.vector3, point: vmath.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 torque  torque about the z-axis (out of the screen), usually in N-m.
+	*/
+	export function apply_torque(torque: number): void
+
+	/**
+	* Print the body representation to the log output
+	*/
+	export function dump(): void
+
+	/**
+	* Get the angular damping of the body.
+	* @return damping  the damping
+	*/
+	export function get_angular_damping(): number
+
+	/**
+	* Set the angular velocity.
+	* @param omega  the new angular velocity in radians/second.
+	*/
+	export function get_angular_velocity(omega: number): void
+
+	/**
+	* Get the angular velocity.
+	* @return velocity  the angular velocity in radians/second.
+	*/
+	export function get_angular_velocity(): number
+
+	/**
+	* Get the gravity scale of the body.
+	* @return scale  the scale
+	*/
+	export function get_gravity_scale(): number
+
+	/**
+	* Get the rotational inertia of the body about the local origin.
+	* @return inertia  the rotational inertia, usually in kg-m^2.
+	*/
+	export function get_inertia(): number
+
+	/**
+	* Get the linear damping of the body.
+	* @return damping  the damping
+	*/
+	export function get_linear_damping(): number
+
+	/**
+	* Get the linear velocity of the center of mass.
+	* @return velocity  the linear velocity of the center of mass.
+	*/
+	export function get_linear_velocity(): vmath.vector3
+
+	/**
+	* Get the world linear velocity of a world point attached to this body.
+	* @param world_point  a point in world coordinates.
+	* @return velocity  the world velocity of a point.
+	*/
+	export function get_linear_velocity_from_world_point(world_point: vmath.vector3): vmath.vector3
+
+	/**
+	* Get the world velocity of a local point.
+	* @param world_point  a point in local coordinates.
+	* @return velocity  the world velocity of a point.
+	*/
+	export function get_linear_velocity_from_world_point(world_point: vmath.vector3): vmath.vector3
+
+	/**
+	* Get the local position of the center of mass.
+	* @return center  Get the local position of the center of mass.
+	*/
+	export function get_local_center(): vmath.vector3
+
+	/**
+	* Gets a local point relative to the body's origin given a world point.
+	* @param world_point  a point in world coordinates.
+	* @return vector  the corresponding local point relative to the body's origin.
+	*/
+	export function get_local_point(world_point: vmath.vector3): vmath.vector3
+
+	/**
+	* Gets a local vector given a world vector.
+	* @param world_vector  a vector in world coordinates.
+	* @return vector  the corresponding local vector.
+	*/
+	export function get_local_vector(world_vector: vmath.vector3): vmath.vector3
+
+	/**
+	* Get the total mass of the body.
+	* @return mass  the mass, usually in kilograms (kg).
+	*/
+	export function get_mass(): number
+
+	/**
+	* Get the next body in the world's body list.
+	* @return body  the next body
+	*/
+	export function get_next(): any
+
+	/**
+	* Get the world body origin position.
+	* @return position  the world position of the body's origin.
+	*/
+	export function get_position(): vmath.vector3
+
+	/**
+	* Get the type of this body.
+	* @return type  the body type
+	*/
+	export function get_type(): any
+
+	/**
+	* Get the parent world of this body.
+	* @return world  
+	*/
+	export function get_world(): any
+
+	/**
+	* Get the angle in radians.
+	* @return angle  the current world rotation angle in radians.
+	*/
+	export function get_world_center(): number
+
+	/**
+	* Get the world position of the center of mass.
+	* @return center  Get the world position of the center of mass.
+	*/
+	export function get_world_center(): vmath.vector3
+
+	/**
+	* Get the world coordinates of a point given the local coordinates.
+	* @param local_vector  localPoint a point on the body measured relative the the body's origin.
+	* @return vector  the same point expressed in world coordinates.
+	*/
+	export function get_world_point(local_vector: vmath.vector3): vmath.vector3
+
+	/**
+	* Get the world coordinates of a vector given the local coordinates.
+	* @param local_vector  a vector fixed in the body.
+	* @return vector  the same vector expressed in world coordinates.
+	*/
+	export function get_world_vector(local_vector: vmath.vector3): vmath.vector3
+
+	/**
+	* Get the active state of the body.
+	* @return enabled  is the body active
+	*/
+	export function is_active(): any
+
+	/**
+	* Get the sleeping state of this body.
+	* @return enabled  true if the body is awake, false if it's sleeping.
+	*/
+	export function is_awake(): any
+
+	/**
+	* Is this body in bullet mode
+	* @return enabled  true if the body is in bullet mode
+	*/
+	export function is_bullet(): any
+
+	/**
+	* Does this body have fixed rotation?
+	* @return enabled  is the rotation fixed
+	*/
+	export function is_fixed_rotation(): any
+
+	/**
+	* Is this body allowed to sleep
+	* @return enabled  true if the body is allowed to sleep
+	*/
+	export function is_sleeping_allowed(): any
+
+	/**
+	* 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
+	*/
+	export function reset_mass_data(): 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 enable  true if the body should be active
+	*/
+	export function set_active(enable: any): void
+
+	/**
+	* Set the angular damping of the body.
+	* @param damping  the damping
+	*/
+	export function set_angular_damping(damping: number): void
+
+	/**
+	* Set the sleep state of the body. A sleeping body has very low CPU cost.
+	* @param enable  flag set to false to put body to sleep, true to wake it.
+	*/
+	export function set_awake(enable: any): void
+
+	/**
+	* Should this body be treated like a bullet for continuous collision detection?
+	* @param enable  if true, the body will be in bullet mode
+	*/
+	export function set_bullet(enable: any): void
+
+	/**
+	* Set this body to have fixed rotation. This causes the mass to be reset.
+	* @param enable  true if the rotation should be fixed
+	*/
+	export function set_fixed_rotation(enable: any): void
+
+	/**
+	* Set the gravity scale of the body.
+	* @param scale  the scale
+	*/
+	export function set_gravity_scale(scale: number): void
+
+	/**
+	* Set the linear damping of the body.
+	* @param damping  the damping
+	*/
+	export function set_linear_damping(damping: number): void
+
+	/**
+	* Set the linear velocity of the center of mass.
+	* @param velocity  the new linear velocity of the center of mass.
+	*/
+	export function set_linear_velocity(velocity: vmath.vector3): void
+
+	/**
+	* You can disable sleeping on this body. If you disable sleeping, the body will be woken.
+	* @param enable  if false, the body will never sleep, and consume more CPU
+	*/
+	export function set_sleeping_allowed(enable: any): 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 position  the world position of the body's local origin.
+	* @param angle  the world position of the body's local origin.
+	*/
+	export function set_transform(position: vmath.vector3, angle: number): void
+
+	/**
+	* Set the type of this body. This may alter the mass and velocity.
+	* @param type  the body type
+	*/
+	export function set_type(type: any): void
+
+}
+// =^..^=   =^..^=   =^..^=    =^..^=    =^..^=    =^..^=    =^..^= //
+
+
 declare namespace crash {
 
 	/**
@@ -912,6 +1244,22 @@ name of internal property
 	*/
 	export function set_scale(scale: number | vmath.vector3, id?: string | hash | url): void
 
+	/**
+	* ⚠ The function uses world transformation calculated at the end of previous frame.
+	* @param position  position which need to be converted
+	* @param url  url of the game object which coordinate system convert to
+	* @return converted_postion  converted position
+	*/
+	export function world_to_local_position(position: vmath.vector3, url: string | hash | url): vmath.vector3
+
+	/**
+	* ⚠ The function uses world transformation calculated at the end of previous frame.
+	* @param transformation  transformation which need to be converted
+	* @param url  url of the game object which coordinate system convert to
+	* @return converted_transform  converted transformation
+	*/
+	export function world_to_local_transform(transformation: vmath.matrix4, url: string | hash | url): vmath.matrix4
+
 
 
 
@@ -1022,6 +1370,11 @@ declare namespace gui {
 	*/
 	export let BLEND_MULT: any
 
+	/**
+	* screen blending
+	*/
+	export let BLEND_SCREEN: any
+
 	/**
 	* clipping mode none
 	*/
@@ -1347,6 +1700,11 @@ declare namespace gui {
 	*/
 	export let PROP_COLOR: any
 
+	/**
+	* euler property
+	*/
+	export let PROP_EULER: any
+
 	/**
 	* fill_angle property
 	*/
@@ -1438,6 +1796,7 @@ declare namespace gui {
 
 - `"position"`
 - `"rotation"`
+- `"euler"`
 - `"scale"`
 - `"color"`
 - `"outline"`
@@ -1451,6 +1810,7 @@ The following property constants are defined equaling the corresponding property
 
 - `gui.PROP_POSITION`
 - `gui.PROP_ROTATION`
+- `gui.PROP_EULER`
 - `gui.PROP_SCALE`
 - `gui.PROP_COLOR`
 - `gui.PROP_OUTLINE`
@@ -1487,6 +1847,7 @@ with a custom curve. See the animation guide for more information.
 
 - `"position"`
 - `"rotation"`
+- `"euler"`
 - `"scale"`
 - `"color"`
 - `"outline"`
@@ -1537,6 +1898,31 @@ with a custom curve. See the animation guide for more information.
 	*/
 	export function delete_texture(texture: string | hash): void
 
+	/**
+	* Instead of using specific getters such as gui.get_position or gui.get_scale,
+	* you can use gui.get instead and supply the property as a string or a hash.
+	* While this function is similar to go.get, there are a few more restrictions
+	* when operating in the gui namespace. Most notably, only these propertie identifiers are supported:
+	* 
+	* - `"position"`
+	* - `"rotation"`
+	* - `"euler"`
+	* - `"scale"`
+	* - `"color"`
+	* - `"outline"`
+	* - `"shadow"`
+	* - `"size"`
+	* - `"fill_angle"` (pie)
+	* - `"inner_radius"` (pie)
+	* - `"slice9"` (slice9)
+	* 
+	* The value returned will either be a vmath.vector4 or a single number, i.e getting the "position"
+	* property will return a vec4 while getting the "position.x" property will return a single value.
+	* @param node  node to get the property for
+	* @param property  the property to retrieve
+	*/
+	export function get(node: node, property: any): void
+
 	/**
 	* Returns the adjust mode of a node.
 	* The adjust mode defines how the node will adjust itself to screen
@@ -1567,6 +1953,7 @@ with a custom curve. See the animation guide for more information.
 - `gui.BLEND_ADD`
 - `gui.BLEND_ADD_ALPHA`
 - `gui.BLEND_MULT`
+- `gui.BLEND_SCREEN`
 
 	*/
 	export function get_blend_mode(node: node): any
@@ -1630,6 +2017,14 @@ with a custom curve. See the animation guide for more information.
 	*/
 	export function get_color(node: node): vmath.vector4
 
+	/**
+	* Returns the rotation of the supplied node.
+	* The rotation is expressed in degree Euler angles.
+	* @param node  node to get the rotation from
+	* @return rotation  node rotation
+	*/
+	export function get_euler(node: node): vmath.vector3
+
 	/**
 	* Returns the sector angle of a pie node.
 	* @param node  node from which to get the fill angle
@@ -1819,11 +2214,11 @@ with a custom curve. See the animation guide for more information.
 
 	/**
 	* Returns the rotation of the supplied node.
-	* The rotation is expressed in degree Euler angles.
+	* The rotation is expressed as a quaternion
 	* @param node  node to get the rotation from
 	* @return rotation  node rotation
 	*/
-	export function get_rotation(node: node): vmath.vector3
+	export function get_rotation(node: node): vmath.quaternion
 
 	/**
 	* Returns the scale of the supplied node.
@@ -2013,7 +2408,7 @@ with a custom curve. See the animation guide for more information.
 
 	/**
 	* Dynamically create a new texture.
-	* @param texture  texture id
+	* @param texture_id  texture id
 	* @param width  texture width
 	* @param height  texture height
 	* @param type  texture type
@@ -2027,7 +2422,7 @@ with a custom curve. See the animation guide for more information.
 	* @return success  texture creation was successful
 	* @return code  one of the gui.RESULT_* codes if unsuccessful
 	*/
-	export function new_texture(texture: string | hash, width: number, height: number, type: any, buffer: string, flip: boolean): LuaMultiReturn<[boolean, number]>
+	export function new_texture(texture_id: string | hash, width: number, height: number, type: any, buffer: string, flip: boolean): LuaMultiReturn<[boolean, number]>
 
 	/**
 	* Tests whether a coordinate is within the bounding box of a
@@ -2115,6 +2510,36 @@ the new state of the emitter:
 	*/
 	export function screen_to_local(node: node, screen_position: vmath.vector3): vmath.vector3
 
+	/**
+	* Instead of using specific setteres such as gui.set_position or gui.set_scale,
+	* you can use gui.set instead and supply the property as a string or a hash.
+	* While this function is similar to go.get and go.set, there are a few more restrictions
+	* when operating in the gui namespace. Most notably, only these propertie identifiers are supported:
+	* 
+	* - `"position"`
+	* - `"rotation"`
+	* - `"euler"`
+	* - `"scale"`
+	* - `"color"`
+	* - `"outline"`
+	* - `"shadow"`
+	* - `"size"`
+	* - `"fill_angle"` (pie)
+	* - `"inner_radius"` (pie)
+	* - `"slice9"` (slice9)
+	* 
+	* The value to set must either be a vmath.vector4, vmath.vector3, vmath.quat or a single number and depends on the property name you want to set.
+	* I.e when setting the "position" property, you need to use a vmath.vector4 and when setting a single component of the property,
+	* such as "position.x", you need to use a single value.
+	* Note: When setting the rotation using the "rotation" property, you need to pass in a vmath.quat. This behaviour is different than from the gui.set_rotation function,
+	* the intention is to move new functionality closer to go namespace so that migrating between gui and go is easier. To set the rotation using degrees instead,
+	* use the "euler" property instead. The rotation and euler properties are linked, changing one of them will change the backing data of the other.
+	* @param node  node to set the property for
+	* @param property  the property to set
+	* @param value  the property to set
+	*/
+	export function set(node: node, property: any, value: number | vmath.vector4 | vmath.vector3 | vmath.quaternion): void
+
 	/**
 	* Sets the adjust mode on a node.
 	* The adjust mode defines how the node will adjust itself to screen
@@ -2146,6 +2571,7 @@ the new state of the emitter:
 - `gui.BLEND_ADD`
 - `gui.BLEND_ADD_ALPHA`
 - `gui.BLEND_MULT`
+- `gui.BLEND_SCREEN`
 
 	*/
 	export function set_blend_mode(node: node, blend_mode: any): void
@@ -2217,6 +2643,14 @@ the new state of the emitter:
 	*/
 	export function set_enabled(node: node, enabled: boolean): void
 
+	/**
+	* Sets the rotation of the supplied node.
+	* The rotation is expressed in degree Euler angles.
+	* @param node  node to set the rotation for
+	* @param rotation  new rotation
+	*/
+	export function set_euler(node: node, rotation: vmath.vector3 | vmath.vector4): void
+
 	/**
 	* Set the sector angle of a pie node.
 	* @param node  node to set the fill angle for
@@ -2383,11 +2817,11 @@ the new state of the emitter:
 
 	/**
 	* Sets the rotation of the supplied node.
-	* The rotation is expressed in degree Euler angles.
+	* The rotation is expressed as a quaternion
 	* @param node  node to set the rotation for
 	* @param rotation  new rotation
 	*/
-	export function set_rotation(node: node, rotation: vmath.vector3 | vmath.vector4): void
+	export function set_rotation(node: node, rotation: vmath.quaternion | vmath.vector4): void
 
 	/**
 	* Sets the scaling of the supplied node.
@@ -3562,7 +3996,8 @@ declare namespace render {
 	export function constant_buffer(): any
 
 	/**
-	* Deletes a previously created render target.
+	* Deletes a render target created by a render script.
+	* You cannot delete a render target resource.
 	* @param render_target  render target to delete
 	*/
 	export function delete_render_target(render_target: any): void
@@ -3589,10 +4024,10 @@ declare namespace render {
 	export function disable_state(state: any): void
 
 	/**
-	* Disables a texture unit for a render target that has previourly been enabled.
-	* @param unit  texture unit to disable
+	* Disables a texture that has previourly been enabled.
+	* @param binding  texture binding, either by texture unit, string or hash that should be disabled
 	*/
-	export function disable_texture(unit: number): void
+	export function disable_texture(binding: number | string | hash): void
 
 	/**
 	* Draws all objects that match a specified predicate. An optional constant buffer can be
@@ -3658,11 +4093,19 @@ Determines which sides of the frustum will be used. Default is render.FRUSTUM_PL
 	export function enable_state(state: any): void
 
 	/**
-	* Sets the specified render target's specified buffer to be
-	* used as texture with the specified unit.
-	* A material shader can then use the texture to sample from.
-	* @param unit  texture unit to enable texture for
-	* @param render_target  render target or texture from which to enable the specified texture unit
+	* Sets the specified texture handle for a render target attachment or a regular texture
+	* that should be used for rendering. The texture can be bound to either a texture unit
+	* or to a sampler name by a hash or a string.
+	* A texture can be bound to multiple units and sampler names at the same time,
+	* the actual binding will be applied to the shaders when a shader program is bound.
+	* When mixing binding using both units and sampler names, you might end up in situations
+	* where two different textures will be applied to the same bind location in the shader.
+	* In this case, the texture set to the named sampler will take precedence over the unit.
+	* Note that you can bind multiple sampler names to the same texture, in case you want to reuse
+	* the same texture for differnt use-cases. It is however recommended that you use the same name
+	* everywhere for the textures that should be shared across different materials.
+	* @param binding  texture binding, either by texture unit, string or hash for the sampler name that the texture should be bound to
+	* @param handle_or_name  render target or texture handle that should be bound, or a named resource in the "Render Resource" table in the currently assigned .render file
 	* @param buffer_type  optional buffer type from which to enable the texture. Note that this argument only applies to render targets. Defaults to `render.BUFFER_COLOR_BIT`. These values are supported:
 
 - `render.BUFFER_COLOR_BIT`
@@ -3681,7 +4124,7 @@ to enable those textures as well. Currently 4 color attachments are supported:
 - `render.BUFFER_COLOR3_BIT`
 
 	*/
-	export function enable_texture(unit: number, render_target: any, buffer_type?: any): void
+	export function enable_texture(binding: number | string | hash, handle_or_name: any, buffer_type?: any): void
 
 	/**
 	* Returns the logical window height that is set in the "game.project" settings.
@@ -4004,6 +4447,7 @@ to enable those textures as well. Currently 4 color attachments are supported:
 	/**
 	* Sets a render target. Subsequent draw operations will be to the
 	* render target until it is replaced by a subsequent call to set_render_target.
+	* This function supports render targets created by a render script, or a render target resource.
 	* @param render_target  render target to set. render.RENDER_TARGET_DEFAULT to set the default render target
 	* @param options  optional table with behaviour parameters
 
@@ -4021,7 +4465,8 @@ Transient frame buffer types are only valid while the render target is active, i
 	export function set_render_target(render_target: any, options?: any): void
 
 	/**
-	* sets the render target size
+	* Sets the render target size for a render target created from
+	* either a render script, or from a render target resource.
 	* @param render_target  render target to set size for
 	* @param width  new render target width
 	* @param height  new render target height
@@ -4307,7 +4752,7 @@ declare namespace resource {
 	* Note that releasing a resource essentially means decreasing the reference count of that resource,
 	* and not necessarily that it will be deleted.
 	* @param path  The path to the resource.
-	* @param table  A table containing info about how to create the texture. Supported entries:
+	* @param table  A table containing info about how to create the atlas. Supported entries:
 
 
 
@@ -4383,6 +4828,12 @@ A list of the geometries that should map to the texture data. Supports the follo
 
 
 
+`id`
+The name of the geometry. Used when matching animations between multiple atlases
+
+
+
+
 `vertices`
 a list of the vertices in texture space of the geometry in the form {px0, py0, px1, py1, ..., pxn, pyn}
 
@@ -4439,6 +4890,7 @@ optional flag to determine wether or not the resource should take over ownership
 	* registered will trigger an error. If the intention is to instead modify an existing texture, use the resource.set_texture
 	* function. Also note that the path to the new texture resource must have a '.texturec' extension,
 	* meaning "/path/my_texture" is not a valid path but "/path/my_texture.texturec" is.
+	* If the texture is created without a buffer, the pixel data will be blank.
 	* @param path  The path to the resource.
 	* @param table  A table containing info about how to create the texture. Supported entries:
 
@@ -4451,9 +4903,9 @@ The texture type. Supported values:
 
 
 `width`
-The width of the texture (in pixels)
+The width of the texture (in pixels). Must be larger than 0.
 `height`
-The width of the texture (in pixels)
+The width of the texture (in pixels). Must be larger than 0.
 `format`
 The texture format, note that some of these formats might not be supported by the running device. Supported values:
 
@@ -4463,6 +4915,7 @@ The texture format, note that some of these formats might not be supported by th
 - `resource.TEXTURE_FORMAT_RGBA`
 
 These constants might not be available on the device:
+
 - `resource.TEXTURE_FORMAT_RGB_PVRTC_2BPPV1`
 - `resource.TEXTURE_FORMAT_RGB_PVRTC_4BPPV1`
 - `resource.TEXTURE_FORMAT_RGBA_PVRTC_2BPPV1`
@@ -4483,6 +4936,7 @@ These constants might not be available on the device:
 - `resource.TEXTURE_FORMAT_RG16F`
 - `resource.TEXTURE_FORMAT_R32F`
 - `resource.TEXTURE_FORMAT_RG32F`
+
 You can test if the device supports these values by checking if a specific enum is nil or not:
 `if resource.TEXTURE_FORMAT_RGBA16F ~= nil then
     -- it is safe to use this format
@@ -4505,6 +4959,85 @@ Creating an empty texture with no buffer data is not supported as a core feature
 	*/
 	export function create_texture(path: string, table: any, buffer?: buffer): hash
 
+	/**
+	* Creates a new texture resource that can be used in the same way as any texture created during build time.
+	* The path used for creating the texture must be unique, trying to create a resource at a path that is already
+	* registered will trigger an error. If the intention is to instead modify an existing texture, use the resource.set_texture
+	* function. Also note that the path to the new texture resource must have a '.texturec' extension,
+	* meaning "/path/my_texture" is not a valid path but "/path/my_texture.texturec" is.
+	* If the texture is created without a buffer, the pixel data will be blank.
+	* The difference between the async version and resource.create_texture is that the texture data will be uploaded
+	* in a graphics worker thread. The function will return a resource immediately that contains a 1x1 blank texture which can be used
+	* immediately after the function call. When the new texture has been uploaded, the initial blank texture will be deleted and replaced with the
+	* new texture. Be careful when using the initial texture handle handle as it will not be valid after the upload has finished.
+	* @param path  The path to the resource.
+	* @param table  
+A table containing info about how to create the texture. Supported entries:
+`type`
+The texture type. Supported values:
+
+
+- `resource.TEXTURE_TYPE_2D`
+- `resource.TEXTURE_TYPE_CUBE_MAP`
+
+
+`width`
+The width of the texture (in pixels). Must be larger than 0.
+`height`
+The width of the texture (in pixels). Must be larger than 0.
+`format`
+The texture format, note that some of these formats might not be supported by the running device. Supported values:
+
+
+- `resource.TEXTURE_FORMAT_LUMINANCE`
+- `resource.TEXTURE_FORMAT_RGB`
+- `resource.TEXTURE_FORMAT_RGBA`
+
+These constants might not be available on the device:
+
+- `resource.TEXTURE_FORMAT_RGB_PVRTC_2BPPV1`
+- `resource.TEXTURE_FORMAT_RGB_PVRTC_4BPPV1`
+- `resource.TEXTURE_FORMAT_RGBA_PVRTC_2BPPV1`
+- `resource.TEXTURE_FORMAT_RGBA_PVRTC_4BPPV1`
+- `resource.TEXTURE_FORMAT_RGB_ETC1`
+- `resource.TEXTURE_FORMAT_RGBA_ETC2`
+- `resource.TEXTURE_FORMAT_RGBA_ASTC_4x4`
+- `resource.TEXTURE_FORMAT_RGB_BC1`
+- `resource.TEXTURE_FORMAT_RGBA_BC3`
+- `resource.TEXTURE_FORMAT_R_BC4`
+- `resource.TEXTURE_FORMAT_RG_BC5`
+- `resource.TEXTURE_FORMAT_RGBA_BC7`
+- `resource.TEXTURE_FORMAT_RGB16F`
+- `resource.TEXTURE_FORMAT_RGB32F`
+- `resource.TEXTURE_FORMAT_RGBA16F`
+- `resource.TEXTURE_FORMAT_RGBA32F`
+- `resource.TEXTURE_FORMAT_R16F`
+- `resource.TEXTURE_FORMAT_RG16F`
+- `resource.TEXTURE_FORMAT_R32F`
+- `resource.TEXTURE_FORMAT_RG32F`
+
+You can test if the device supports these values by checking if a specific enum is nil or not:
+`if resource.TEXTURE_FORMAT_RGBA16F ~= nil then
+    -- it is safe to use this format
+end
+`
+
+
+`max_mipmaps`
+optional max number of mipmaps. Defaults to zero, i.e no mipmap support
+`compression_type`
+optional specify the compression type for the data in the buffer object that holds the texture data. Will only be used when a compressed buffer has been passed into the function.
+Creating an empty texture with no buffer data is not supported as a core feature. Defaults to resource.COMPRESSION_TYPE_DEFAULT, i.e no compression. Supported values:
+
+
+- `COMPRESSION_TYPE_DEFAULT`
+- `COMPRESSION_TYPE_BASIS_UASTC`
+
+	* @param buffer  optional buffer of precreated pixel data
+	* @return path_  The path to the resource and the request id for the async request.
+	*/
+	export function create_texture_async(path: string, table: any, buffer?: buffer): any
+
 	/**
 	* Constructor-like function with two purposes:
 	* 
@@ -4537,6 +5070,48 @@ See resource.set_atlas for a detailed description of each field
 	*/
 	export function get_buffer(path: hash | string): buffer
 
+	/**
+	* Gets render target info from a render target resource path or a render target handle
+	* @param path  The path to the resource or a render target handle
+	* @return table  A table containing info about the render target:
+
+`handle`
+the opaque handle to the texture resource
+'attachments'
+a table of attachments, where each attachment contains the following entries:
+`handle`
+the opaque handle to the texture resource
+`width`
+width of the texture
+`height`
+height of the texture
+`depth`
+depth of the texture (i.e 1 for a 2D texture and 6 for a cube map)
+`mipmaps`
+number of mipmaps of the texture
+`type`
+The texture type. Supported values:
+
+
+- `resource.TEXTURE_TYPE_2D`
+- `resource.TEXTURE_TYPE_CUBE_MAP`
+- `resource.TEXTURE_TYPE_2D_ARRAY`
+
+
+`buffer_type`
+The attachment buffer type. Supported values:
+
+
+- `resource.BUFFER_TYPE_COLOR0`
+- `resource.BUFFER_TYPE_COLOR1`
+- `resource.BUFFER_TYPE_COLOR2`
+- `resource.BUFFER_TYPE_COLOR3`
+- `resource.BUFFER_TYPE_DEPTH`
+- `resource.BUFFER_TYPE_STENCIL`
+
+	*/
+	export function get_render_target_info(path: any): any
+
 	/**
 	* Gets the text metrics from a font
 	* @param url  the font to get the (unscaled) metrics from
@@ -5609,9 +6184,9 @@ The response data. Contains the fields:
 	* @param options  optional table with request parameters. Supported entries:
 
 `timeout`: timeout in seconds
-`path`: path on disc where to download the file. Only overwrites the path if status is 200
-`ignore_cache`: don't return cached data if we get a 304
-`chunked_transfer`: use chunked transfer encoding for https requests larger than 16kb. Defaults to true.
+Not available in HTML5 build
+Not available in HTML5 build
+Not available in HTML5 build
 
 	*/
 	export function request(url: string, method: string, callback: any, headers?: any, post_data?: string, options?: any): void
@@ -5645,7 +6220,13 @@ declare namespace image {
 	/**
 	* Load image (PNG or JPEG) from buffer.
 	* @param buffer  image data buffer
-	* @param premult  optional flag if alpha should be premultiplied. Defaults to `false`
+	* @param options  An optional table containing parameters for loading the image. Supported entries:
+
+`premultiply_alpha`
+True if alpha should be premultiplied into the color components. Defaults to `false`.
+`flip_vertically`
+True if the image contents should be flipped vertically. Defaults to `false`.
+
 	* @return image  object or `nil` if loading fails. The object is a table with the following fields:
 
 `width`: image width
@@ -5660,12 +6241,18 @@ declare namespace image {
 `buffer`: the raw image data
 
 	*/
-	export function load(buffer: string, premult?: boolean): LuaMultiReturn<[any, any]>
+	export function load(buffer: string, options?: any): LuaMultiReturn<[any, any]>
 
 	/**
 	* Load image (PNG or JPEG) from a string buffer.
 	* @param buffer  image data buffer
-	* @param premult  optional flag if alpha should be premultiplied. Defaults to `false`
+	* @param options  An optional table containing parameters for loading the image. Supported entries:
+
+`premultiply_alpha`
+True if alpha should be premultiplied into the color components. Defaults to `false`.
+`flip_vertically`
+True if the image contents should be flipped vertically. Defaults to `false`.
+
 	* @return image  object or `nil` if loading fails. The object is a table with the following fields:
 
 `width`: image width
@@ -5680,7 +6267,7 @@ declare namespace image {
 `buffer`: the script buffer that holds the decompressed image data. See buffer.create how to use the buffer.
 
 	*/
-	export function load_buffer(buffer: string, premult?: boolean): LuaMultiReturn<[any, any]>
+	export function load_buffer(buffer: string, options?: any): LuaMultiReturn<[any, any]>
 
 }
 // =^..^=   =^..^=   =^..^=    =^..^=    =^..^=    =^..^=    =^..^= //
@@ -6350,6 +6937,18 @@ declare namespace camera {
 	*/
 	export let aspect_ratio: any
 
+	/**
+	* makes camera active
+	* @param url  url of camera component
+	*/
+	export function acquire_focus(url: string | hash | url): void
+
+	/**
+	* deactivate camera
+	* @param url  url of camera component
+	*/
+	export function release_focus(url: string | hash | url): void
+
 	/**
 	* Camera frustum far plane.
 	* The type of the property is float.
@@ -6996,6 +7595,7 @@ declare namespace sound {
 	* Inversely, to find the linear value from a dB value, use the formula
 	* `10db/20`.
 	* ⚠ A sound will continue to play even if the game object the sound component belonged to is deleted. You can send a `stop_sound` to stop the sound.
+	* ⚠ `play_id` should be specified in case you want to receive `sound_done` or `sound_stopped` in `on_message()`.
 	*/
 	export type play_sound = "play_sound"
 
@@ -7140,7 +7740,7 @@ Information about the completion:
 `sender`
 The invoker of the callback: the sound component.
 
-	* @return id  The identifier for the sound voice
+	* @return play_id  The identifier for the sound voice
 	*/
 	export function play(url: string | hash | url, play_properties?: any, complete_function?: any): number
 
@@ -7186,14 +7786,14 @@ the sequential play identifier that should be stopped (was given by the sound.pl
 	export function stop(url: string | hash | url, stop_properties?: any): void
 
 	/**
-	* This message is sent back to the sender of a `play_sound` message, if the sound
-	* could be played to completion.
+	* This message is sent back to the sender of a `play_sound` message
+	* if the sound could be played to completion and a `play_id` was provided with the `play_sound` message.
 	*/
 	export type sound_done = "sound_done"
 
 	/**
 	* This message is sent back to the sender of a `play_sound` message, if the sound
-	* has been manually stopped.
+	* has been manually stopped and a `play_id` was provided with the `play_sound` message.
 	*/
 	export type sound_stopped = "sound_stopped"
 
@@ -7277,6 +7877,13 @@ declare namespace sprite {
 	*/
 	export let size: any
 
+	/**
+	* The slice values of the sprite. The type of the property is a vector4 that corresponds to
+	* the left, top, right, bottom values of the sprite in the editor.
+	* It is not possible to set the slice property if the size mode of the sprite is set to auto.
+	*/
+	export let slice: any
+
 	/**
 	* Play an animation on a sprite component from its tile set
 	* An optional completion callback function can be provided that will be called when

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-defold/types",
-  "version": "1.2.40",
+  "version": "1.2.42",
   "description": "TypeScript definitions for Defold",
   "repository": "github:ts-defold/types",
   "keywords": [