typescript-to-gdscript 0.1.0

package/typings/classes/NavigationLink2D.d.ts

@@ -0,0 +1,77 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A link between two positions on {@link NavigationRegion2D}s that agents can be routed through. */
+declare class NavigationLink2D extends Node2D {
+  /**
+   * Whether this link can be traveled in both directions or only from {@link start_position} to {@link end_position}.
+   */
+  bidirectional: boolean;
+  /**
+   * Whether this link is currently active. If `false`, {@link NavigationServer2D.map_get_path} will ignore this link.
+   */
+  enabled: boolean;
+  /**
+   * Ending position of the link.
+   * This position will search out the nearest polygon in the navigation mesh to attach to.
+   * The distance the link will search is controlled by {@link NavigationServer2D.map_set_link_connection_radius}.
+   */
+  end_position: Vector2;
+  /**
+   * When pathfinding enters this link from another regions navigation mesh the {@link enter_cost} value is added to the path distance for determining the shortest path.
+   */
+  enter_cost: float;
+  /**
+   * A bitfield determining all navigation layers the link belongs to. These navigation layers will be checked when requesting a path with {@link NavigationServer2D.map_get_path}.
+   */
+  navigation_layers: int;
+  /**
+   * Starting position of the link.
+   * This position will search out the nearest polygon in the navigation mesh to attach to.
+   * The distance the link will search is controlled by {@link NavigationServer2D.map_set_link_connection_radius}.
+   */
+  start_position: Vector2;
+  /**
+   * When pathfinding moves along the link the traveled distance is multiplied with {@link travel_cost} for determining the shortest path.
+   */
+  travel_cost: float;
+  set_bidirectional(value: boolean): void;
+  is_bidirectional(): boolean;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_end_position(value: Vector2 | Vector2i): void;
+  get_end_position(): Vector2;
+  set_enter_cost(value: float): void;
+  get_enter_cost(): float;
+  set_navigation_layers(value: int): void;
+  get_navigation_layers(): int;
+  set_start_position(value: Vector2 | Vector2i): void;
+  get_start_position(): Vector2;
+  set_travel_cost(value: float): void;
+  get_travel_cost(): float;
+
+  /** Returns the {@link end_position} that is relative to the link as a global position. */
+  get_global_end_position(): Vector2;
+  /** Returns the {@link start_position} that is relative to the link as a global position. */
+  get_global_start_position(): Vector2;
+  /**
+   * Returns whether or not the specified layer of the {@link navigation_layers} bitmask is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_navigation_layer_value(layer_number: int): boolean;
+  /** Returns the current navigation map {@link RID} used by this link. */
+  get_navigation_map(): RID;
+  /** Returns the {@link RID} of this link on the {@link NavigationServer2D}. */
+  get_rid(): RID;
+  /** Sets the {@link end_position} that is relative to the link from a global `position`. */
+  set_global_end_position(position: Vector2 | Vector2i): void;
+  /** Sets the {@link start_position} that is relative to the link from a global `position`. */
+  set_global_start_position(position: Vector2 | Vector2i): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link navigation_layers} bitmask, given a `layer_number` between 1 and 32.
+   */
+  set_navigation_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the {@link RID} of the navigation map this link should use. By default the link will automatically join the {@link World2D} default navigation map so this function is only required to override the default map.
+   */
+  set_navigation_map(navigation_map: RID): void;
+}

package/typings/classes/NavigationLink3D.d.ts

@@ -0,0 +1,77 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A link between two positions on {@link NavigationRegion3D}s that agents can be routed through. */
+declare class NavigationLink3D extends Node3D {
+  /**
+   * Whether this link can be traveled in both directions or only from {@link start_position} to {@link end_position}.
+   */
+  bidirectional: boolean;
+  /**
+   * Whether this link is currently active. If `false`, {@link NavigationServer3D.map_get_path} will ignore this link.
+   */
+  enabled: boolean;
+  /**
+   * Ending position of the link.
+   * This position will search out the nearest polygon in the navigation mesh to attach to.
+   * The distance the link will search is controlled by {@link NavigationServer3D.map_set_link_connection_radius}.
+   */
+  end_position: Vector3;
+  /**
+   * When pathfinding enters this link from another regions navigation mesh the {@link enter_cost} value is added to the path distance for determining the shortest path.
+   */
+  enter_cost: float;
+  /**
+   * A bitfield determining all navigation layers the link belongs to. These navigation layers will be checked when requesting a path with {@link NavigationServer3D.map_get_path}.
+   */
+  navigation_layers: int;
+  /**
+   * Starting position of the link.
+   * This position will search out the nearest polygon in the navigation mesh to attach to.
+   * The distance the link will search is controlled by {@link NavigationServer3D.map_set_link_connection_radius}.
+   */
+  start_position: Vector3;
+  /**
+   * When pathfinding moves along the link the traveled distance is multiplied with {@link travel_cost} for determining the shortest path.
+   */
+  travel_cost: float;
+  set_bidirectional(value: boolean): void;
+  is_bidirectional(): boolean;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_end_position(value: Vector3 | Vector3i): void;
+  get_end_position(): Vector3;
+  set_enter_cost(value: float): void;
+  get_enter_cost(): float;
+  set_navigation_layers(value: int): void;
+  get_navigation_layers(): int;
+  set_start_position(value: Vector3 | Vector3i): void;
+  get_start_position(): Vector3;
+  set_travel_cost(value: float): void;
+  get_travel_cost(): float;
+
+  /** Returns the {@link end_position} that is relative to the link as a global position. */
+  get_global_end_position(): Vector3;
+  /** Returns the {@link start_position} that is relative to the link as a global position. */
+  get_global_start_position(): Vector3;
+  /**
+   * Returns whether or not the specified layer of the {@link navigation_layers} bitmask is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_navigation_layer_value(layer_number: int): boolean;
+  /** Returns the current navigation map {@link RID} used by this link. */
+  get_navigation_map(): RID;
+  /** Returns the {@link RID} of this link on the {@link NavigationServer3D}. */
+  get_rid(): RID;
+  /** Sets the {@link end_position} that is relative to the link from a global `position`. */
+  set_global_end_position(position: Vector3 | Vector3i): void;
+  /** Sets the {@link start_position} that is relative to the link from a global `position`. */
+  set_global_start_position(position: Vector3 | Vector3i): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link navigation_layers} bitmask, given a `layer_number` between 1 and 32.
+   */
+  set_navigation_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the {@link RID} of the navigation map this link should use. By default the link will automatically join the {@link World3D} default navigation map so this function is only required to override the default map.
+   */
+  set_navigation_map(navigation_map: RID): void;
+}

package/typings/classes/NavigationMesh.d.ts

@@ -0,0 +1,207 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A navigation mesh that defines traversable areas and obstacles. */
+declare class NavigationMesh extends Resource {
+  /**
+   * The minimum floor to ceiling height that will still allow the floor area to be considered walkable.
+   * **Note:** While baking, this value will be rounded up to the nearest multiple of {@link cell_height}.
+   */
+  agent_height: float;
+  /**
+   * The minimum ledge height that is considered to still be traversable.
+   * **Note:** While baking, this value will be rounded down to the nearest multiple of {@link cell_height}.
+   */
+  agent_max_climb: float;
+  /** The maximum slope that is considered walkable, in degrees. */
+  agent_max_slope: float;
+  /**
+   * The distance to erode/shrink the walkable area of the heightfield away from obstructions.
+   * **Note:** While baking, this value will be rounded up to the nearest multiple of {@link cell_size}.
+   * **Note:** The radius must be equal or higher than `0.0`. If the radius is `0.0`, it won't be possible to fix invalid outline overlaps and other precision errors during the baking process. As a result, some obstacles may be excluded incorrectly from the final navigation mesh, or may delete the navigation mesh's polygons.
+   */
+  agent_radius: float;
+  /**
+   * The size of the non-navigable border around the bake bounding area.
+   * In conjunction with the {@link filter_baking_aabb} and a {@link edge_max_error} value at `1.0` or below the border size can be used to bake tile aligned navigation meshes without the tile edges being shrunk by {@link agent_radius}.
+   * **Note:** If this value is not `0.0`, it will be rounded up to the nearest multiple of {@link cell_size} during baking.
+   */
+  border_size: float;
+  /**
+   * The cell height used to rasterize the navigation mesh vertices on the Y axis. Must match with the cell height on the navigation map.
+   */
+  cell_height: float;
+  /**
+   * The cell size used to rasterize the navigation mesh vertices on the XZ plane. Must match with the cell size on the navigation map.
+   */
+  cell_size: float;
+  /** The sampling distance to use when generating the detail mesh, in cell unit. */
+  detail_sample_distance: float;
+  /** The maximum distance the detail mesh surface should deviate from heightfield, in cell unit. */
+  detail_sample_max_error: float;
+  /** The maximum distance a simplified contour's border edges should deviate the original raw contour. */
+  edge_max_error: float;
+  /**
+   * The maximum allowed length for contour edges along the border of the mesh. A value of `0.0` disables this feature.
+   * **Note:** While baking, this value will be rounded up to the nearest multiple of {@link cell_size}.
+   */
+  edge_max_length: float;
+  /**
+   * If the baking {@link AABB} has a volume the navigation mesh baking will be restricted to its enclosing area.
+   */
+  filter_baking_aabb: AABB;
+  /** The position offset applied to the {@link filter_baking_aabb} {@link AABB}. */
+  filter_baking_aabb_offset: Vector3;
+  /** If `true`, marks spans that are ledges as non-walkable. */
+  filter_ledge_spans: boolean;
+  /**
+   * If `true`, marks non-walkable spans as walkable if their maximum is within {@link agent_max_climb} of a walkable neighbor.
+   */
+  filter_low_hanging_obstacles: boolean;
+  /**
+   * If `true`, marks walkable spans as not walkable if the clearance above the span is less than {@link agent_height}.
+   */
+  filter_walkable_low_height_spans: boolean;
+  /**
+   * The physics layers to scan for static colliders.
+   * Only used when {@link geometry_parsed_geometry_type} is {@link PARSED_GEOMETRY_STATIC_COLLIDERS} or {@link PARSED_GEOMETRY_BOTH}.
+   */
+  geometry_collision_mask: int;
+  /** Determines which type of nodes will be parsed as geometry. */
+  geometry_parsed_geometry_type: int;
+  /** The source of the geometry used when baking. */
+  geometry_source_geometry_mode: int;
+  /**
+   * The name of the group to scan for geometry.
+   * Only used when {@link geometry_source_geometry_mode} is {@link SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN} or {@link SOURCE_GEOMETRY_GROUPS_EXPLICIT}.
+   */
+  geometry_source_group_name: string;
+  /**
+   * Any regions with a size smaller than this will be merged with larger regions if possible.
+   * **Note:** This value will be squared to calculate the number of cells. For example, a value of 20 will set the number of cells to 400.
+   */
+  region_merge_size: float;
+  /**
+   * The minimum size of a region for it to be created.
+   * **Note:** This value will be squared to calculate the minimum number of cells allowed to form isolated island areas. For example, a value of 8 will set the number of cells to 64.
+   */
+  region_min_size: float;
+  /** Partitioning algorithm for creating the navigation mesh polys. */
+  sample_partition_type: int;
+  /**
+   * The maximum number of vertices allowed for polygons generated during the contour to polygon conversion process.
+   */
+  vertices_per_polygon: float;
+  set_agent_height(value: float): void;
+  get_agent_height(): float;
+  set_agent_max_climb(value: float): void;
+  get_agent_max_climb(): float;
+  set_agent_max_slope(value: float): void;
+  get_agent_max_slope(): float;
+  set_agent_radius(value: float): void;
+  get_agent_radius(): float;
+  set_border_size(value: float): void;
+  get_border_size(): float;
+  set_cell_height(value: float): void;
+  get_cell_height(): float;
+  set_cell_size(value: float): void;
+  get_cell_size(): float;
+  set_detail_sample_distance(value: float): void;
+  get_detail_sample_distance(): float;
+  set_detail_sample_max_error(value: float): void;
+  get_detail_sample_max_error(): float;
+  set_edge_max_error(value: float): void;
+  get_edge_max_error(): float;
+  set_edge_max_length(value: float): void;
+  get_edge_max_length(): float;
+  set_filter_baking_aabb(value: AABB): void;
+  get_filter_baking_aabb(): AABB;
+  set_filter_baking_aabb_offset(value: Vector3 | Vector3i): void;
+  get_filter_baking_aabb_offset(): Vector3;
+  set_filter_ledge_spans(value: boolean): void;
+  get_filter_ledge_spans(): boolean;
+  set_filter_low_hanging_obstacles(value: boolean): void;
+  get_filter_low_hanging_obstacles(): boolean;
+  set_filter_walkable_low_height_spans(value: boolean): void;
+  get_filter_walkable_low_height_spans(): boolean;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_parsed_geometry_type(value: int): void;
+  get_parsed_geometry_type(): int;
+  set_source_geometry_mode(value: int): void;
+  get_source_geometry_mode(): int;
+  set_source_group_name(value: string): void;
+  get_source_group_name(): string;
+  set_region_merge_size(value: float): void;
+  get_region_merge_size(): float;
+  set_region_min_size(value: float): void;
+  get_region_min_size(): float;
+  set_sample_partition_type(value: int): void;
+  get_sample_partition_type(): int;
+  set_vertices_per_polygon(value: float): void;
+  get_vertices_per_polygon(): float;
+
+  /** Adds a polygon using the indices of the vertices you get when calling {@link get_vertices}. */
+  add_polygon(polygon: PackedInt32Array | Array<unknown>): void;
+  /** Clears the internal arrays for vertices and polygon indices. */
+  clear(): void;
+  /** Clears the array of polygons, but it doesn't clear the array of vertices. */
+  clear_polygons(): void;
+  /**
+   * Initializes the navigation mesh by setting the vertices and indices according to a {@link Mesh}.
+   * **Note:** The given `mesh` must be of type {@link Mesh.PRIMITIVE_TRIANGLES} and have an index array.
+   */
+  create_from_mesh(mesh: Mesh): void;
+  /**
+   * Returns whether or not the specified layer of the {@link geometry_collision_mask} is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_collision_mask_value(layer_number: int): boolean;
+  /** Returns a {@link PackedInt32Array} containing the indices of the vertices of a created polygon. */
+  get_polygon(idx: int): PackedInt32Array;
+  /** Returns the number of polygons in the navigation mesh. */
+  get_polygon_count(): int;
+  /** Returns a {@link PackedVector3Array} containing all the vertices being used to create the polygons. */
+  get_vertices(): PackedVector3Array;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link geometry_collision_mask}, given a `layer_number` between 1 and 32.
+   */
+  set_collision_mask_value(layer_number: int, value: boolean): void;
+  /** Sets the vertices that can be then indexed to create polygons with the {@link add_polygon} method. */
+  set_vertices(vertices: PackedVector3Array | Array<unknown>): void;
+
+  // enum SamplePartitionType
+  /**
+   * Watershed partitioning. Generally the best choice if you precompute the navigation mesh, use this if you have large open areas.
+   */
+  static readonly SAMPLE_PARTITION_WATERSHED: int;
+  /** Monotone partitioning. Use this if you want fast navigation mesh generation. */
+  static readonly SAMPLE_PARTITION_MONOTONE: int;
+  /** Layer partitioning. Good choice to use for tiled navigation mesh with medium and small sized tiles. */
+  static readonly SAMPLE_PARTITION_LAYERS: int;
+  /** Represents the size of the {@link SamplePartitionType} enum. */
+  static readonly SAMPLE_PARTITION_MAX: int;
+  // enum ParsedGeometryType
+  /**
+   * Parses mesh instances as geometry. This includes {@link MeshInstance3D}, {@link CSGShape3D}, and {@link GridMap} nodes.
+   */
+  static readonly PARSED_GEOMETRY_MESH_INSTANCES: int;
+  /**
+   * Parses {@link StaticBody3D} colliders as geometry. The collider should be in any of the layers specified by {@link geometry_collision_mask}.
+   */
+  static readonly PARSED_GEOMETRY_STATIC_COLLIDERS: int;
+  /** Both {@link PARSED_GEOMETRY_MESH_INSTANCES} and {@link PARSED_GEOMETRY_STATIC_COLLIDERS}. */
+  static readonly PARSED_GEOMETRY_BOTH: int;
+  /** Represents the size of the {@link ParsedGeometryType} enum. */
+  static readonly PARSED_GEOMETRY_MAX: int;
+  // enum SourceGeometryMode
+  /** Scans the child nodes of the root node recursively for geometry. */
+  static readonly SOURCE_GEOMETRY_ROOT_NODE_CHILDREN: int;
+  /**
+   * Scans nodes in a group and their child nodes recursively for geometry. The group is specified by {@link geometry_source_group_name}.
+   */
+  static readonly SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN: int;
+  /** Uses nodes in a group for geometry. The group is specified by {@link geometry_source_group_name}. */
+  static readonly SOURCE_GEOMETRY_GROUPS_EXPLICIT: int;
+  /** Represents the size of the {@link SourceGeometryMode} enum. */
+  static readonly SOURCE_GEOMETRY_MAX: int;
+}

package/typings/classes/NavigationMeshGenerator.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Helper class for creating and clearing navigation meshes. */
+declare interface NavigationMeshGenerator extends GodotObject {
+  /** Bakes the `navigation_mesh` with source geometry collected starting from the `root_node`. */
+  bake(navigation_mesh: NavigationMesh, root_node: Node): void;
+  /**
+   * Bakes the provided `navigation_mesh` with the data from the provided `source_geometry_data`. After the process is finished the optional `callback` will be called.
+   */
+  bake_from_source_geometry_data(navigation_mesh: NavigationMesh, source_geometry_data: NavigationMeshSourceGeometryData3D, callback?: Callable): void;
+  /** Removes all polygons and vertices from the provided `navigation_mesh` resource. */
+  clear(navigation_mesh: NavigationMesh): void;
+  /**
+   * Parses the {@link SceneTree} for source geometry according to the properties of `navigation_mesh`. Updates the provided `source_geometry_data` resource with the resulting data. The resource can then be used to bake a navigation mesh with {@link bake_from_source_geometry_data}. After the process is finished the optional `callback` will be called.
+   * **Note:** This function needs to run on the main thread or with a deferred call as the SceneTree is not thread-safe.
+   * **Performance:** While convenient, reading data arrays from {@link Mesh} resources can affect the frame rate negatively. The data needs to be received from the GPU, stalling the {@link RenderingServer} in the process. For performance prefer the use of e.g. collision shapes or creating the data arrays entirely in code.
+   */
+  parse_source_geometry_data(navigation_mesh: NavigationMesh, source_geometry_data: NavigationMeshSourceGeometryData3D, root_node: Node, callback?: Callable): void;
+}
+declare const NavigationMeshGenerator: NavigationMeshGenerator;
+

package/typings/classes/NavigationMeshSourceGeometryData2D.d.ts

@@ -0,0 +1,52 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Container for parsed source geometry data used in navigation mesh baking. */
+declare class NavigationMeshSourceGeometryData2D extends Resource {
+  /** Adds the outline points of a shape as obstructed area. */
+  add_obstruction_outline(shape_outline: PackedVector2Array | Array<unknown>): void;
+  /**
+   * Adds a projected obstruction shape to the source geometry. If `carve` is `true` the carved shape will not be affected by additional offsets (e.g. agent radius) of the navigation mesh baking process.
+   */
+  add_projected_obstruction(vertices: PackedVector2Array | Array<unknown>, carve: boolean): void;
+  /** Adds the outline points of a shape as traversable area. */
+  add_traversable_outline(shape_outline: PackedVector2Array | Array<unknown>): void;
+  /**
+   * Appends another array of `obstruction_outlines` at the end of the existing obstruction outlines array.
+   */
+  append_obstruction_outlines(obstruction_outlines: Array<PackedVector2Array>): void;
+  /**
+   * Appends another array of `traversable_outlines` at the end of the existing traversable outlines array.
+   */
+  append_traversable_outlines(traversable_outlines: Array<PackedVector2Array>): void;
+  /** Clears the internal data. */
+  clear(): void;
+  /** Clears all projected obstructions. */
+  clear_projected_obstructions(): void;
+  /**
+   * Returns an axis-aligned bounding box that covers all the stored geometry data. The bounds are calculated when calling this function with the result cached until further geometry changes are made.
+   */
+  get_bounds(): Rect2;
+  /** Returns all the obstructed area outlines arrays. */
+  get_obstruction_outlines(): Array<PackedVector2Array>;
+  /**
+   * Returns the projected obstructions as an {@link Array} of dictionaries. Each {@link Dictionary} contains the following entries:
+   * - `vertices` - A {@link PackedFloat32Array} that defines the outline points of the projected shape.
+   * - `carve` - A [bool] that defines how the projected shape affects the navigation mesh baking. If `true` the projected shape will not be affected by addition offsets, e.g. agent radius.
+   */
+  get_projected_obstructions(): Array<unknown>;
+  /** Returns all the traversable area outlines arrays. */
+  get_traversable_outlines(): Array<PackedVector2Array>;
+  /** Returns `true` when parsed source geometry data exists. */
+  has_data(): boolean;
+  /**
+   * Adds the geometry data of another {@link NavigationMeshSourceGeometryData2D} to the navigation mesh baking data.
+   */
+  merge(other_geometry: NavigationMeshSourceGeometryData2D): void;
+  /** Sets all the obstructed area outlines arrays. */
+  set_obstruction_outlines(obstruction_outlines: Array<PackedVector2Array>): void;
+  /** Sets the projected obstructions with an Array of Dictionaries with the following key value pairs: */
+  set_projected_obstructions(projected_obstructions: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /** Sets all the traversable area outlines arrays. */
+  set_traversable_outlines(traversable_outlines: Array<PackedVector2Array>): void;
+}

package/typings/classes/NavigationMeshSourceGeometryData3D.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Container for parsed source geometry data used in navigation mesh baking. */
+declare class NavigationMeshSourceGeometryData3D extends Resource {
+  /**
+   * Adds an array of vertex positions to the geometry data for navigation mesh baking to form triangulated faces. For each face the array must have three vertex positions in clockwise winding order. Since {@link NavigationMesh} resources have no transform, all vertex positions need to be offset by the node's transform using `xform`.
+   */
+  add_faces(faces: PackedVector3Array | Array<unknown>, xform: Transform3D | Projection): void;
+  /**
+   * Adds the geometry data of a {@link Mesh} resource to the navigation mesh baking data. The mesh must have valid triangulated mesh data to be considered. Since {@link NavigationMesh} resources have no transform, all vertex positions need to be offset by the node's transform using `xform`.
+   */
+  add_mesh(mesh: Mesh, xform: Transform3D | Projection): void;
+  /**
+   * Adds an {@link Array} the size of {@link Mesh.ARRAY_MAX} and with vertices at index {@link Mesh.ARRAY_VERTEX} and indices at index {@link Mesh.ARRAY_INDEX} to the navigation mesh baking data. The array must have valid triangulated mesh data to be considered. Since {@link NavigationMesh} resources have no transform, all vertex positions need to be offset by the node's transform using `xform`.
+   */
+  add_mesh_array(mesh_array: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array, xform: Transform3D | Projection): void;
+  /**
+   * Adds a projected obstruction shape to the source geometry. The `vertices` are considered projected on an xz-axes plane, placed at the global y-axis `elevation` and extruded by `height`. If `carve` is `true` the carved shape will not be affected by additional offsets (e.g. agent radius) of the navigation mesh baking process.
+   */
+  add_projected_obstruction(vertices: PackedVector3Array | Array<unknown>, elevation: float, height: float, carve: boolean): void;
+  /**
+   * Appends arrays of `vertices` and `indices` at the end of the existing arrays. Adds the existing index as an offset to the appended indices.
+   */
+  append_arrays(vertices: PackedFloat32Array | Array<unknown>, indices: PackedInt32Array | Array<unknown>): void;
+  /** Clears the internal data. */
+  clear(): void;
+  /** Clears all projected obstructions. */
+  clear_projected_obstructions(): void;
+  /**
+   * Returns an axis-aligned bounding box that covers all the stored geometry data. The bounds are calculated when calling this function with the result cached until further geometry changes are made.
+   */
+  get_bounds(): AABB;
+  /** Returns the parsed source geometry data indices array. */
+  get_indices(): PackedInt32Array;
+  /**
+   * Returns the projected obstructions as an {@link Array} of dictionaries. Each {@link Dictionary} contains the following entries:
+   * - `vertices` - A {@link PackedFloat32Array} that defines the outline points of the projected shape.
+   * - `elevation` - A [float] that defines the projected shape placement on the y-axis.
+   * - `height` - A [float] that defines how much the projected shape is extruded along the y-axis.
+   * - `carve` - A [bool] that defines how the obstacle affects the navigation mesh baking. If `true` the projected shape will not be affected by addition offsets, e.g. agent radius.
+   */
+  get_projected_obstructions(): Array<unknown>;
+  /** Returns the parsed source geometry data vertices array. */
+  get_vertices(): PackedFloat32Array;
+  /** Returns `true` when parsed source geometry data exists. */
+  has_data(): boolean;
+  /**
+   * Adds the geometry data of another {@link NavigationMeshSourceGeometryData3D} to the navigation mesh baking data.
+   */
+  merge(other_geometry: NavigationMeshSourceGeometryData3D): void;
+  /**
+   * Sets the parsed source geometry data indices. The indices need to be matched with appropriated vertices.
+   * **Warning:** Inappropriate data can crash the baking process of the involved third-party libraries.
+   */
+  set_indices(indices: PackedInt32Array | Array<unknown>): void;
+  /** Sets the projected obstructions with an Array of Dictionaries with the following key value pairs: */
+  set_projected_obstructions(projected_obstructions: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /**
+   * Sets the parsed source geometry data vertices. The vertices need to be matched with appropriated indices.
+   * **Warning:** Inappropriate data can crash the baking process of the involved third-party libraries.
+   */
+  set_vertices(vertices: PackedFloat32Array | Array<unknown>): void;
+}

package/typings/classes/NavigationObstacle2D.d.ts

@@ -0,0 +1,67 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * 2D obstacle used to affect navigation mesh baking or constrain velocities of avoidance controlled agents.
+ */
+declare class NavigationObstacle2D extends Node2D {
+  /**
+   * If enabled and parsed in a navigation mesh baking process the obstacle will discard source geometry inside its {@link vertices} defined shape.
+   */
+  affect_navigation_mesh: boolean;
+  /** If `true` the obstacle affects avoidance using agents. */
+  avoidance_enabled: boolean;
+  /**
+   * A bitfield determining the avoidance layers for this obstacle. Agents with a matching bit on the their avoidance mask will avoid this obstacle.
+   */
+  avoidance_layers: int;
+  /**
+   * If enabled the obstacle vertices will carve into the baked navigation mesh with the shape unaffected by additional offsets (e.g. agent radius).
+   * It will still be affected by further postprocessing of the baking process, like edge and polygon simplification.
+   * Requires {@link affect_navigation_mesh} to be enabled.
+   */
+  carve_navigation_mesh: boolean;
+  /** Sets the avoidance radius for the obstacle. */
+  radius: float;
+  /**
+   * Sets the wanted velocity for the obstacle so other agent's can better predict the obstacle if it is moved with a velocity regularly (every frame) instead of warped to a new position. Does only affect avoidance for the obstacles {@link radius}. Does nothing for the obstacles static vertices.
+   */
+  velocity: Vector2;
+  /**
+   * The outline vertices of the obstacle. If the vertices are winded in clockwise order agents will be pushed in by the obstacle, else they will be pushed out. Outlines can not be crossed or overlap. Should the vertices using obstacle be warped to a new position agent's can not predict this movement and may get trapped inside the obstacle.
+   */
+  vertices: PackedVector2Array;
+  set_affect_navigation_mesh(value: boolean): void;
+  get_affect_navigation_mesh(): boolean;
+  set_avoidance_enabled(value: boolean): void;
+  get_avoidance_enabled(): boolean;
+  set_avoidance_layers(value: int): void;
+  get_avoidance_layers(): int;
+  set_carve_navigation_mesh(value: boolean): void;
+  get_carve_navigation_mesh(): boolean;
+  set_radius(value: float): void;
+  get_radius(): float;
+  set_velocity(value: Vector2 | Vector2i): void;
+  get_velocity(): Vector2;
+  set_vertices(value: PackedVector2Array | Array<unknown>): void;
+  get_vertices(): PackedVector2Array;
+
+  /**
+   * Returns whether or not the specified layer of the {@link avoidance_layers} bitmask is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_avoidance_layer_value(layer_number: int): boolean;
+  /**
+   * Returns the {@link RID} of the navigation map for this NavigationObstacle node. This function returns always the map set on the NavigationObstacle node and not the map of the abstract obstacle on the NavigationServer. If the obstacle map is changed directly with the NavigationServer API the NavigationObstacle node will not be aware of the map change. Use {@link set_navigation_map} to change the navigation map for the NavigationObstacle and also update the obstacle on the NavigationServer.
+   */
+  get_navigation_map(): RID;
+  /** Returns the {@link RID} of this obstacle on the {@link NavigationServer2D}. */
+  get_rid(): RID;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link avoidance_layers} bitmask, given a `layer_number` between 1 and 32.
+   */
+  set_avoidance_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the {@link RID} of the navigation map this NavigationObstacle node should use and also updates the `obstacle` on the NavigationServer.
+   */
+  set_navigation_map(navigation_map: RID): void;
+}

package/typings/classes/NavigationObstacle3D.d.ts

@@ -0,0 +1,80 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * 3D obstacle used to affect navigation mesh baking or constrain velocities of avoidance controlled agents.
+ */
+declare class NavigationObstacle3D extends Node3D {
+  /**
+   * If enabled and parsed in a navigation mesh baking process the obstacle will discard source geometry inside its {@link vertices} and {@link height} defined shape.
+   */
+  affect_navigation_mesh: boolean;
+  /** If `true` the obstacle affects avoidance using agents. */
+  avoidance_enabled: boolean;
+  /**
+   * A bitfield determining the avoidance layers for this obstacle. Agents with a matching bit on the their avoidance mask will avoid this obstacle.
+   */
+  avoidance_layers: int;
+  /**
+   * If enabled the obstacle vertices will carve into the baked navigation mesh with the shape unaffected by additional offsets (e.g. agent radius).
+   * It will still be affected by further postprocessing of the baking process, like edge and polygon simplification.
+   * Requires {@link affect_navigation_mesh} to be enabled.
+   */
+  carve_navigation_mesh: boolean;
+  /**
+   * Sets the obstacle height used in 2D avoidance. 2D avoidance using agent's ignore obstacles that are below or above them.
+   */
+  height: float;
+  /** Sets the avoidance radius for the obstacle. */
+  radius: float;
+  /**
+   * If `true` the obstacle affects 3D avoidance using agent's with obstacle {@link radius}.
+   * If `false` the obstacle affects 2D avoidance using agent's with both obstacle {@link vertices} as well as obstacle {@link radius}.
+   */
+  use_3d_avoidance: boolean;
+  /**
+   * Sets the wanted velocity for the obstacle so other agent's can better predict the obstacle if it is moved with a velocity regularly (every frame) instead of warped to a new position. Does only affect avoidance for the obstacles {@link radius}. Does nothing for the obstacles static vertices.
+   */
+  velocity: Vector3;
+  /**
+   * The outline vertices of the obstacle. If the vertices are winded in clockwise order agents will be pushed in by the obstacle, else they will be pushed out. Outlines can not be crossed or overlap. Should the vertices using obstacle be warped to a new position agent's can not predict this movement and may get trapped inside the obstacle.
+   */
+  vertices: PackedVector3Array;
+  set_affect_navigation_mesh(value: boolean): void;
+  get_affect_navigation_mesh(): boolean;
+  set_avoidance_enabled(value: boolean): void;
+  get_avoidance_enabled(): boolean;
+  set_avoidance_layers(value: int): void;
+  get_avoidance_layers(): int;
+  set_carve_navigation_mesh(value: boolean): void;
+  get_carve_navigation_mesh(): boolean;
+  set_height(value: float): void;
+  get_height(): float;
+  set_radius(value: float): void;
+  get_radius(): float;
+  set_use_3d_avoidance(value: boolean): void;
+  get_use_3d_avoidance(): boolean;
+  set_velocity(value: Vector3 | Vector3i): void;
+  get_velocity(): Vector3;
+  set_vertices(value: PackedVector3Array | Array<unknown>): void;
+  get_vertices(): PackedVector3Array;
+
+  /**
+   * Returns whether or not the specified layer of the {@link avoidance_layers} bitmask is enabled, given a `layer_number` between 1 and 32.
+   */
+  get_avoidance_layer_value(layer_number: int): boolean;
+  /**
+   * Returns the {@link RID} of the navigation map for this NavigationObstacle node. This function returns always the map set on the NavigationObstacle node and not the map of the abstract obstacle on the NavigationServer. If the obstacle map is changed directly with the NavigationServer API the NavigationObstacle node will not be aware of the map change. Use {@link set_navigation_map} to change the navigation map for the NavigationObstacle and also update the obstacle on the NavigationServer.
+   */
+  get_navigation_map(): RID;
+  /** Returns the {@link RID} of this obstacle on the {@link NavigationServer3D}. */
+  get_rid(): RID;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link avoidance_layers} bitmask, given a `layer_number` between 1 and 32.
+   */
+  set_avoidance_layer_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the {@link RID} of the navigation map this NavigationObstacle node should use and also updates the `obstacle` on the NavigationServer.
+   */
+  set_navigation_map(navigation_map: RID): void;
+}