typescript-to-gdscript 0.1.0

package/typings/classes/PhysicsBody3D.d.ts

@@ -0,0 +1,51 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 3D game objects affected by physics. */
+declare class PhysicsBody3D extends CollisionObject3D {
+  /** Lock the body's rotation in the X axis. */
+  axis_lock_angular_x: boolean;
+  /** Lock the body's rotation in the Y axis. */
+  axis_lock_angular_y: boolean;
+  /** Lock the body's rotation in the Z axis. */
+  axis_lock_angular_z: boolean;
+  /** Lock the body's linear movement in the X axis. */
+  axis_lock_linear_x: boolean;
+  /** Lock the body's linear movement in the Y axis. */
+  axis_lock_linear_y: boolean;
+  /** Lock the body's linear movement in the Z axis. */
+  axis_lock_linear_z: boolean;
+
+  /** Adds a body to the list of bodies that this body can't collide with. */
+  add_collision_exception_with(body: Node): void;
+  /** Returns `true` if the specified linear or rotational `axis` is locked. */
+  get_axis_lock(axis: int): boolean;
+  /** Returns an array of nodes that were added as collision exceptions for this body. */
+  get_collision_exceptions(): Array<PhysicsBody3D>;
+  /**
+   * Returns the gravity vector computed from all sources that can affect the body, including all gravity overrides from {@link Area3D} nodes and the global world gravity.
+   */
+  get_gravity(): Vector3;
+  /**
+   * Moves the body along the vector `motion`. In order to be frame rate independent in {@link Node._physics_process} or {@link Node._process}, `motion` should be computed using `delta`.
+   * The body will stop if it collides. Returns a {@link KinematicCollision3D}, which contains information about the collision when stopped, or when touching another body along the motion.
+   * If `test_only` is `true`, the body does not move but the would-be collision information is given.
+   * `safe_margin` is the extra margin used for collision recovery (see {@link CharacterBody3D.safe_margin} for more details).
+   * If `recovery_as_collision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is used e.g. by {@link CharacterBody3D} for improving floor detection during floor snapping.
+   * `max_collisions` allows to retrieve more than one collision result.
+   */
+  move_and_collide(motion: Vector3 | Vector3i, test_only?: boolean, safe_margin?: float, recovery_as_collision?: boolean, max_collisions?: int): KinematicCollision3D | null;
+  /** Removes a body from the list of bodies that this body can't collide with. */
+  remove_collision_exception_with(body: Node): void;
+  /** Locks or unlocks the specified linear or rotational `axis` depending on the value of `lock`. */
+  set_axis_lock(axis: int, lock: boolean): void;
+  /**
+   * Checks for collisions without moving the body. In order to be frame rate independent in {@link Node._physics_process} or {@link Node._process}, `motion` should be computed using `delta`.
+   * Virtually sets the node's position, scale and rotation to that of the given {@link Transform3D}, then tries to move the body along the vector `motion`. Returns `true` if a collision would stop the body from moving along the whole path.
+   * `collision` is an optional object of type {@link KinematicCollision3D}, which contains additional information about the collision when stopped, or when touching another body along the motion.
+   * `safe_margin` is the extra margin used for collision recovery (see {@link CharacterBody3D.safe_margin} for more details).
+   * If `recovery_as_collision` is `true`, any depenetration from the recovery phase is also reported as a collision; this is useful for checking whether the body would *touch* any other bodies.
+   * `max_collisions` allows to retrieve more than one collision result.
+   */
+  test_move(from_: Transform3D | Projection, motion: Vector3 | Vector3i, collision?: KinematicCollision3D, safe_margin?: float, recovery_as_collision?: boolean, max_collisions?: int): boolean;
+}

package/typings/classes/PhysicsDirectBodyState2D.d.ts

@@ -0,0 +1,162 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides direct access to a physics body in the {@link PhysicsServer2D}. */
+declare class PhysicsDirectBodyState2D extends GodotObject {
+  /** The body's rotational velocity in *radians* per second. */
+  angular_velocity: float;
+  /** The body's center of mass position relative to the body's center in the global coordinate system. */
+  center_of_mass: Vector2;
+  /** The body's center of mass position in the body's local coordinate system. */
+  center_of_mass_local: Vector2;
+  /** The body's collision layer. */
+  collision_layer: int;
+  /** The body's collision mask. */
+  collision_mask: int;
+  /** The inverse of the inertia of the body. */
+  inverse_inertia: float;
+  /** The inverse of the mass of the body. */
+  inverse_mass: float;
+  /** The body's linear velocity in pixels per second. */
+  linear_velocity: Vector2;
+  /** If `true`, this body is currently sleeping (not active). */
+  sleeping: boolean;
+  /** The timestep (delta) used for the simulation. */
+  step: float;
+  /** The rate at which the body stops rotating, if there are not any other forces moving it. */
+  total_angular_damp: float;
+  /** The total gravity vector being currently applied to this body. */
+  total_gravity: Vector2;
+  /** The rate at which the body stops moving, if there are not any other forces moving it. */
+  total_linear_damp: float;
+  /** The body's transformation matrix. */
+  transform: Transform2D;
+  set_angular_velocity(value: float): void;
+  get_angular_velocity(): float;
+  get_center_of_mass(): Vector2;
+  get_center_of_mass_local(): Vector2;
+  set_collision_layer(value: int): void;
+  get_collision_layer(): int;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  get_inverse_inertia(): float;
+  get_inverse_mass(): float;
+  set_linear_velocity(value: Vector2 | Vector2i): void;
+  get_linear_velocity(): Vector2;
+  set_sleep_state(value: boolean): void;
+  is_sleeping(): boolean;
+  get_step(): float;
+  get_total_angular_damp(): float;
+  get_total_gravity(): Vector2;
+  get_total_linear_damp(): float;
+  set_transform(value: Transform2D): void;
+  get_transform(): Transform2D;
+
+  /**
+   * Adds a constant directional force without affecting rotation that keeps being applied over time until cleared with `constant_force = Vector2(0, 0)`.
+   * This is equivalent to using {@link add_constant_force} at the body's center of mass.
+   */
+  add_constant_central_force(force?: Vector2 | Vector2i): void;
+  /**
+   * Adds a constant positioned force to the body that keeps being applied over time until cleared with `constant_force = Vector2(0, 0)`.
+   * `position` is the offset from the body origin in global coordinates.
+   */
+  add_constant_force(force: Vector2 | Vector2i, position?: Vector2 | Vector2i): void;
+  /**
+   * Adds a constant rotational force without affecting position that keeps being applied over time until cleared with `constant_torque = 0`.
+   */
+  add_constant_torque(torque: float): void;
+  /**
+   * Applies a directional force without affecting rotation. A force is time dependent and meant to be applied every physics update.
+   * This is equivalent to using {@link apply_force} at the body's center of mass.
+   */
+  apply_central_force(force?: Vector2 | Vector2i): void;
+  /**
+   * Applies a directional impulse without affecting rotation.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+   * This is equivalent to using {@link apply_impulse} at the body's center of mass.
+   */
+  apply_central_impulse(impulse: Vector2 | Vector2i): void;
+  /**
+   * Applies a positioned force to the body. A force is time dependent and meant to be applied every physics update.
+   * `position` is the offset from the body origin in global coordinates.
+   */
+  apply_force(force: Vector2 | Vector2i, position?: Vector2 | Vector2i): void;
+  /**
+   * Applies a positioned impulse to the body.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+   * `position` is the offset from the body origin in global coordinates.
+   */
+  apply_impulse(impulse: Vector2 | Vector2i, position?: Vector2 | Vector2i): void;
+  /**
+   * Applies a rotational force without affecting position. A force is time dependent and meant to be applied every physics update.
+   * **Note:** {@link inverse_inertia} is required for this to work. To have {@link inverse_inertia}, an active {@link CollisionShape2D} must be a child of the node, or you can manually set {@link inverse_inertia}.
+   */
+  apply_torque(torque: float): void;
+  /**
+   * Applies a rotational impulse to the body without affecting the position.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+   * **Note:** {@link inverse_inertia} is required for this to work. To have {@link inverse_inertia}, an active {@link CollisionShape2D} must be a child of the node, or you can manually set {@link inverse_inertia}.
+   */
+  apply_torque_impulse(impulse: float): void;
+  /**
+   * Returns the body's total constant positional forces applied during each physics update.
+   * See {@link add_constant_force} and {@link add_constant_central_force}.
+   */
+  get_constant_force(): Vector2;
+  /**
+   * Returns the body's total constant rotational forces applied during each physics update.
+   * See {@link add_constant_torque}.
+   */
+  get_constant_torque(): float;
+  /** Returns the collider's {@link RID}. */
+  get_contact_collider(contact_idx: int): RID;
+  /** Returns the collider's object id. */
+  get_contact_collider_id(contact_idx: int): int;
+  /**
+   * Returns the collider object. This depends on how it was created (will return a scene node if such was used to create it).
+   */
+  get_contact_collider_object(contact_idx: int): GodotObject | null;
+  /** Returns the position of the contact point on the collider in the global coordinate system. */
+  get_contact_collider_position(contact_idx: int): Vector2;
+  /** Returns the collider's shape index. */
+  get_contact_collider_shape(contact_idx: int): int;
+  /** Returns the velocity vector at the collider's contact point. */
+  get_contact_collider_velocity_at_position(contact_idx: int): Vector2;
+  /**
+   * Returns the number of contacts this body has with other bodies.
+   * **Note:** By default, this returns 0 unless bodies are configured to monitor contacts. See {@link RigidBody2D.contact_monitor}.
+   */
+  get_contact_count(): int;
+  /** Returns the impulse created by the contact. */
+  get_contact_impulse(contact_idx: int): Vector2;
+  /** Returns the local normal at the contact point. */
+  get_contact_local_normal(contact_idx: int): Vector2;
+  /** Returns the position of the contact point on the body in the global coordinate system. */
+  get_contact_local_position(contact_idx: int): Vector2;
+  /** Returns the local shape index of the collision. */
+  get_contact_local_shape(contact_idx: int): int;
+  /** Returns the velocity vector at the body's contact point. */
+  get_contact_local_velocity_at_position(contact_idx: int): Vector2;
+  /** Returns the current state of the space, useful for queries. */
+  get_space_state(): PhysicsDirectSpaceState2D | null;
+  /**
+   * Returns the body's velocity at the given relative position.
+   * `local_position` is the offset from the body origin in global coordinates.
+   */
+  get_velocity_at_local_position(local_position: Vector2 | Vector2i): Vector2;
+  /**
+   * Updates the body's linear and angular velocity by applying gravity and damping for the equivalent of one physics tick.
+   */
+  integrate_forces(): void;
+  /**
+   * Sets the body's total constant positional forces applied during each physics update.
+   * See {@link add_constant_force} and {@link add_constant_central_force}.
+   */
+  set_constant_force(force: Vector2 | Vector2i): void;
+  /**
+   * Sets the body's total constant rotational forces applied during each physics update.
+   * See {@link add_constant_torque}.
+   */
+  set_constant_torque(torque: float): void;
+}

package/typings/classes/PhysicsDirectBodyState2DExtension.d.ts

@@ -0,0 +1,132 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Provides virtual methods that can be overridden to create custom {@link PhysicsDirectBodyState2D} implementations.
+ */
+declare class PhysicsDirectBodyState2DExtension extends PhysicsDirectBodyState2D {
+  /** Overridable version of {@link PhysicsDirectBodyState2D.add_constant_central_force}. */
+  _add_constant_central_force(force: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.add_constant_force}. */
+  _add_constant_force(force: Vector2 | Vector2i, position: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.add_constant_torque}. */
+  _add_constant_torque(torque: float): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.apply_central_force}. */
+  _apply_central_force(force: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.apply_central_impulse}. */
+  _apply_central_impulse(impulse: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.apply_force}. */
+  _apply_force(force: Vector2 | Vector2i, position: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.apply_impulse}. */
+  _apply_impulse(impulse: Vector2 | Vector2i, position: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.apply_torque}. */
+  _apply_torque(torque: float): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.apply_torque_impulse}. */
+  _apply_torque_impulse(impulse: float): void;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.angular_velocity} and its respective getter.
+   */
+  _get_angular_velocity(): float;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.center_of_mass} and its respective getter.
+   */
+  _get_center_of_mass(): Vector2;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.center_of_mass_local} and its respective getter.
+   */
+  _get_center_of_mass_local(): Vector2;
+  _get_collision_layer(): int;
+  _get_collision_mask(): int;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_constant_force}. */
+  _get_constant_force(): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_constant_torque}. */
+  _get_constant_torque(): float;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_collider}. */
+  _get_contact_collider(contact_idx: int): RID;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_collider_id}. */
+  _get_contact_collider_id(contact_idx: int): int;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_collider_object}. */
+  _get_contact_collider_object(contact_idx: int): GodotObject | null;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_collider_position}. */
+  _get_contact_collider_position(contact_idx: int): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_collider_shape}. */
+  _get_contact_collider_shape(contact_idx: int): int;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_collider_velocity_at_position}. */
+  _get_contact_collider_velocity_at_position(contact_idx: int): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_count}. */
+  _get_contact_count(): int;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_impulse}. */
+  _get_contact_impulse(contact_idx: int): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_local_normal}. */
+  _get_contact_local_normal(contact_idx: int): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_local_position}. */
+  _get_contact_local_position(contact_idx: int): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_local_shape}. */
+  _get_contact_local_shape(contact_idx: int): int;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_contact_local_velocity_at_position}. */
+  _get_contact_local_velocity_at_position(contact_idx: int): Vector2;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.inverse_inertia} and its respective getter.
+   */
+  _get_inverse_inertia(): float;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.inverse_mass} and its respective getter.
+   */
+  _get_inverse_mass(): float;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.linear_velocity} and its respective getter.
+   */
+  _get_linear_velocity(): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_space_state}. */
+  _get_space_state(): PhysicsDirectSpaceState2D | null;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.step} and its respective getter.
+   */
+  _get_step(): float;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.total_angular_damp} and its respective getter.
+   */
+  _get_total_angular_damp(): float;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.total_gravity} and its respective getter.
+   */
+  _get_total_gravity(): Vector2;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.total_linear_damp} and its respective getter.
+   */
+  _get_total_linear_damp(): float;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.transform} and its respective getter.
+   */
+  _get_transform(): Transform2D;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.get_velocity_at_local_position}. */
+  _get_velocity_at_local_position(local_position: Vector2 | Vector2i): Vector2;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.integrate_forces}. */
+  _integrate_forces(): void;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.sleeping} and its respective getter.
+   */
+  _is_sleeping(): boolean;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.angular_velocity} and its respective setter.
+   */
+  _set_angular_velocity(velocity: float): void;
+  _set_collision_layer(layer: int): void;
+  _set_collision_mask(mask: int): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.set_constant_force}. */
+  _set_constant_force(force: Vector2 | Vector2i): void;
+  /** Overridable version of {@link PhysicsDirectBodyState2D.set_constant_torque}. */
+  _set_constant_torque(torque: float): void;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.linear_velocity} and its respective setter.
+   */
+  _set_linear_velocity(velocity: Vector2 | Vector2i): void;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.sleeping} and its respective setter.
+   */
+  _set_sleep_state(enabled: boolean): void;
+  /**
+   * Implement to override the behavior of {@link PhysicsDirectBodyState2D.transform} and its respective setter.
+   */
+  _set_transform(transform: Transform2D): void;
+}

package/typings/classes/PhysicsDirectBodyState3D.d.ts

@@ -0,0 +1,165 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides direct access to a physics body in the {@link PhysicsServer3D}. */
+declare class PhysicsDirectBodyState3D extends GodotObject {
+  /** The body's rotational velocity in *radians* per second. */
+  angular_velocity: Vector3;
+  /** The body's center of mass position relative to the body's center in the global coordinate system. */
+  center_of_mass: Vector3;
+  /** The body's center of mass position in the body's local coordinate system. */
+  center_of_mass_local: Vector3;
+  /** The body's collision layer. */
+  collision_layer: int;
+  /** The body's collision mask. */
+  collision_mask: int;
+  /** The inverse of the inertia of the body. */
+  inverse_inertia: Vector3;
+  /** The inverse of the inertia tensor of the body. */
+  inverse_inertia_tensor: Basis;
+  /** The inverse of the mass of the body. */
+  inverse_mass: float;
+  /** The body's linear velocity in units per second. */
+  linear_velocity: Vector3;
+  principal_inertia_axes: Basis;
+  /** If `true`, this body is currently sleeping (not active). */
+  sleeping: boolean;
+  /** The timestep (delta) used for the simulation. */
+  step: float;
+  /** The rate at which the body stops rotating, if there are not any other forces moving it. */
+  total_angular_damp: float;
+  /** The total gravity vector being currently applied to this body. */
+  total_gravity: Vector3;
+  /** The rate at which the body stops moving, if there are not any other forces moving it. */
+  total_linear_damp: float;
+  /** The body's transformation matrix. */
+  transform: Transform3D;
+  set_angular_velocity(value: Vector3 | Vector3i): void;
+  get_angular_velocity(): Vector3;
+  get_center_of_mass(): Vector3;
+  get_center_of_mass_local(): Vector3;
+  set_collision_layer(value: int): void;
+  get_collision_layer(): int;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  get_inverse_inertia(): Vector3;
+  get_inverse_inertia_tensor(): Basis;
+  get_inverse_mass(): float;
+  set_linear_velocity(value: Vector3 | Vector3i): void;
+  get_linear_velocity(): Vector3;
+  get_principal_inertia_axes(): Basis;
+  set_sleep_state(value: boolean): void;
+  is_sleeping(): boolean;
+  get_step(): float;
+  get_total_angular_damp(): float;
+  get_total_gravity(): Vector3;
+  get_total_linear_damp(): float;
+  set_transform(value: Transform3D | Projection): void;
+  get_transform(): Transform3D;
+
+  /**
+   * Adds a constant directional force without affecting rotation that keeps being applied over time until cleared with `constant_force = Vector3(0, 0, 0)`.
+   * This is equivalent to using {@link add_constant_force} at the body's center of mass.
+   */
+  add_constant_central_force(force?: Vector3 | Vector3i): void;
+  /**
+   * Adds a constant positioned force to the body that keeps being applied over time until cleared with `constant_force = Vector3(0, 0, 0)`.
+   * `position` is the offset from the body origin in global coordinates.
+   */
+  add_constant_force(force: Vector3 | Vector3i, position?: Vector3 | Vector3i): void;
+  /**
+   * Adds a constant rotational force without affecting position that keeps being applied over time until cleared with `constant_torque = Vector3(0, 0, 0)`.
+   */
+  add_constant_torque(torque: Vector3 | Vector3i): void;
+  /**
+   * Applies a directional force without affecting rotation. A force is time dependent and meant to be applied every physics update.
+   * This is equivalent to using {@link apply_force} at the body's center of mass.
+   */
+  apply_central_force(force?: Vector3 | Vector3i): void;
+  /**
+   * Applies a directional impulse without affecting rotation.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+   * This is equivalent to using {@link apply_impulse} at the body's center of mass.
+   */
+  apply_central_impulse(impulse?: Vector3 | Vector3i): void;
+  /**
+   * Applies a positioned force to the body. A force is time dependent and meant to be applied every physics update.
+   * `position` is the offset from the body origin in global coordinates.
+   */
+  apply_force(force: Vector3 | Vector3i, position?: Vector3 | Vector3i): void;
+  /**
+   * Applies a positioned impulse to the body.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+   * `position` is the offset from the body origin in global coordinates.
+   */
+  apply_impulse(impulse: Vector3 | Vector3i, position?: Vector3 | Vector3i): void;
+  /**
+   * Applies a rotational force without affecting position. A force is time dependent and meant to be applied every physics update.
+   * **Note:** {@link inverse_inertia} is required for this to work. To have {@link inverse_inertia}, an active {@link CollisionShape3D} must be a child of the node, or you can manually set {@link inverse_inertia}.
+   */
+  apply_torque(torque: Vector3 | Vector3i): void;
+  /**
+   * Applies a rotational impulse to the body without affecting the position.
+   * An impulse is time-independent! Applying an impulse every frame would result in a framerate-dependent force. For this reason, it should only be used when simulating one-time impacts (use the "_force" functions otherwise).
+   * **Note:** {@link inverse_inertia} is required for this to work. To have {@link inverse_inertia}, an active {@link CollisionShape3D} must be a child of the node, or you can manually set {@link inverse_inertia}.
+   */
+  apply_torque_impulse(impulse: Vector3 | Vector3i): void;
+  /**
+   * Returns the body's total constant positional forces applied during each physics update.
+   * See {@link add_constant_force} and {@link add_constant_central_force}.
+   */
+  get_constant_force(): Vector3;
+  /**
+   * Returns the body's total constant rotational forces applied during each physics update.
+   * See {@link add_constant_torque}.
+   */
+  get_constant_torque(): Vector3;
+  /** Returns the collider's {@link RID}. */
+  get_contact_collider(contact_idx: int): RID;
+  /** Returns the collider's object id. */
+  get_contact_collider_id(contact_idx: int): int;
+  /** Returns the collider object. */
+  get_contact_collider_object(contact_idx: int): GodotObject | null;
+  /** Returns the position of the contact point on the collider in the global coordinate system. */
+  get_contact_collider_position(contact_idx: int): Vector3;
+  /** Returns the collider's shape index. */
+  get_contact_collider_shape(contact_idx: int): int;
+  /** Returns the linear velocity vector at the collider's contact point. */
+  get_contact_collider_velocity_at_position(contact_idx: int): Vector3;
+  /**
+   * Returns the number of contacts this body has with other bodies.
+   * **Note:** By default, this returns 0 unless bodies are configured to monitor contacts. See {@link RigidBody3D.contact_monitor}.
+   */
+  get_contact_count(): int;
+  /** Impulse created by the contact. */
+  get_contact_impulse(contact_idx: int): Vector3;
+  /** Returns the local normal at the contact point. */
+  get_contact_local_normal(contact_idx: int): Vector3;
+  /** Returns the position of the contact point on the body in the global coordinate system. */
+  get_contact_local_position(contact_idx: int): Vector3;
+  /** Returns the local shape index of the collision. */
+  get_contact_local_shape(contact_idx: int): int;
+  /** Returns the linear velocity vector at the body's contact point. */
+  get_contact_local_velocity_at_position(contact_idx: int): Vector3;
+  /** Returns the current state of the space, useful for queries. */
+  get_space_state(): PhysicsDirectSpaceState3D | null;
+  /**
+   * Returns the body's velocity at the given relative position.
+   * `local_position` is the offset from the body origin in global coordinates.
+   */
+  get_velocity_at_local_position(local_position: Vector3 | Vector3i): Vector3;
+  /**
+   * Updates the body's linear and angular velocity by applying gravity and damping for the equivalent of one physics tick.
+   */
+  integrate_forces(): void;
+  /**
+   * Sets the body's total constant positional forces applied during each physics update.
+   * See {@link add_constant_force} and {@link add_constant_central_force}.
+   */
+  set_constant_force(force: Vector3 | Vector3i): void;
+  /**
+   * Sets the body's total constant rotational forces applied during each physics update.
+   * See {@link add_constant_torque}.
+   */
+  set_constant_torque(torque: Vector3 | Vector3i): void;
+}

package/typings/classes/PhysicsDirectBodyState3DExtension.d.ts

@@ -0,0 +1,58 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Provides virtual methods that can be overridden to create custom {@link PhysicsDirectBodyState3D} implementations.
+ */
+declare class PhysicsDirectBodyState3DExtension extends PhysicsDirectBodyState3D {
+  _add_constant_central_force(force: Vector3 | Vector3i): void;
+  _add_constant_force(force: Vector3 | Vector3i, position: Vector3 | Vector3i): void;
+  _add_constant_torque(torque: Vector3 | Vector3i): void;
+  _apply_central_force(force: Vector3 | Vector3i): void;
+  _apply_central_impulse(impulse: Vector3 | Vector3i): void;
+  _apply_force(force: Vector3 | Vector3i, position: Vector3 | Vector3i): void;
+  _apply_impulse(impulse: Vector3 | Vector3i, position: Vector3 | Vector3i): void;
+  _apply_torque(torque: Vector3 | Vector3i): void;
+  _apply_torque_impulse(impulse: Vector3 | Vector3i): void;
+  _get_angular_velocity(): Vector3;
+  _get_center_of_mass(): Vector3;
+  _get_center_of_mass_local(): Vector3;
+  _get_collision_layer(): int;
+  _get_collision_mask(): int;
+  _get_constant_force(): Vector3;
+  _get_constant_torque(): Vector3;
+  _get_contact_collider(contact_idx: int): RID;
+  _get_contact_collider_id(contact_idx: int): int;
+  _get_contact_collider_object(contact_idx: int): GodotObject | null;
+  _get_contact_collider_position(contact_idx: int): Vector3;
+  _get_contact_collider_shape(contact_idx: int): int;
+  _get_contact_collider_velocity_at_position(contact_idx: int): Vector3;
+  _get_contact_count(): int;
+  _get_contact_impulse(contact_idx: int): Vector3;
+  _get_contact_local_normal(contact_idx: int): Vector3;
+  _get_contact_local_position(contact_idx: int): Vector3;
+  _get_contact_local_shape(contact_idx: int): int;
+  _get_contact_local_velocity_at_position(contact_idx: int): Vector3;
+  _get_inverse_inertia(): Vector3;
+  _get_inverse_inertia_tensor(): Basis;
+  _get_inverse_mass(): float;
+  _get_linear_velocity(): Vector3;
+  _get_principal_inertia_axes(): Basis;
+  _get_space_state(): PhysicsDirectSpaceState3D | null;
+  _get_step(): float;
+  _get_total_angular_damp(): float;
+  _get_total_gravity(): Vector3;
+  _get_total_linear_damp(): float;
+  _get_transform(): Transform3D;
+  _get_velocity_at_local_position(local_position: Vector3 | Vector3i): Vector3;
+  _integrate_forces(): void;
+  _is_sleeping(): boolean;
+  _set_angular_velocity(velocity: Vector3 | Vector3i): void;
+  _set_collision_layer(layer: int): void;
+  _set_collision_mask(mask: int): void;
+  _set_constant_force(force: Vector3 | Vector3i): void;
+  _set_constant_torque(torque: Vector3 | Vector3i): void;
+  _set_linear_velocity(velocity: Vector3 | Vector3i): void;
+  _set_sleep_state(enabled: boolean): void;
+  _set_transform(transform: Transform3D | Projection): void;
+}

package/typings/classes/PhysicsDirectSpaceState2D.d.ts

@@ -0,0 +1,58 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides direct access to a physics space in the {@link PhysicsServer2D}. */
+declare class PhysicsDirectSpaceState2D extends GodotObject {
+  /**
+   * Checks how far a {@link Shape2D} can move without colliding. All the parameters for the query, including the shape and the motion, are supplied through a {@link PhysicsShapeQueryParameters2D} object.
+   * Returns an array with the safe and unsafe proportions (between 0 and 1) of the motion. The safe proportion is the maximum fraction of the motion that can be made without a collision. The unsafe proportion is the minimum fraction of the distance that must be moved for a collision. If no collision is detected a result of `[1.0, 1.0]` will be returned.
+   * **Note:** Any {@link Shape2D}s that the shape is already colliding with e.g. inside of, will be ignored. Use {@link collide_shape} to determine the {@link Shape2D}s that the shape is already colliding with.
+   */
+  cast_motion(parameters: PhysicsShapeQueryParameters2D): PackedFloat32Array;
+  /**
+   * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters2D} object, against the space. The resulting array contains a list of points where the shape intersects another. Like with {@link intersect_shape}, the number of returned results can be limited to save processing time.
+   * Returned points are a list of pairs of contact points. For each pair the first one is in the shape passed in {@link PhysicsShapeQueryParameters2D} object, second one is in the collided shape from the physics space.
+   */
+  collide_shape(parameters: PhysicsShapeQueryParameters2D, max_results?: int): Array<Vector2>;
+  /**
+   * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters2D} object, against the space. If it collides with more than one shape, the nearest one is selected. The returned object is a dictionary containing the following fields:
+   * `collider_id`: The colliding object's ID.
+   * `linear_velocity`: The colliding object's velocity {@link Vector2}. If the object is an {@link Area2D}, the result is `(0, 0)`.
+   * `normal`: The collision normal of the query shape at the intersection point, pointing away from the intersecting object.
+   * `point`: The intersection point.
+   * `rid`: The intersecting object's {@link RID}.
+   * `shape`: The shape index of the colliding shape.
+   * If the shape did not intersect anything, then an empty dictionary is returned instead.
+   */
+  get_rest_info(parameters: PhysicsShapeQueryParameters2D): Dictionary;
+  /**
+   * Checks whether a point is inside any solid shape. Position and other parameters are defined through {@link PhysicsPointQueryParameters2D}. The shapes the point is inside of are returned in an array containing dictionaries with the following fields:
+   * `collider`: The colliding object.
+   * `collider_id`: The colliding object's ID.
+   * `rid`: The intersecting object's {@link RID}.
+   * `shape`: The shape index of the colliding shape.
+   * The number of intersections can be limited with the `max_results` parameter, to reduce the processing time.
+   * **Note:** {@link ConcavePolygonShape2D}s and {@link CollisionPolygon2D}s in `Segments` build mode are not solid shapes. Therefore, they will not be detected.
+   */
+  intersect_point(parameters: PhysicsPointQueryParameters2D, max_results?: int): Array<Dictionary>;
+  /**
+   * Intersects a ray in a given space. Ray position and other parameters are defined through {@link PhysicsRayQueryParameters2D}. The returned object is a dictionary with the following fields:
+   * `collider`: The colliding object.
+   * `collider_id`: The colliding object's ID.
+   * `normal`: The object's surface normal at the intersection point, or `Vector2(0, 0)` if the ray starts inside the shape and {@link PhysicsRayQueryParameters2D.hit_from_inside} is `true`.
+   * `position`: The intersection point.
+   * `rid`: The intersecting object's {@link RID}.
+   * `shape`: The shape index of the colliding shape.
+   * If the ray did not intersect anything, then an empty dictionary is returned instead.
+   */
+  intersect_ray(parameters: PhysicsRayQueryParameters2D): Dictionary;
+  /**
+   * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters2D} object, against the space. The intersected shapes are returned in an array containing dictionaries with the following fields:
+   * `collider`: The colliding object.
+   * `collider_id`: The colliding object's ID.
+   * `rid`: The intersecting object's {@link RID}.
+   * `shape`: The shape index of the colliding shape.
+   * The number of intersections can be limited with the `max_results` parameter, to reduce the processing time.
+   */
+  intersect_shape(parameters: PhysicsShapeQueryParameters2D, max_results?: int): Array<Dictionary>;
+}

package/typings/classes/PhysicsDirectSpaceState2DExtension.d.ts

@@ -0,0 +1,15 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Provides virtual methods that can be overridden to create custom {@link PhysicsDirectSpaceState2D} implementations.
+ */
+declare class PhysicsDirectSpaceState2DExtension extends PhysicsDirectSpaceState2D {
+  _cast_motion(shape_rid: RID, transform: Transform2D, motion: Vector2 | Vector2i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, closest_safe: float, closest_unsafe: float): boolean;
+  _collide_shape(shape_rid: RID, transform: Transform2D, motion: Vector2 | Vector2i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, results: void, max_results: int, result_count: int): boolean;
+  _intersect_point(position: Vector2 | Vector2i, canvas_instance_id: int, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, results: unknown, max_results: int): int;
+  _intersect_ray(from_: Vector2 | Vector2i, to: Vector2 | Vector2i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, hit_from_inside: boolean, result: unknown): boolean;
+  _intersect_shape(shape_rid: RID, transform: Transform2D, motion: Vector2 | Vector2i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, result: unknown, max_results: int): int;
+  _rest_info(shape_rid: RID, transform: Transform2D, motion: Vector2 | Vector2i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, rest_info: unknown): boolean;
+  is_body_excluded_from_query(body: RID): boolean;
+}