typescript-to-gdscript 0.1.0

package/typings/classes/GPUParticlesCollisionSDF3D.d.ts

@@ -0,0 +1,59 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A baked signed distance field 3D particle collision shape affecting {@link GPUParticles3D} nodes. */
+declare class GPUParticlesCollisionSDF3D extends GPUParticlesCollision3D {
+  /**
+   * The visual layers to account for when baking the particle collision SDF. Only {@link MeshInstance3D}s whose {@link VisualInstance3D.layers} match with this {@link bake_mask} will be included in the generated particle collision SDF. By default, all objects are taken into account for the particle collision SDF baking.
+   */
+  bake_mask: int;
+  /**
+   * The bake resolution to use for the signed distance field {@link texture}. The texture must be baked again for changes to the {@link resolution} property to be effective. Higher resolutions have a greater performance cost and take more time to bake. Higher resolutions also result in larger baked textures, leading to increased VRAM and storage space requirements. To improve performance and reduce bake times, use the lowest resolution possible for the object you're representing the collision of.
+   */
+  resolution: int;
+  /**
+   * The collision SDF's size in 3D units. To improve SDF quality, the {@link size} should be set as small as possible while covering the parts of the scene you need.
+   */
+  size: Vector3;
+  /** The 3D texture representing the signed distance field. */
+  texture: Texture3D | null;
+  /**
+   * The collision shape's thickness. Unlike other particle colliders, {@link GPUParticlesCollisionSDF3D} is actually hollow on the inside. {@link thickness} can be increased to prevent particles from tunneling through the collision shape at high speeds, or when the {@link GPUParticlesCollisionSDF3D} is moved.
+   */
+  thickness: float;
+  set_bake_mask(value: int): void;
+  get_bake_mask(): int;
+  set_resolution(value: int): void;
+  get_resolution(): int;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+  set_texture(value: Texture3D | null): void;
+  get_texture(): Texture3D | null;
+  set_thickness(value: float): void;
+  get_thickness(): float;
+
+  /**
+   * Returns whether or not the specified layer of the {@link bake_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_bake_mask_value(layer_number: int): boolean;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link bake_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_bake_mask_value(layer_number: int, value: boolean): void;
+
+  // enum Resolution
+  /** Bake a 16×16×16 signed distance field. This is the fastest option, but also the least precise. */
+  static readonly RESOLUTION_16: int;
+  /** Bake a 32×32×32 signed distance field. */
+  static readonly RESOLUTION_32: int;
+  /** Bake a 64×64×64 signed distance field. */
+  static readonly RESOLUTION_64: int;
+  /** Bake a 128×128×128 signed distance field. */
+  static readonly RESOLUTION_128: int;
+  /** Bake a 256×256×256 signed distance field. */
+  static readonly RESOLUTION_256: int;
+  /** Bake a 512×512×512 signed distance field. This is the slowest option, but also the most precise. */
+  static readonly RESOLUTION_512: int;
+  /** Represents the size of the {@link Resolution} enum. */
+  static readonly RESOLUTION_MAX: int;
+}

package/typings/classes/GPUParticlesCollisionSphere3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A sphere-shaped 3D particle collision shape affecting {@link GPUParticles3D} nodes. */
+declare class GPUParticlesCollisionSphere3D extends GPUParticlesCollision3D {
+  /** The collision sphere's radius in 3D units. */
+  radius: float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/Generic6DOFJoint3D.d.ts

@@ -0,0 +1,241 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A physics joint that allows for complex movement and rotation between two 3D physics bodies. */
+declare class Generic6DOFJoint3D extends Joint3D {
+  /**
+   * The amount of rotational damping across the X axis.
+   * The lower, the longer an impulse from one side takes to travel to the other side.
+   */
+  'angular_limit_x/damping': float;
+  /** If `true`, rotation across the X axis is limited. */
+  'angular_limit_x/enabled': boolean;
+  /**
+   * When rotating across the X axis, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
+   */
+  'angular_limit_x/erp': float;
+  /** The maximum amount of force that can occur, when rotating around the X axis. */
+  'angular_limit_x/force_limit': float;
+  /** The minimum rotation in negative direction to break loose and rotate around the X axis. */
+  'angular_limit_x/lower_angle': float;
+  /** The amount of rotational restitution across the X axis. The lower, the more restitution occurs. */
+  'angular_limit_x/restitution': float;
+  /** The speed of all rotations across the X axis. */
+  'angular_limit_x/softness': float;
+  /** The minimum rotation in positive direction to break loose and rotate around the X axis. */
+  'angular_limit_x/upper_angle': float;
+  /** The amount of rotational damping across the Y axis. The lower, the more damping occurs. */
+  'angular_limit_y/damping': float;
+  /** If `true`, rotation across the Y axis is limited. */
+  'angular_limit_y/enabled': boolean;
+  /**
+   * When rotating across the Y axis, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
+   */
+  'angular_limit_y/erp': float;
+  /** The maximum amount of force that can occur, when rotating around the Y axis. */
+  'angular_limit_y/force_limit': float;
+  /** The minimum rotation in negative direction to break loose and rotate around the Y axis. */
+  'angular_limit_y/lower_angle': float;
+  /** The amount of rotational restitution across the Y axis. The lower, the more restitution occurs. */
+  'angular_limit_y/restitution': float;
+  /** The speed of all rotations across the Y axis. */
+  'angular_limit_y/softness': float;
+  /** The minimum rotation in positive direction to break loose and rotate around the Y axis. */
+  'angular_limit_y/upper_angle': float;
+  /** The amount of rotational damping across the Z axis. The lower, the more damping occurs. */
+  'angular_limit_z/damping': float;
+  /** If `true`, rotation across the Z axis is limited. */
+  'angular_limit_z/enabled': boolean;
+  /**
+   * When rotating across the Z axis, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
+   */
+  'angular_limit_z/erp': float;
+  /** The maximum amount of force that can occur, when rotating around the Z axis. */
+  'angular_limit_z/force_limit': float;
+  /** The minimum rotation in negative direction to break loose and rotate around the Z axis. */
+  'angular_limit_z/lower_angle': float;
+  /** The amount of rotational restitution across the Z axis. The lower, the more restitution occurs. */
+  'angular_limit_z/restitution': float;
+  /** The speed of all rotations across the Z axis. */
+  'angular_limit_z/softness': float;
+  /** The minimum rotation in positive direction to break loose and rotate around the Z axis. */
+  'angular_limit_z/upper_angle': float;
+  /** If `true`, a rotating motor at the X axis is enabled. */
+  'angular_motor_x/enabled': boolean;
+  /** Maximum acceleration for the motor at the X axis. */
+  'angular_motor_x/force_limit': float;
+  /** Target speed for the motor at the X axis. */
+  'angular_motor_x/target_velocity': float;
+  /** If `true`, a rotating motor at the Y axis is enabled. */
+  'angular_motor_y/enabled': boolean;
+  /** Maximum acceleration for the motor at the Y axis. */
+  'angular_motor_y/force_limit': float;
+  /** Target speed for the motor at the Y axis. */
+  'angular_motor_y/target_velocity': float;
+  /** If `true`, a rotating motor at the Z axis is enabled. */
+  'angular_motor_z/enabled': boolean;
+  /** Maximum acceleration for the motor at the Z axis. */
+  'angular_motor_z/force_limit': float;
+  /** Target speed for the motor at the Z axis. */
+  'angular_motor_z/target_velocity': float;
+  'angular_spring_x/damping': float;
+  'angular_spring_x/enabled': boolean;
+  'angular_spring_x/equilibrium_point': float;
+  'angular_spring_x/stiffness': float;
+  'angular_spring_y/damping': float;
+  'angular_spring_y/enabled': boolean;
+  'angular_spring_y/equilibrium_point': float;
+  'angular_spring_y/stiffness': float;
+  'angular_spring_z/damping': float;
+  'angular_spring_z/enabled': boolean;
+  'angular_spring_z/equilibrium_point': float;
+  'angular_spring_z/stiffness': float;
+  /** The amount of damping that happens at the X motion. */
+  'linear_limit_x/damping': float;
+  /** If `true`, the linear motion across the X axis is limited. */
+  'linear_limit_x/enabled': boolean;
+  /** The minimum difference between the pivot points' X axis. */
+  'linear_limit_x/lower_distance': float;
+  /** The amount of restitution on the X axis movement. The lower, the more momentum gets lost. */
+  'linear_limit_x/restitution': float;
+  /** A factor applied to the movement across the X axis. The lower, the slower the movement. */
+  'linear_limit_x/softness': float;
+  /** The maximum difference between the pivot points' X axis. */
+  'linear_limit_x/upper_distance': float;
+  /** The amount of damping that happens at the Y motion. */
+  'linear_limit_y/damping': float;
+  /** If `true`, the linear motion across the Y axis is limited. */
+  'linear_limit_y/enabled': boolean;
+  /** The minimum difference between the pivot points' Y axis. */
+  'linear_limit_y/lower_distance': float;
+  /** The amount of restitution on the Y axis movement. The lower, the more momentum gets lost. */
+  'linear_limit_y/restitution': float;
+  /** A factor applied to the movement across the Y axis. The lower, the slower the movement. */
+  'linear_limit_y/softness': float;
+  /** The maximum difference between the pivot points' Y axis. */
+  'linear_limit_y/upper_distance': float;
+  /** The amount of damping that happens at the Z motion. */
+  'linear_limit_z/damping': float;
+  /** If `true`, the linear motion across the Z axis is limited. */
+  'linear_limit_z/enabled': boolean;
+  /** The minimum difference between the pivot points' Z axis. */
+  'linear_limit_z/lower_distance': float;
+  /** The amount of restitution on the Z axis movement. The lower, the more momentum gets lost. */
+  'linear_limit_z/restitution': float;
+  /** A factor applied to the movement across the Z axis. The lower, the slower the movement. */
+  'linear_limit_z/softness': float;
+  /** The maximum difference between the pivot points' Z axis. */
+  'linear_limit_z/upper_distance': float;
+  /**
+   * If `true`, then there is a linear motor on the X axis. It will attempt to reach the target velocity while staying within the force limits.
+   */
+  'linear_motor_x/enabled': boolean;
+  /**
+   * The maximum force the linear motor can apply on the X axis while trying to reach the target velocity.
+   */
+  'linear_motor_x/force_limit': float;
+  /** The speed that the linear motor will attempt to reach on the X axis. */
+  'linear_motor_x/target_velocity': float;
+  /**
+   * If `true`, then there is a linear motor on the Y axis. It will attempt to reach the target velocity while staying within the force limits.
+   */
+  'linear_motor_y/enabled': boolean;
+  /**
+   * The maximum force the linear motor can apply on the Y axis while trying to reach the target velocity.
+   */
+  'linear_motor_y/force_limit': float;
+  /** The speed that the linear motor will attempt to reach on the Y axis. */
+  'linear_motor_y/target_velocity': float;
+  /**
+   * If `true`, then there is a linear motor on the Z axis. It will attempt to reach the target velocity while staying within the force limits.
+   */
+  'linear_motor_z/enabled': boolean;
+  /**
+   * The maximum force the linear motor can apply on the Z axis while trying to reach the target velocity.
+   */
+  'linear_motor_z/force_limit': float;
+  /** The speed that the linear motor will attempt to reach on the Z axis. */
+  'linear_motor_z/target_velocity': float;
+  'linear_spring_x/damping': float;
+  'linear_spring_x/enabled': boolean;
+  'linear_spring_x/equilibrium_point': float;
+  'linear_spring_x/stiffness': float;
+  'linear_spring_y/damping': float;
+  'linear_spring_y/enabled': boolean;
+  'linear_spring_y/equilibrium_point': float;
+  'linear_spring_y/stiffness': float;
+  'linear_spring_z/damping': float;
+  'linear_spring_z/enabled': boolean;
+  'linear_spring_z/equilibrium_point': float;
+  'linear_spring_z/stiffness': float;
+
+  get_flag_x(flag: int): boolean;
+  get_flag_y(flag: int): boolean;
+  get_flag_z(flag: int): boolean;
+  get_param_x(param: int): float;
+  get_param_y(param: int): float;
+  get_param_z(param: int): float;
+  set_flag_x(flag: int, value: boolean): void;
+  set_flag_y(flag: int, value: boolean): void;
+  set_flag_z(flag: int, value: boolean): void;
+  set_param_x(param: int, value: float): void;
+  set_param_y(param: int, value: float): void;
+  set_param_z(param: int, value: float): void;
+
+  // enum Param
+  /** The minimum difference between the pivot points' axes. */
+  static readonly PARAM_LINEAR_LOWER_LIMIT: int;
+  /** The maximum difference between the pivot points' axes. */
+  static readonly PARAM_LINEAR_UPPER_LIMIT: int;
+  /** A factor applied to the movement across the axes. The lower, the slower the movement. */
+  static readonly PARAM_LINEAR_LIMIT_SOFTNESS: int;
+  /** The amount of restitution on the axes' movement. The lower, the more momentum gets lost. */
+  static readonly PARAM_LINEAR_RESTITUTION: int;
+  /** The amount of damping that happens at the linear motion across the axes. */
+  static readonly PARAM_LINEAR_DAMPING: int;
+  /** The velocity the linear motor will try to reach. */
+  static readonly PARAM_LINEAR_MOTOR_TARGET_VELOCITY: int;
+  /** The maximum force the linear motor will apply while trying to reach the velocity target. */
+  static readonly PARAM_LINEAR_MOTOR_FORCE_LIMIT: int;
+  static readonly PARAM_LINEAR_SPRING_STIFFNESS: int;
+  static readonly PARAM_LINEAR_SPRING_DAMPING: int;
+  static readonly PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT: int;
+  /** The minimum rotation in negative direction to break loose and rotate around the axes. */
+  static readonly PARAM_ANGULAR_LOWER_LIMIT: int;
+  /** The minimum rotation in positive direction to break loose and rotate around the axes. */
+  static readonly PARAM_ANGULAR_UPPER_LIMIT: int;
+  /** The speed of all rotations across the axes. */
+  static readonly PARAM_ANGULAR_LIMIT_SOFTNESS: int;
+  /** The amount of rotational damping across the axes. The lower, the more damping occurs. */
+  static readonly PARAM_ANGULAR_DAMPING: int;
+  /** The amount of rotational restitution across the axes. The lower, the more restitution occurs. */
+  static readonly PARAM_ANGULAR_RESTITUTION: int;
+  /** The maximum amount of force that can occur, when rotating around the axes. */
+  static readonly PARAM_ANGULAR_FORCE_LIMIT: int;
+  /**
+   * When rotating across the axes, this error tolerance factor defines how much the correction gets slowed down. The lower, the slower.
+   */
+  static readonly PARAM_ANGULAR_ERP: int;
+  /** Target speed for the motor at the axes. */
+  static readonly PARAM_ANGULAR_MOTOR_TARGET_VELOCITY: int;
+  /** Maximum acceleration for the motor at the axes. */
+  static readonly PARAM_ANGULAR_MOTOR_FORCE_LIMIT: int;
+  static readonly PARAM_ANGULAR_SPRING_STIFFNESS: int;
+  static readonly PARAM_ANGULAR_SPRING_DAMPING: int;
+  static readonly PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT: int;
+  /** Represents the size of the {@link Param} enum. */
+  static readonly PARAM_MAX: int;
+  // enum Flag
+  /** If enabled, linear motion is possible within the given limits. */
+  static readonly FLAG_ENABLE_LINEAR_LIMIT: int;
+  /** If enabled, rotational motion is possible within the given limits. */
+  static readonly FLAG_ENABLE_ANGULAR_LIMIT: int;
+  static readonly FLAG_ENABLE_LINEAR_SPRING: int;
+  static readonly FLAG_ENABLE_ANGULAR_SPRING: int;
+  /** If enabled, there is a rotational motor across these axes. */
+  static readonly FLAG_ENABLE_MOTOR: int;
+  /** If enabled, there is a linear motor across these axes. */
+  static readonly FLAG_ENABLE_LINEAR_MOTOR: int;
+  /** Represents the size of the {@link Flag} enum. */
+  static readonly FLAG_MAX: int;
+}

package/typings/classes/Geometry2D.d.ts

@@ -0,0 +1,147 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides methods for some common 2D geometric operations. */
+declare interface Geometry2D extends GodotObject {
+  /**
+   * Returns the Bresenham line (https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm) between the `from` and `to` points. A Bresenham line is a series of pixels that draws a line and is always 1-pixel thick on every row and column of the drawing (never more, never less).
+   * Example code to draw a line between two {@link Marker2D} nodes using a series of {@link CanvasItem.draw_rect} calls:
+   */
+  bresenham_line(from_: Vector2i | Vector2, to: Vector2i | Vector2): Array<Vector2i>;
+  /**
+   * Clips `polygon_a` against `polygon_b` and returns an array of clipped polygons. This performs {@link OPERATION_DIFFERENCE} between polygons. Returns an empty array if `polygon_b` completely overlaps `polygon_a`.
+   * If `polygon_b` is enclosed by `polygon_a`, returns an outer polygon (boundary) and inner polygon (hole) which could be distinguished by calling {@link is_polygon_clockwise}.
+   */
+  clip_polygons(polygon_a: PackedVector2Array | Array<unknown>, polygon_b: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Clips `polyline` against `polygon` and returns an array of clipped polylines. This performs {@link OPERATION_DIFFERENCE} between the polyline and the polygon. This operation can be thought of as cutting a line with a closed shape.
+   */
+  clip_polyline_with_polygon(polyline: PackedVector2Array | Array<unknown>, polygon: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Given an array of {@link Vector2}s, returns the convex hull as a list of points in counterclockwise order. The last point is the same as the first one.
+   */
+  convex_hull(points: PackedVector2Array | Array<unknown>): PackedVector2Array;
+  /**
+   * Decomposes the `polygon` into multiple convex hulls and returns an array of {@link PackedVector2Array}.
+   */
+  decompose_polygon_in_convex(polygon: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Mutually excludes common area defined by intersection of `polygon_a` and `polygon_b` (see {@link intersect_polygons}) and returns an array of excluded polygons. This performs {@link OPERATION_XOR} between polygons. In other words, returns all but common area between polygons.
+   * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link is_polygon_clockwise}.
+   */
+  exclude_polygons(polygon_a: PackedVector2Array | Array<unknown>, polygon_b: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Returns the 2D point on the 2D segment (`s1`, `s2`) that is closest to `point`. The returned point will always be inside the specified segment.
+   */
+  get_closest_point_to_segment(point: Vector2 | Vector2i, s1: Vector2 | Vector2i, s2: Vector2 | Vector2i): Vector2;
+  /**
+   * Returns the 2D point on the 2D line defined by (`s1`, `s2`) that is closest to `point`. The returned point can be inside the segment (`s1`, `s2`) or outside of it, i.e. somewhere on the line extending from the segment.
+   */
+  get_closest_point_to_segment_uncapped(point: Vector2 | Vector2i, s1: Vector2 | Vector2i, s2: Vector2 | Vector2i): Vector2;
+  /**
+   * Given the two 2D segments (`p1`, `q1`) and (`p2`, `q2`), finds those two points on the two segments that are closest to each other. Returns a {@link PackedVector2Array} that contains this point on (`p1`, `q1`) as well the accompanying point on (`p2`, `q2`).
+   */
+  get_closest_points_between_segments(p1: Vector2 | Vector2i, q1: Vector2 | Vector2i, p2: Vector2 | Vector2i, q2: Vector2 | Vector2i): PackedVector2Array;
+  /**
+   * Intersects `polygon_a` with `polygon_b` and returns an array of intersected polygons. This performs {@link OPERATION_INTERSECTION} between polygons. In other words, returns common area shared by polygons. Returns an empty array if no intersection occurs.
+   * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link is_polygon_clockwise}.
+   */
+  intersect_polygons(polygon_a: PackedVector2Array | Array<unknown>, polygon_b: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Intersects `polyline` with `polygon` and returns an array of intersected polylines. This performs {@link OPERATION_INTERSECTION} between the polyline and the polygon. This operation can be thought of as chopping a line with a closed shape.
+   */
+  intersect_polyline_with_polygon(polyline: PackedVector2Array | Array<unknown>, polygon: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Returns `true` if `point` is inside the circle or if it's located exactly *on* the circle's boundary, otherwise returns `false`.
+   */
+  is_point_in_circle(point: Vector2 | Vector2i, circle_position: Vector2 | Vector2i, circle_radius: float): boolean;
+  /**
+   * Returns `true` if `point` is inside `polygon` or if it's located exactly *on* polygon's boundary, otherwise returns `false`.
+   */
+  is_point_in_polygon(point: Vector2 | Vector2i, polygon: PackedVector2Array | Array<unknown>): boolean;
+  /**
+   * Returns `true` if `polygon`'s vertices are ordered in clockwise order, otherwise returns `false`.
+   * **Note:** Assumes a Cartesian coordinate system where `+x` is right and `+y` is up. If using screen coordinates (`+y` is down), the result will need to be flipped (i.e. a `true` result will indicate counter-clockwise).
+   */
+  is_polygon_clockwise(polygon: PackedVector2Array | Array<unknown>): boolean;
+  /**
+   * Returns the point of intersection between the two lines (`from_a`, `dir_a`) and (`from_b`, `dir_b`). Returns a {@link Vector2}, or `null` if the lines are parallel.
+   * `from` and `dir` are *not* endpoints of a line segment or ray but the slope (`dir`) and a known point (`from`) on that line.
+   */
+  line_intersects_line(from_a: Vector2 | Vector2i, dir_a: Vector2 | Vector2i, from_b: Vector2 | Vector2i, dir_b: Vector2 | Vector2i): unknown;
+  /**
+   * Given an array of {@link Vector2}s representing tiles, builds an atlas. The returned dictionary has two keys: `points` is a {@link PackedVector2Array} that specifies the positions of each tile, `size` contains the overall size of the whole atlas as {@link Vector2i}.
+   */
+  make_atlas(sizes: PackedVector2Array | Array<unknown>): Dictionary;
+  /**
+   * Merges (combines) `polygon_a` and `polygon_b` and returns an array of merged polygons. This performs {@link OPERATION_UNION} between polygons.
+   * The operation may result in an outer polygon (boundary) and multiple inner polygons (holes) produced which could be distinguished by calling {@link is_polygon_clockwise}.
+   */
+  merge_polygons(polygon_a: PackedVector2Array | Array<unknown>, polygon_b: PackedVector2Array | Array<unknown>): Array<PackedVector2Array>;
+  /**
+   * Inflates or deflates `polygon` by `delta` units (pixels). If `delta` is positive, makes the polygon grow outward. If `delta` is negative, shrinks the polygon inward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. Returns an empty array if `delta` is negative and the absolute value of it approximately exceeds the minimum bounding rectangle dimensions of the polygon.
+   * Each polygon's vertices will be rounded as determined by `join_type`.
+   * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link is_polygon_clockwise}.
+   * **Note:** To translate the polygon's vertices specifically, multiply them to a {@link Transform2D}:
+   */
+  offset_polygon(polygon: PackedVector2Array | Array<unknown>, delta: float, join_type: int): Array<PackedVector2Array>;
+  /**
+   * Inflates or deflates `polyline` by `delta` units (pixels), producing polygons. If `delta` is positive, makes the polyline grow outward. Returns an array of polygons because inflating/deflating may result in multiple discrete polygons. If `delta` is negative, returns an empty array.
+   * Each polygon's vertices will be rounded as determined by `join_type`.
+   * Each polygon's endpoints will be rounded as determined by `end_type`.
+   * The operation may result in an outer polygon (boundary) and inner polygon (hole) produced which could be distinguished by calling {@link is_polygon_clockwise}.
+   */
+  offset_polyline(polyline: PackedVector2Array | Array<unknown>, delta: float, join_type: int, end_type: int): Array<PackedVector2Array>;
+  /** Returns if `point` is inside the triangle specified by `a`, `b` and `c`. */
+  point_is_inside_triangle(point: Vector2 | Vector2i, a: Vector2 | Vector2i, b: Vector2 | Vector2i, c: Vector2 | Vector2i): boolean;
+  /**
+   * Given the 2D segment (`segment_from`, `segment_to`), returns the position on the segment (as a number between 0 and 1) at which the segment hits the circle that is located at position `circle_position` and has radius `circle_radius`. If the segment does not intersect the circle, -1 is returned (this is also the case if the line extending the segment would intersect the circle, but the segment does not).
+   */
+  segment_intersects_circle(segment_from: Vector2 | Vector2i, segment_to: Vector2 | Vector2i, circle_position: Vector2 | Vector2i, circle_radius: float): float;
+  /**
+   * Checks if the two segments (`from_a`, `to_a`) and (`from_b`, `to_b`) intersect. If yes, return the point of intersection as {@link Vector2}. If no intersection takes place, returns `null`.
+   */
+  segment_intersects_segment(from_a: Vector2 | Vector2i, to_a: Vector2 | Vector2i, from_b: Vector2 | Vector2i, to_b: Vector2 | Vector2i): unknown;
+  /**
+   * Triangulates the area specified by discrete set of `points` such that no point is inside the circumcircle of any resulting triangle. Returns a {@link PackedInt32Array} where each triangle consists of three consecutive point indices into `points` (i.e. the returned array will have `n * 3` elements, with `n` being the number of found triangles). If the triangulation did not succeed, an empty {@link PackedInt32Array} is returned.
+   */
+  triangulate_delaunay(points: PackedVector2Array | Array<unknown>): PackedInt32Array;
+  /**
+   * Triangulates the polygon specified by the points in `polygon`. Returns a {@link PackedInt32Array} where each triangle consists of three consecutive point indices into `polygon` (i.e. the returned array will have `n * 3` elements, with `n` being the number of found triangles). Output triangles will always be counter clockwise, and the contour will be flipped if it's clockwise. If the triangulation did not succeed, an empty {@link PackedInt32Array} is returned.
+   */
+  triangulate_polygon(polygon: PackedVector2Array | Array<unknown>): PackedInt32Array;
+
+  // enum PolyBooleanOperation
+  /** Create regions where either subject or clip polygons (or both) are filled. */
+  readonly OPERATION_UNION: int;
+  /** Create regions where subject polygons are filled except where clip polygons are filled. */
+  readonly OPERATION_DIFFERENCE: int;
+  /** Create regions where both subject and clip polygons are filled. */
+  readonly OPERATION_INTERSECTION: int;
+  /** Create regions where either subject or clip polygons are filled but not where both are filled. */
+  readonly OPERATION_XOR: int;
+  // enum PolyJoinType
+  /** Squaring is applied uniformally at all convex edge joins at `1 * delta`. */
+  readonly JOIN_SQUARE: int;
+  /**
+   * While flattened paths can never perfectly trace an arc, they are approximated by a series of arc chords.
+   */
+  readonly JOIN_ROUND: int;
+  /**
+   * There's a necessary limit to mitered joins since offsetting edges that join at very acute angles will produce excessively long and narrow "spikes". For any given edge join, when miter offsetting would exceed that maximum distance, "square" joining is applied.
+   */
+  readonly JOIN_MITER: int;
+  // enum PolyEndType
+  /** Endpoints are joined using the {@link PolyJoinType} value and the path filled as a polygon. */
+  readonly END_POLYGON: int;
+  /** Endpoints are joined using the {@link PolyJoinType} value and the path filled as a polyline. */
+  readonly END_JOINED: int;
+  /** Endpoints are squared off with no extension. */
+  readonly END_BUTT: int;
+  /** Endpoints are squared off and extended by `delta` units. */
+  readonly END_SQUARE: int;
+  /** Endpoints are rounded off and extended by `delta` units. */
+  readonly END_ROUND: int;
+}
+declare const Geometry2D: Geometry2D;
+

package/typings/classes/Geometry3D.d.ts

@@ -0,0 +1,67 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides methods for some common 3D geometric operations. */
+declare interface Geometry3D extends GodotObject {
+  /**
+   * Returns an array with 6 {@link Plane}s that describe the sides of a box centered at the origin. The box size is defined by `extents`, which represents one (positive) corner of the box (i.e. half its actual size).
+   */
+  build_box_planes(extents: Vector3 | Vector3i): Array<Plane>;
+  /**
+   * Returns an array of {@link Plane}s closely bounding a faceted capsule centered at the origin with radius `radius` and height `height`. The parameter `sides` defines how many planes will be generated for the side part of the capsule, whereas `lats` gives the number of latitudinal steps at the bottom and top of the capsule. The parameter `axis` describes the axis along which the capsule is oriented (0 for X, 1 for Y, 2 for Z).
+   */
+  build_capsule_planes(radius: float, height: float, sides: int, lats: int, axis: int): Array<Plane>;
+  /**
+   * Returns an array of {@link Plane}s closely bounding a faceted cylinder centered at the origin with radius `radius` and height `height`. The parameter `sides` defines how many planes will be generated for the round part of the cylinder. The parameter `axis` describes the axis along which the cylinder is oriented (0 for X, 1 for Y, 2 for Z).
+   */
+  build_cylinder_planes(radius: float, height: float, sides: int, axis: int): Array<Plane>;
+  /**
+   * Clips the polygon defined by the points in `points` against the `plane` and returns the points of the clipped polygon.
+   */
+  clip_polygon(points: PackedVector3Array | Array<unknown>, plane: Plane): PackedVector3Array;
+  /** Calculates and returns all the vertex points of a convex shape defined by an array of `planes`. */
+  compute_convex_mesh_points(planes: Array<Plane>): PackedVector3Array;
+  /**
+   * Returns the 3D point on the 3D segment (`s1`, `s2`) that is closest to `point`. The returned point will always be inside the specified segment.
+   */
+  get_closest_point_to_segment(point: Vector3 | Vector3i, s1: Vector3 | Vector3i, s2: Vector3 | Vector3i): Vector3;
+  /**
+   * Returns the 3D point on the 3D line defined by (`s1`, `s2`) that is closest to `point`. The returned point can be inside the segment (`s1`, `s2`) or outside of it, i.e. somewhere on the line extending from the segment.
+   */
+  get_closest_point_to_segment_uncapped(point: Vector3 | Vector3i, s1: Vector3 | Vector3i, s2: Vector3 | Vector3i): Vector3;
+  /**
+   * Given the two 3D segments (`p1`, `p2`) and (`q1`, `q2`), finds those two points on the two segments that are closest to each other. Returns a {@link PackedVector3Array} that contains this point on (`p1`, `p2`) as well the accompanying point on (`q1`, `q2`).
+   */
+  get_closest_points_between_segments(p1: Vector3 | Vector3i, p2: Vector3 | Vector3i, q1: Vector3 | Vector3i, q2: Vector3 | Vector3i): PackedVector3Array;
+  /**
+   * Returns a {@link Vector3} containing weights based on how close a 3D position (`point`) is to a triangle's different vertices (`a`, `b` and `c`). This is useful for interpolating between the data of different vertices in a triangle. One example use case is using this to smoothly rotate over a mesh instead of relying solely on face normals.
+   * Here is a more detailed explanation of barycentric coordinates. (https://en.wikipedia.org/wiki/Barycentric_coordinate_system)
+   */
+  get_triangle_barycentric_coords(point: Vector3 | Vector3i, a: Vector3 | Vector3i, b: Vector3 | Vector3i, c: Vector3 | Vector3i): Vector3;
+  /**
+   * Tests if the 3D ray starting at `from` with the direction of `dir` intersects the triangle specified by `a`, `b` and `c`. If yes, returns the point of intersection as {@link Vector3}. If no intersection takes place, returns `null`.
+   */
+  ray_intersects_triangle(from_: Vector3 | Vector3i, dir: Vector3 | Vector3i, a: Vector3 | Vector3i, b: Vector3 | Vector3i, c: Vector3 | Vector3i): unknown;
+  /**
+   * Given a convex hull defined though the {@link Plane}s in the array `planes`, tests if the segment (`from`, `to`) intersects with that hull. If an intersection is found, returns a {@link PackedVector3Array} containing the point the intersection and the hull's normal. Otherwise, returns an empty array.
+   */
+  segment_intersects_convex(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, planes: Array<Plane>): PackedVector3Array;
+  /**
+   * Checks if the segment (`from`, `to`) intersects the cylinder with height `height` that is centered at the origin and has radius `radius`. If no, returns an empty {@link PackedVector3Array}. If an intersection takes place, the returned array contains the point of intersection and the cylinder's normal at the point of intersection.
+   */
+  segment_intersects_cylinder(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, height: float, radius: float): PackedVector3Array;
+  /**
+   * Checks if the segment (`from`, `to`) intersects the sphere that is located at `sphere_position` and has radius `sphere_radius`. If no, returns an empty {@link PackedVector3Array}. If yes, returns a {@link PackedVector3Array} containing the point of intersection and the sphere's normal at the point of intersection.
+   */
+  segment_intersects_sphere(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, sphere_position: Vector3 | Vector3i, sphere_radius: float): PackedVector3Array;
+  /**
+   * Tests if the segment (`from`, `to`) intersects the triangle `a`, `b`, `c`. If yes, returns the point of intersection as {@link Vector3}. If no intersection takes place, returns `null`.
+   */
+  segment_intersects_triangle(from_: Vector3 | Vector3i, to: Vector3 | Vector3i, a: Vector3 | Vector3i, b: Vector3 | Vector3i, c: Vector3 | Vector3i): unknown;
+  /**
+   * Tetrahedralizes the volume specified by a discrete set of `points` in 3D space, ensuring that no point lies within the circumsphere of any resulting tetrahedron. The method returns a {@link PackedInt32Array} where each tetrahedron consists of four consecutive point indices into the `points` array (resulting in an array with `n * 4` elements, where `n` is the number of tetrahedra found). If the tetrahedralization is unsuccessful, an empty {@link PackedInt32Array} is returned.
+   */
+  tetrahedralize_delaunay(points: PackedVector3Array | Array<unknown>): PackedInt32Array;
+}
+declare const Geometry3D: Geometry3D;
+