typescript-to-gdscript 0.1.0

package/typings/classes/CollisionObject3D.d.ts

@@ -0,0 +1,141 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract base class for 3D physics objects. */
+declare class CollisionObject3D extends Node3D {
+  /**
+   * The physics layers this CollisionObject3D **is in**. Collision objects can exist in one or more of 32 different layers. See also {@link collision_mask}.
+   * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_layer: int;
+  /**
+   * The physics layers this CollisionObject3D **scans**. Collision objects can scan one or more of 32 different layers. See also {@link collision_layer}.
+   * **Note:** Object A can detect a contact with object B only if object B is in any of the layers that object A scans. 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 priority used to solve colliding when occurring penetration. The higher the priority is, the lower the penetration into the object will be. This can for example be used to prevent the player from breaking through the boundaries of a level.
+   */
+  collision_priority: float;
+  /**
+   * Defines the behavior in physics when {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}.
+   */
+  disable_mode: int;
+  /**
+   * If `true`, the {@link CollisionObject3D} will continue to receive input events as the mouse is dragged across its shapes.
+   */
+  input_capture_on_drag: boolean;
+  /**
+   * If `true`, this object is pickable. A pickable object can detect the mouse pointer entering/leaving, and if the mouse is inside it, report input events. Requires at least one {@link collision_layer} bit to be set.
+   */
+  input_ray_pickable: boolean;
+  set_collision_layer(value: int): void;
+  get_collision_layer(): int;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_collision_priority(value: float): void;
+  get_collision_priority(): float;
+  set_disable_mode(value: int): void;
+  get_disable_mode(): int;
+  set_capture_input_on_drag(value: boolean): void;
+  get_capture_input_on_drag(): boolean;
+  set_ray_pickable(value: boolean): void;
+  is_ray_pickable(): boolean;
+
+  /**
+   * Receives unhandled {@link InputEvent}s. `event_position` is the location in world space of the mouse pointer on the surface of the shape with index `shape_idx` and `normal` is the normal vector of the surface at that point. Connect to the {@link input_event} signal to easily pick up these events.
+   * **Note:** {@link _input_event} requires {@link input_ray_pickable} to be `true` and at least one {@link collision_layer} bit to be set.
+   */
+  _input_event(camera: Camera3D, event: InputEvent, event_position: Vector3 | Vector3i, normal: Vector3 | Vector3i, shape_idx: int): void;
+  /**
+   * Called when the mouse pointer enters any of this object's shapes. Requires {@link input_ray_pickable} to be `true` and at least one {@link collision_layer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject3D} won't cause this function to be called.
+   */
+  _mouse_enter(): void;
+  /**
+   * Called when the mouse pointer exits all this object's shapes. Requires {@link input_ray_pickable} to be `true` and at least one {@link collision_layer} bit to be set. Note that moving between different shapes within a single {@link CollisionObject3D} won't cause this function to be called.
+   */
+  _mouse_exit(): void;
+  /**
+   * Creates a new shape owner for the given object. Returns `owner_id` of the new owner for future reference.
+   */
+  create_shape_owner(owner: GodotObject): int;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_layer} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_layer_value(layer_number: int): boolean;
+  /**
+   * Returns whether or not the specified layer of the {@link collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /** Returns the object's {@link RID}. */
+  get_rid(): RID;
+  /**
+   * Returns an {@link Array} of `owner_id` identifiers. You can use these ids in other methods that take `owner_id` as an argument.
+   */
+  get_shape_owners(): PackedInt32Array;
+  /** If `true`, the shape owner and its shapes are disabled. */
+  is_shape_owner_disabled(owner_id: int): boolean;
+  /** Removes the given shape owner. */
+  remove_shape_owner(owner_id: int): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_layer}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+  /** Returns the `owner_id` of the given shape. */
+  shape_find_owner(shape_index: int): int;
+  /** Adds a {@link Shape3D} to the shape owner. */
+  shape_owner_add_shape(owner_id: int, shape: Shape3D): void;
+  /** Removes all shapes from the shape owner. */
+  shape_owner_clear_shapes(owner_id: int): void;
+  /** Returns the parent object of the given shape owner. */
+  shape_owner_get_owner(owner_id: int): GodotObject | null;
+  /** Returns the {@link Shape3D} with the given ID from the given shape owner. */
+  shape_owner_get_shape(owner_id: int, shape_id: int): Shape3D | null;
+  /** Returns the number of shapes the given shape owner contains. */
+  shape_owner_get_shape_count(owner_id: int): int;
+  /** Returns the child index of the {@link Shape3D} with the given ID from the given shape owner. */
+  shape_owner_get_shape_index(owner_id: int, shape_id: int): int;
+  /** Returns the shape owner's {@link Transform3D}. */
+  shape_owner_get_transform(owner_id: int): Transform3D;
+  /** Removes a shape from the given shape owner. */
+  shape_owner_remove_shape(owner_id: int, shape_id: int): void;
+  /** If `true`, disables the given shape owner. */
+  shape_owner_set_disabled(owner_id: int, disabled: boolean): void;
+  /** Sets the {@link Transform3D} of the given shape owner. */
+  shape_owner_set_transform(owner_id: int, transform: Transform3D | Projection): void;
+
+  /**
+   * Emitted when the object receives an unhandled {@link InputEvent}. `event_position` is the location in world space of the mouse pointer on the surface of the shape with index `shape_idx` and `normal` is the normal vector of the surface at that point.
+   */
+  input_event: Signal<[Node, InputEvent, Vector3, Vector3, int]>;
+  /**
+   * Emitted when the mouse pointer enters any of this object's shapes. Requires {@link input_ray_pickable} to be `true` and at least one {@link collision_layer} bit to be set.
+   * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject3D}'s area is small. This signal may also not be emitted if another {@link CollisionObject3D} is overlapping the {@link CollisionObject3D} in question.
+   */
+  mouse_entered: Signal<[]>;
+  /**
+   * Emitted when the mouse pointer exits all this object's shapes. Requires {@link input_ray_pickable} to be `true` and at least one {@link collision_layer} bit to be set.
+   * **Note:** Due to the lack of continuous collision detection, this signal may not be emitted in the expected order if the mouse moves fast enough and the {@link CollisionObject3D}'s area is small. This signal may also not be emitted if another {@link CollisionObject3D} is overlapping the {@link CollisionObject3D} in question.
+   */
+  mouse_exited: Signal<[]>;
+
+  // enum DisableMode
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, remove from the physics simulation to stop all physics interactions with this {@link CollisionObject3D}.
+   * Automatically re-added to the physics simulation when the {@link Node} is processed again.
+   */
+  static readonly DISABLE_MODE_REMOVE: int;
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, make the body static. Doesn't affect {@link Area3D}. {@link PhysicsBody3D} can't be affected by forces or other bodies while static.
+   * Automatically set {@link PhysicsBody3D} back to its original mode when the {@link Node} is processed again.
+   */
+  static readonly DISABLE_MODE_MAKE_STATIC: int;
+  /**
+   * When {@link Node.process_mode} is set to {@link Node.PROCESS_MODE_DISABLED}, do not affect the physics simulation.
+   */
+  static readonly DISABLE_MODE_KEEP_ACTIVE: int;
+}

package/typings/classes/CollisionPolygon2D.d.ts

@@ -0,0 +1,51 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that provides a polygon shape to a {@link CollisionObject2D} parent. */
+declare class CollisionPolygon2D extends Node2D {
+  /** Collision build mode. */
+  build_mode: int;
+  /**
+   * If `true`, no collisions will be detected. This property should be changed with {@link Object.set_deferred}.
+   */
+  disabled: boolean;
+  /**
+   * If `true`, only edges that face up, relative to {@link CollisionPolygon2D}'s rotation, will collide with other objects.
+   * **Note:** This property has no effect if this {@link CollisionPolygon2D} is a child of an {@link Area2D} node.
+   * **Note:** The one way collision direction can be configured by setting {@link one_way_collision_direction}.
+   */
+  one_way_collision: boolean;
+  /** The direction used for one-way collision. */
+  one_way_collision_direction: Vector2;
+  /**
+   * The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the polygon at a high velocity.
+   */
+  one_way_collision_margin: float;
+  /**
+   * The polygon's list of vertices. Each point will be connected to the next, and the final point will be connected to the first.
+   * **Note:** The returned vertices are in the local coordinate space of the given {@link CollisionPolygon2D}.
+   */
+  polygon: PackedVector2Array;
+  set_build_mode(value: int): void;
+  get_build_mode(): int;
+  set_disabled(value: boolean): void;
+  is_disabled(): boolean;
+  set_one_way_collision(value: boolean): void;
+  is_one_way_collision_enabled(): boolean;
+  set_one_way_collision_direction(value: Vector2 | Vector2i): void;
+  get_one_way_collision_direction(): Vector2;
+  set_one_way_collision_margin(value: float): void;
+  get_one_way_collision_margin(): float;
+  set_polygon(value: PackedVector2Array | Array<unknown>): void;
+  get_polygon(): PackedVector2Array;
+
+  // enum BuildMode
+  /**
+   * Collisions will include the polygon and its contained area. In this mode the node has the same effect as several {@link ConvexPolygonShape2D} nodes, one for each convex shape in the convex decomposition of the polygon (but without the overhead of multiple nodes).
+   */
+  static readonly BUILD_SOLIDS: int;
+  /**
+   * Collisions will only include the polygon edges. In this mode the node has the same effect as a single {@link ConcavePolygonShape2D} made of segments, with the restriction that each segment (after the first one) starts where the previous one ends, and the last one ends where the first one starts (forming a closed but hollow polygon).
+   */
+  static readonly BUILD_SEGMENTS: int;
+}

package/typings/classes/CollisionPolygon3D.d.ts

@@ -0,0 +1,39 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that provides a thickened polygon shape (a prism) to a {@link CollisionObject3D} parent. */
+declare class CollisionPolygon3D extends Node3D {
+  /**
+   * The collision shape color that is displayed in the editor, or in the running project if **Debug > Visible Collision Shapes** is checked at the top of the editor.
+   * **Note:** The default value is {@link ProjectSettings.debug/shapes/collision/shape_color}. The `Color(0, 0, 0, 0)` value documented here is a placeholder, and not the actual default debug color.
+   */
+  debug_color: Color;
+  /**
+   * If `true`, when the shape is displayed, it will show a solid fill color in addition to its wireframe.
+   */
+  debug_fill: boolean;
+  /** Length that the resulting collision extends in either direction perpendicular to its 2D polygon. */
+  depth: float;
+  /**
+   * If `true`, no collision will be produced. This property should be changed with {@link Object.set_deferred}.
+   */
+  disabled: boolean;
+  /**
+   * The collision margin for the generated {@link Shape3D}. See {@link Shape3D.margin} for more details.
+   */
+  margin: float;
+  /** Array of vertices which define the 2D polygon in the local XY plane. */
+  polygon: PackedVector2Array;
+  set_debug_color(value: Color): void;
+  get_debug_color(): Color;
+  set_enable_debug_fill(value: boolean): void;
+  get_enable_debug_fill(): boolean;
+  set_depth(value: float): void;
+  get_depth(): float;
+  set_disabled(value: boolean): void;
+  is_disabled(): boolean;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_polygon(value: PackedVector2Array | Array<unknown>): void;
+  get_polygon(): PackedVector2Array;
+}

package/typings/classes/CollisionShape2D.d.ts

@@ -0,0 +1,41 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that provides a {@link Shape2D} to a {@link CollisionObject2D} parent. */
+declare class CollisionShape2D extends Node2D {
+  /**
+   * The collision shape color that is displayed in the editor, or in the running project if **Debug > Visible Collision Shapes** is checked at the top of the editor.
+   * **Note:** The default value is {@link ProjectSettings.debug/shapes/collision/shape_color}. The `Color(0, 0, 0, 0)` value documented here is a placeholder, and not the actual default debug color.
+   */
+  debug_color: Color;
+  /**
+   * A disabled collision shape has no effect in the world. This property should be changed with {@link Object.set_deferred}.
+   */
+  disabled: boolean;
+  /**
+   * Sets whether this collision shape should only detect collision on one side (top or bottom).
+   * **Note:** This property has no effect if this {@link CollisionShape2D} is a child of an {@link Area2D} node.
+   * **Note:** The one way collision direction can be configured by setting {@link one_way_collision_direction}.
+   */
+  one_way_collision: boolean;
+  /** The direction used for one-way collision. */
+  one_way_collision_direction: Vector2;
+  /**
+   * The margin used for one-way collision (in pixels). Higher values will make the shape thicker, and work better for colliders that enter the shape at a high velocity.
+   */
+  one_way_collision_margin: float;
+  /** The actual shape owned by this collision shape. */
+  shape: Shape2D | null;
+  set_debug_color(value: Color): void;
+  get_debug_color(): Color;
+  set_disabled(value: boolean): void;
+  is_disabled(): boolean;
+  set_one_way_collision(value: boolean): void;
+  is_one_way_collision_enabled(): boolean;
+  set_one_way_collision_direction(value: Vector2 | Vector2i): void;
+  get_one_way_collision_direction(): Vector2;
+  set_one_way_collision_margin(value: float): void;
+  get_one_way_collision_margin(): float;
+  set_shape(value: Shape2D | null): void;
+  get_shape(): Shape2D | null;
+}

package/typings/classes/CollisionShape3D.d.ts

@@ -0,0 +1,36 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that provides a {@link Shape3D} to a {@link CollisionObject3D} parent. */
+declare class CollisionShape3D extends Node3D {
+  /**
+   * The collision shape color that is displayed in the editor, or in the running project if **Debug > Visible Collision Shapes** is checked at the top of the editor.
+   * **Note:** The default value is {@link ProjectSettings.debug/shapes/collision/shape_color}. The `Color(0, 0, 0, 0)` value documented here is a placeholder, and not the actual default debug color.
+   */
+  debug_color: Color;
+  /**
+   * If `true`, when the shape is displayed, it will show a solid fill color in addition to its wireframe.
+   */
+  debug_fill: boolean;
+  /**
+   * A disabled collision shape has no effect in the world. This property should be changed with {@link Object.set_deferred}.
+   */
+  disabled: boolean;
+  /** The actual shape owned by this collision shape. */
+  shape: Shape3D | null;
+  set_debug_color(value: Color): void;
+  get_debug_color(): Color;
+  set_enable_debug_fill(value: boolean): void;
+  get_enable_debug_fill(): boolean;
+  set_disabled(value: boolean): void;
+  is_disabled(): boolean;
+  set_shape(value: Shape3D | null): void;
+  get_shape(): Shape3D | null;
+
+  /**
+   * Sets the collision shape's shape to the addition of all its convexed {@link MeshInstance3D} siblings geometry.
+   */
+  make_convex_from_siblings(): void;
+  /** This method does nothing. */
+  resource_changed(resource: Resource): void;
+}