typescript-to-gdscript 0.1.0

package/typings/classes/PhysicsDirectSpaceState3D.d.ts

@@ -0,0 +1,62 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides direct access to a physics space in the {@link PhysicsServer3D}. */
+declare class PhysicsDirectSpaceState3D extends GodotObject {
+  /**
+   * Checks how far a {@link Shape3D} can move without colliding. All the parameters for the query, including the shape and the motion, are supplied through a {@link PhysicsShapeQueryParameters3D} 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 Shape3D}s that the shape is already colliding with e.g. inside of, will be ignored. Use {@link collide_shape} to determine the {@link Shape3D}s that the shape is already colliding with.
+   */
+  cast_motion(parameters: PhysicsShapeQueryParameters3D): PackedFloat32Array;
+  /**
+   * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters3D} 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 PhysicsShapeQueryParameters3D} object, second one is in the collided shape from the physics space.
+   * **Note:** This method does not take into account the `motion` property of the object.
+   */
+  collide_shape(parameters: PhysicsShapeQueryParameters3D, max_results?: int): Array<Vector3>;
+  /**
+   * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters3D} 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 Vector3}. If the object is an {@link Area3D}, the result is `(0, 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.
+   * **Note:** This method does not take into account the `motion` property of the object.
+   */
+  get_rest_info(parameters: PhysicsShapeQueryParameters3D): Dictionary;
+  /**
+   * Checks whether a point is inside any solid shape. Position and other parameters are defined through {@link PhysicsPointQueryParameters3D}. 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.
+   */
+  intersect_point(parameters: PhysicsPointQueryParameters3D, max_results?: int): Array<Dictionary>;
+  /**
+   * Intersects a ray in a given space. Ray position and other parameters are defined through {@link PhysicsRayQueryParameters3D}. 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 `Vector3(0, 0, 0)` if the ray starts inside the shape and {@link PhysicsRayQueryParameters3D.hit_from_inside} is `true`.
+   * `position`: The intersection point.
+   * `face_index`: The face index at the intersection point.
+   * **Note:** Returns a valid number only if the intersected shape is a {@link ConcavePolygonShape3D}. Otherwise, `-1` is returned.
+   * `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: PhysicsRayQueryParameters3D): Dictionary;
+  /**
+   * Checks the intersections of a shape, given through a {@link PhysicsShapeQueryParameters3D} 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.
+   * **Note:** This method does not take into account the `motion` property of the object.
+   */
+  intersect_shape(parameters: PhysicsShapeQueryParameters3D, max_results?: int): Array<Dictionary>;
+}

package/typings/classes/PhysicsDirectSpaceState3DExtension.d.ts

@@ -0,0 +1,16 @@
+// 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 PhysicsDirectSpaceState3D} implementations.
+ */
+declare class PhysicsDirectSpaceState3DExtension extends PhysicsDirectSpaceState3D {
+  _cast_motion(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, closest_safe: float, closest_unsafe: float, info: unknown): boolean;
+  _collide_shape(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, results: void, max_results: int, result_count: int): boolean;
+  _get_closest_point_to_object_volume(object: RID, point: Vector3 | Vector3i): Vector3;
+  _intersect_point(position: Vector3 | Vector3i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, results: unknown, max_results: int): int;
+  _intersect_ray(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, hit_from_inside: boolean, hit_back_faces: boolean, pick_ray: boolean, result: unknown): boolean;
+  _intersect_shape(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, margin: float, collision_mask: int, collide_with_bodies: boolean, collide_with_areas: boolean, result_count: unknown, max_results: int): int;
+  _rest_info(shape_rid: RID, transform: Transform3D | Projection, motion: Vector3 | Vector3i, 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;
+}

package/typings/classes/PhysicsMaterial.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Holds physics-related properties of a surface, namely its roughness and bounciness. */
+declare class PhysicsMaterial extends Resource {
+  /** If `true`, subtracts the bounciness from the colliding object's bounciness instead of adding it. */
+  absorbent: boolean;
+  /**
+   * The body's bounciness. Values range from `0` (no bounce) to `1` (full bounciness).
+   * **Note:** Even with {@link bounce} set to `1.0`, some energy will be lost over time due to linear and angular damping. To have a physics body that preserves all its energy over time, set {@link bounce} to `1.0`, the body's linear damp mode to **Replace** (if applicable), its linear damp to `0.0`, its angular damp mode to **Replace** (if applicable), and its angular damp to `0.0`.
+   */
+  bounce: float;
+  /** The body's friction. Values range from `0` (frictionless) to `1` (maximum friction). */
+  friction: float;
+  /**
+   * If `true`, the physics engine will use the friction of the object marked as "rough" when two objects collide. If `false`, the physics engine will use the lowest friction of all colliding objects instead. If `true` for both colliding objects, the physics engine will use the highest friction.
+   */
+  rough: boolean;
+  set_absorbent(value: boolean): void;
+  is_absorbent(): boolean;
+  set_bounce(value: float): void;
+  get_bounce(): float;
+  set_friction(value: float): void;
+  get_friction(): float;
+  set_rough(value: boolean): void;
+  is_rough(): boolean;
+}

package/typings/classes/PhysicsPointQueryParameters2D.d.ts

@@ -0,0 +1,38 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsDirectSpaceState2D.intersect_point}. */
+declare class PhysicsPointQueryParameters2D extends RefCounted {
+  /**
+   * If different from `0`, restricts the query to a specific canvas layer specified by its instance ID. See {@link Object.get_instance_id}.
+   * If `0`, restricts the query to the Viewport's default canvas layer.
+   */
+  canvas_instance_id: int;
+  /** If `true`, the query will take {@link Area2D}s into account. */
+  collide_with_areas: boolean;
+  /** If `true`, the query will take {@link PhysicsBody2D}s into account. */
+  collide_with_bodies: boolean;
+  /**
+   * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject2D.get_rid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+   */
+  exclude: Array<RID>;
+  /** The position being queried for, in global coordinates. */
+  position: Vector2;
+  set_canvas_instance_id(value: int): void;
+  get_canvas_instance_id(): int;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_exclude(value: Array<RID>): void;
+  get_exclude(): Array<RID>;
+  set_position(value: Vector2 | Vector2i): void;
+  get_position(): Vector2;
+}

package/typings/classes/PhysicsPointQueryParameters3D.d.ts

@@ -0,0 +1,31 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsDirectSpaceState3D.intersect_point}. */
+declare class PhysicsPointQueryParameters3D extends RefCounted {
+  /** If `true`, the query will take {@link Area3D}s into account. */
+  collide_with_areas: boolean;
+  /** If `true`, the query will take {@link PhysicsBody3D}s into account. */
+  collide_with_bodies: boolean;
+  /**
+   * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject3D.get_rid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+   */
+  exclude: Array<RID>;
+  /** The position being queried for, in global coordinates. */
+  position: Vector3;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_exclude(value: Array<RID>): void;
+  get_exclude(): Array<RID>;
+  set_position(value: Vector3 | Vector3i): void;
+  get_position(): Vector3;
+}

package/typings/classes/PhysicsRayQueryParameters2D.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsDirectSpaceState2D.intersect_ray}. */
+declare class PhysicsRayQueryParameters2D extends RefCounted {
+  /** If `true`, the query will take {@link Area2D}s into account. */
+  collide_with_areas: boolean;
+  /** If `true`, the query will take {@link PhysicsBody2D}s into account. */
+  collide_with_bodies: boolean;
+  /**
+   * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject2D.get_rid} to get the {@link RID} associated with a {@link CollisionObject2D}-derived node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+   */
+  exclude: Array<RID>;
+  /** The starting point of the ray being queried for, in global coordinates. */
+  from: Vector2;
+  /**
+   * If `true`, the query will detect a hit when starting inside shapes. In this case the collision normal will be `Vector2(0, 0)`. Does not affect concave polygon shapes.
+   */
+  hit_from_inside: boolean;
+  /** The ending point of the ray being queried for, in global coordinates. */
+  to: Vector2;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_exclude(value: Array<RID>): void;
+  get_exclude(): Array<RID>;
+  set_from(value: Vector2 | Vector2i): void;
+  get_from(): Vector2;
+  set_hit_from_inside(value: boolean): void;
+  is_hit_from_inside_enabled(): boolean;
+  set_to(value: Vector2 | Vector2i): void;
+  get_to(): Vector2;
+
+  /**
+   * Returns a new, pre-configured {@link PhysicsRayQueryParameters2D} object. Use it to quickly create query parameters using the most common options.
+   */
+  static create(from_: Vector2 | Vector2i, to: Vector2 | Vector2i, collision_mask?: int, exclude?: Array<RID>): PhysicsRayQueryParameters2D;
+}

package/typings/classes/PhysicsRayQueryParameters3D.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides parameters for {@link PhysicsDirectSpaceState3D.intersect_ray}. */
+declare class PhysicsRayQueryParameters3D extends RefCounted {
+  /** If `true`, the query will take {@link Area3D}s into account. */
+  collide_with_areas: boolean;
+  /** If `true`, the query will take {@link PhysicsBody3D}s into account. */
+  collide_with_bodies: boolean;
+  /**
+   * The physics layers the query will detect (as a bitmask). By default, all collision layers are detected. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * The list of object {@link RID}s that will be excluded from collisions. Use {@link CollisionObject3D.get_rid} to get the {@link RID} associated with a {@link CollisionObject3D}-derived node.
+   * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then assign it to the property again.
+   */
+  exclude: Array<RID>;
+  /** The starting point of the ray being queried for, in global coordinates. */
+  from: Vector3;
+  /**
+   * If `true`, the query will hit back faces with concave polygon shapes with back face enabled or heightmap shapes.
+   */
+  hit_back_faces: boolean;
+  /**
+   * If `true`, the query will detect a hit when starting inside shapes. In this case the collision normal will be `Vector3(0, 0, 0)`. Does not affect concave polygon shapes or heightmap shapes.
+   */
+  hit_from_inside: boolean;
+  /** The ending point of the ray being queried for, in global coordinates. */
+  to: Vector3;
+  set_collide_with_areas(value: boolean): void;
+  is_collide_with_areas_enabled(): boolean;
+  set_collide_with_bodies(value: boolean): void;
+  is_collide_with_bodies_enabled(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_exclude(value: Array<RID>): void;
+  get_exclude(): Array<RID>;
+  set_from(value: Vector3 | Vector3i): void;
+  get_from(): Vector3;
+  set_hit_back_faces(value: boolean): void;
+  is_hit_back_faces_enabled(): boolean;
+  set_hit_from_inside(value: boolean): void;
+  is_hit_from_inside_enabled(): boolean;
+  set_to(value: Vector3 | Vector3i): void;
+  get_to(): Vector3;
+
+  /**
+   * Returns a new, pre-configured {@link PhysicsRayQueryParameters3D} object. Use it to quickly create query parameters using the most common options.
+   */
+  static create(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, collision_mask?: int, exclude?: Array<RID>): PhysicsRayQueryParameters3D;
+}