@ringozz/godot 0.1.0

package/gen/classes/NavigationMesh.ts

@@ -0,0 +1,283 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, PackedInt32Array, PackedVector3Array, StringName } from '../heap-types/index.ts';
+import type { AABB, Vector3 } from '../value-types/index.ts';
+import type { Mesh } from './Mesh.ts';
+
+/**
+ * A navigation mesh is a collection of polygons that define which areas of an environment are traversable to aid agents in pathfinding through complicated spaces.
+ */
+export class NavigationMesh extends Resource {
+    constructor(name = 438) { super(name); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link geometryCollisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 10895, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link geometryCollisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getCollisionMaskValue(layerNumber: number): boolean { return _C(this, 4206, layerNumber) as boolean; }
+
+    /**
+     * Adds a polygon using the indices of the vertices you get when calling {@link getVertices}.
+     */
+    addPolygon(polygon: PackedInt32Array): void { _C(this, 1273, polygon); }
+
+    /**
+     * Returns the number of polygons in the navigation mesh.
+     */
+    getPolygonCount(): number { return _C(this, 5963) as number; }
+
+    /**
+     * Returns a {@link PackedInt32Array} containing the indices of the vertices of a created polygon.
+     */
+    getPolygon(idx: number): PackedInt32Array { return _C(this, 5962, idx) as PackedInt32Array; }
+
+    /**
+     * Clears the array of polygons, but it doesn't clear the array of vertices.
+     */
+    clearPolygons(): void { _C(this, 2288); }
+
+    /**
+     * 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.
+     */
+    createFromMesh(mesh: Mesh): void { _C(this, 2536, mesh); }
+
+    /**
+     * Clears the internal arrays for vertices and polygon indices.
+     */
+    clear(): void { _C(this, 2232); }
+
+    get vertices(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
+    set vertices(v: PackedVector3Array) { _C(this, 13308, v); }
+
+    get polygons(): GodotArray { return _C(this, 1009) as GodotArray; }
+    set polygons(v: GodotArray) { _C(this, 1037, v); }
+
+    /**
+     * Partitioning algorithm for creating the navigation mesh polys.
+     */
+    get samplePartitionType(): SamplePartitionType { return _C(this, 6229) as SamplePartitionType; }
+    set samplePartitionType(v: SamplePartitionType) { _C(this, 12601, v); }
+
+    /**
+     * Determines which type of nodes will be parsed as geometry.
+     */
+    get geometryParsedGeometryType(): ParsedGeometryType { return _C(this, 5829) as ParsedGeometryType; }
+    set geometryParsedGeometryType(v: ParsedGeometryType) { _C(this, 12262, v); }
+
+    /**
+     * The physics layers to scan for static colliders.
+     * Only used when {@link geometryParsedGeometryType} is {@link PARSED_GEOMETRY_STATIC_COLLIDERS} or {@link PARSED_GEOMETRY_BOTH}.
+     */
+    get geometryCollisionMask(): number { return _C(this, 4205) as number; }
+    set geometryCollisionMask(v: number) { _C(this, 10894, v); }
+
+    /**
+     * The source of the geometry used when baking.
+     */
+    get geometrySourceGeometryMode(): SourceGeometryMode { return _C(this, 6459) as SourceGeometryMode; }
+    set geometrySourceGeometryMode(v: SourceGeometryMode) { _C(this, 12815, v); }
+
+    /**
+     * The name of the group to scan for geometry.
+     * Only used when {@link geometrySourceGeometryMode} is {@link SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN} or {@link SOURCE_GEOMETRY_GROUPS_EXPLICIT}.
+     */
+    get geometrySourceGroupName(): StringName { return _C(this, 6460) as StringName; }
+    set geometrySourceGroupName(v: StringName) { _C(this, 12816, v); }
+
+    /**
+     * The cell size used to rasterize the navigation mesh vertices on the XZ plane. Must match with the cell size on the navigation map.
+     */
+    get cellSize(): number { return _C(this, 4115) as number; }
+    set cellSize(v: number) { _C(this, 10829, v); }
+
+    /**
+     * The cell height used to rasterize the navigation mesh vertices on the Y axis. Must match with the cell height on the navigation map.
+     */
+    get cellHeight(): number { return _C(this, 4108) as number; }
+    set cellHeight(v: number) { _C(this, 10822, v); }
+
+    /**
+     * The size of the non-navigable border around the bake bounding area.
+     * In conjunction with the {@link filterBakingAabb} and a {@link edgeMaxError} 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 agentRadius}.
+     * **Note:** If this value is not `0.0`, it will be rounded up to the nearest multiple of {@link cellSize} during baking.
+     */
+    get borderSize(): number { return _C(this, 3987) as number; }
+    set borderSize(v: number) { _C(this, 10727, v); }
+
+    /**
+     * 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 cellHeight}.
+     */
+    get agentHeight(): number { return _C(this, 3706) as number; }
+    set agentHeight(v: number) { _C(this, 10442, v); }
+
+    /**
+     * 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 cellSize}.
+     * **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.
+     */
+    get agentRadius(): number { return _C(this, 3709) as number; }
+    set agentRadius(v: number) { _C(this, 10445, v); }
+
+    /**
+     * 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 cellHeight}.
+     */
+    get agentMaxClimb(): number { return _C(this, 3707) as number; }
+    set agentMaxClimb(v: number) { _C(this, 10443, v); }
+
+    /**
+     * The maximum slope that is considered walkable, in degrees.
+     */
+    get agentMaxSlope(): number { return _C(this, 3708) as number; }
+    set agentMaxSlope(v: number) { _C(this, 10444, v); }
+
+    /**
+     * 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.
+     */
+    get regionMinSize(): number { return _C(this, 6114) as number; }
+    set regionMinSize(v: number) { _C(this, 12509, v); }
+
+    /**
+     * 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.
+     */
+    get regionMergeSize(): number { return _C(this, 6113) as number; }
+    set regionMergeSize(v: number) { _C(this, 12508, v); }
+
+    /**
+     * 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 cellSize}.
+     */
+    get edgeMaxLength(): number { return _C(this, 4597) as number; }
+    set edgeMaxLength(v: number) { _C(this, 11211, v); }
+
+    /**
+     * The maximum distance a simplified contour's border edges should deviate the original raw contour.
+     */
+    get edgeMaxError(): number { return _C(this, 4596) as number; }
+    set edgeMaxError(v: number) { _C(this, 11210, v); }
+
+    /**
+     * The maximum number of vertices allowed for polygons generated during the contour to polygon conversion process.
+     */
+    get verticesPerPolygon(): number { return _C(this, 7069) as number; }
+    set verticesPerPolygon(v: number) { _C(this, 13309, v); }
+
+    /**
+     * The sampling distance to use when generating the detail mesh, in cell unit.
+     */
+    get detailSampleDistance(): number { return _C(this, 4488) as number; }
+    set detailSampleDistance(v: number) { _C(this, 11102, v); }
+
+    /**
+     * The maximum distance the detail mesh surface should deviate from heightfield, in cell unit.
+     */
+    get detailSampleMaxError(): number { return _C(this, 4489) as number; }
+    set detailSampleMaxError(v: number) { _C(this, 11103, v); }
+
+    /**
+     * If `true`, marks non-walkable spans as walkable if their maximum is within {@link agentMaxClimb} of a walkable neighbor.
+     */
+    get filterLowHangingObstacles(): boolean { return _C(this, 4787) as boolean; }
+    set filterLowHangingObstacles(v: boolean) { _C(this, 11392, v); }
+
+    /**
+     * If `true`, marks spans that are ledges as non-walkable.
+     */
+    get filterLedgeSpans(): boolean { return _C(this, 4786) as boolean; }
+    set filterLedgeSpans(v: boolean) { _C(this, 11391, v); }
+
+    /**
+     * If `true`, marks walkable spans as not walkable if the clearance above the span is less than {@link agentHeight}.
+     */
+    get filterWalkableLowHeightSpans(): boolean { return _C(this, 4788) as boolean; }
+    set filterWalkableLowHeightSpans(v: boolean) { _C(this, 11394, v); }
+
+    /**
+     * If the baking {@link AABB} has a volume the navigation mesh baking will be restricted to its enclosing area.
+     */
+    get filterBakingAabb(): AABB { return _C(this, 4784) as AABB; }
+    set filterBakingAabb(v: AABB) { _C(this, 11387, v); }
+
+    /**
+     * The position offset applied to the {@link filterBakingAabb} {@link AABB}.
+     */
+    get filterBakingAabbOffset(): Vector3 { return _C(this, 4785) as Vector3; }
+    set filterBakingAabbOffset(v: Vector3) { _C(this, 11388, v); }
+
+    static readonly name = _R(438, NavigationMesh);
+}
+
+export const SamplePartitionType = {
+    /**
+     * Watershed partitioning. Generally the best choice if you precompute the navigation mesh, use this if you have large open areas.
+     */
+    SAMPLE_PARTITION_WATERSHED: 0,
+    /**
+     * Monotone partitioning. Use this if you want fast navigation mesh generation.
+     */
+    SAMPLE_PARTITION_MONOTONE: 1,
+    /**
+     * Layer partitioning. Good choice to use for tiled navigation mesh with medium and small sized tiles.
+     */
+    SAMPLE_PARTITION_LAYERS: 2,
+    /**
+     * Represents the size of the {@link SamplePartitionType} enum.
+     */
+    SAMPLE_PARTITION_MAX: 3,
+} as const;
+
+export type SamplePartitionType = (typeof SamplePartitionType)[keyof typeof SamplePartitionType];
+
+export const ParsedGeometryType = {
+    /**
+     * Parses mesh instances as geometry. This includes {@link MeshInstance3D}, {@link CSGShape3D}, and {@link GridMap} nodes.
+     */
+    PARSED_GEOMETRY_MESH_INSTANCES: 0,
+    /**
+     * Parses {@link StaticBody3D} colliders as geometry. The collider should be in any of the layers specified by {@link geometryCollisionMask}.
+     */
+    PARSED_GEOMETRY_STATIC_COLLIDERS: 1,
+    /**
+     * Both {@link PARSED_GEOMETRY_MESH_INSTANCES} and {@link PARSED_GEOMETRY_STATIC_COLLIDERS}.
+     */
+    PARSED_GEOMETRY_BOTH: 2,
+    /**
+     * Represents the size of the {@link ParsedGeometryType} enum.
+     */
+    PARSED_GEOMETRY_MAX: 3,
+} as const;
+
+export type ParsedGeometryType = (typeof ParsedGeometryType)[keyof typeof ParsedGeometryType];
+
+export const SourceGeometryMode = {
+    /**
+     * Scans the child nodes of the root node recursively for geometry.
+     */
+    SOURCE_GEOMETRY_ROOT_NODE_CHILDREN: 0,
+    /**
+     * Scans nodes in a group and their child nodes recursively for geometry. The group is specified by {@link geometrySourceGroupName}.
+     */
+    SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN: 1,
+    /**
+     * Uses nodes in a group for geometry. The group is specified by {@link geometrySourceGroupName}.
+     */
+    SOURCE_GEOMETRY_GROUPS_EXPLICIT: 2,
+    /**
+     * Represents the size of the {@link SourceGeometryMode} enum.
+     */
+    SOURCE_GEOMETRY_MAX: 3,
+} as const;
+
+export type SourceGeometryMode = (typeof SourceGeometryMode)[keyof typeof SourceGeometryMode];
+

package/gen/classes/NavigationMeshGenerator.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { Callable } from '../heap-types/index.ts';
+import type { NavigationMesh } from './NavigationMesh.ts';
+import type { NavigationMeshSourceGeometryData3D } from './NavigationMeshSourceGeometryData3D.ts';
+import type { Node } from './Node.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 439));
+
+/**
+ * This class is responsible for creating and clearing 3D navigation meshes used as {@link NavigationMesh} resources inside {@link NavigationRegion3D}. The {@link NavigationMeshGenerator} has very limited to no use for 2D as the navigation mesh baking process expects 3D node types and 3D source geometry to parse.
+ * The entire navigation mesh baking is best done in a separate thread as the voxelization, collision tests and mesh optimization steps involved are very slow and performance-intensive operations.
+ * Navigation mesh baking happens in multiple steps and the result depends on 3D source geometry and properties of the {@link NavigationMesh} resource. In the first step, starting from a root node and depending on {@link NavigationMesh} properties all valid 3D source geometry nodes are collected from the {@link SceneTree}. Second, all collected nodes are parsed for their relevant 3D geometry data and a combined 3D mesh is build. Due to the many different types of parsable objects, from normal {@link MeshInstance3D}s to {@link CSGShape3D}s or various {@link CollisionObject3D}s, some operations to collect geometry data can trigger {@link RenderingServer} and {@link PhysicsServer3D} synchronizations. Server synchronization can have a negative effect on baking time or framerate as it often involves {@link Mutex} locking for thread security. Many parsable objects and the continuous synchronization with other threaded Servers can increase the baking time significantly. On the other hand only a few but very large and complex objects will take some time to prepare for the Servers which can noticeably stall the next frame render. As a general rule the total number of parsable objects and their individual size and complexity should be balanced to avoid framerate issues or very long baking times. The combined mesh is then passed to the Recast Navigation Object to test the source geometry for walkable terrain suitable to {@link NavigationMesh} agent properties by creating a voxel world around the meshes bounding area.
+ * The finalized navigation mesh is then returned and stored inside the {@link NavigationMesh} for use as a resource inside {@link NavigationRegion3D} nodes.
+ * **Note:** Using meshes to not only define walkable surfaces but also obstruct navigation baking does not always work. The navigation baking has no concept of what is a geometry "inside" when dealing with mesh source geometry and this is intentional. Depending on current baking parameters, as soon as the obstructing mesh is large enough to fit a navigation mesh area inside, the baking will generate navigation mesh areas that are inside the obstructing source geometry mesh.
+ */
+export class NavigationMeshGenerator extends GodotVar {
+
+    /**
+     * Bakes the `navigationMesh` with source geometry collected starting from the `rootNode`.
+     */
+    static bake(navigationMesh: NavigationMesh, rootNode: Node): void { _C($(), 1708, navigationMesh, rootNode); }
+
+    /**
+     * Removes all polygons and vertices from the provided `navigationMesh` resource.
+     */
+    static clear(navigationMesh: NavigationMesh): void { _C($(), 2232, navigationMesh); }
+
+    /**
+     * Parses the {@link SceneTree} for source geometry according to the properties of `navigationMesh`. Updates the provided `sourceGeometryData` resource with the resulting data. The resource can then be used to bake a navigation mesh with {@link bakeFromSourceGeometryData}. 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.
+     */
+    static parseSourceGeometryData(navigationMesh: NavigationMesh, sourceGeometryData: NavigationMeshSourceGeometryData3D, rootNode: Node, callback?: Callable /* = Callable() */): void { _C($(), 9282, navigationMesh, sourceGeometryData, rootNode, callback); }
+
+    /**
+     * Bakes the provided `navigationMesh` with the data from the provided `sourceGeometryData`. After the process is finished the optional `callback` will be called.
+     */
+    static bakeFromSourceGeometryData(navigationMesh: NavigationMesh, sourceGeometryData: NavigationMeshSourceGeometryData3D, callback?: Callable /* = Callable() */): void { _C($(), 1712, navigationMesh, sourceGeometryData, callback); }
+
+    static readonly name = _R(439, NavigationMeshGenerator);
+}

package/gen/classes/NavigationMeshSourceGeometryData2D.ts

@@ -0,0 +1,75 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, PackedVector2Array } from '../heap-types/index.ts';
+import type { Rect2 } from '../value-types/index.ts';
+
+/**
+ * Container for parsed source geometry data used in navigation mesh baking.
+ */
+export class NavigationMeshSourceGeometryData2D extends Resource {
+    constructor(name = 440) { super(name); }
+
+    /**
+     * Clears the internal data.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns `true` when parsed source geometry data exists.
+     */
+    hasData(): boolean { return _C(this, 7385) as boolean; }
+
+    /**
+     * Appends another array of `traversableOutlines` at the end of the existing traversable outlines array.
+     */
+    appendTraversableOutlines(traversableOutlines: GodotArray<PackedVector2Array>): void { _C(this, 1526, traversableOutlines); }
+
+    /**
+     * Appends another array of `obstructionOutlines` at the end of the existing obstruction outlines array.
+     */
+    appendObstructionOutlines(obstructionOutlines: GodotArray<PackedVector2Array>): void { _C(this, 1523, obstructionOutlines); }
+
+    /**
+     * Adds the outline points of a shape as traversable area.
+     */
+    addTraversableOutline(shapeOutline: PackedVector2Array): void { _C(this, 1320, shapeOutline); }
+
+    /**
+     * Adds the outline points of a shape as obstructed area.
+     */
+    addObstructionOutline(shapeOutline: PackedVector2Array): void { _C(this, 1259, shapeOutline); }
+
+    /**
+     * Adds the geometry data of another {@link NavigationMeshSourceGeometryData2D} to the navigation mesh baking data.
+     */
+    merge(otherGeometry: NavigationMeshSourceGeometryData2D): void { _C(this, 8850, otherGeometry); }
+
+    /**
+     * 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.
+     */
+    addProjectedObstruction(vertices: PackedVector2Array, carve: boolean): void { _C(this, 1276, vertices, carve); }
+
+    /**
+     * Clears all projected obstructions.
+     */
+    clearProjectedObstructions(): void { _C(this, 2289); }
+
+    /**
+     * 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.
+     */
+    getBounds(): Rect2 { return _C(this, 3997) as Rect2; }
+
+    get traversableOutlines(): GodotArray<PackedVector2Array> { return _C(this, 6904) as GodotArray<PackedVector2Array>; }
+    set traversableOutlines(v: GodotArray<PackedVector2Array>) { _C(this, 13152, v); }
+
+    get obstructionOutlines(): GodotArray<PackedVector2Array> { return _C(this, 5688) as GodotArray<PackedVector2Array>; }
+    set obstructionOutlines(v: GodotArray<PackedVector2Array>) { _C(this, 12159, v); }
+
+    get projectedObstructions(): GodotArray { return _C(this, 6042) as GodotArray; }
+    set projectedObstructions(v: GodotArray) { _C(this, 12441, v); }
+
+    static readonly name = _R(440, NavigationMeshSourceGeometryData2D);
+}

package/gen/classes/NavigationMeshSourceGeometryData3D.ts

@@ -0,0 +1,76 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, PackedFloat32Array, PackedInt32Array, PackedVector3Array } from '../heap-types/index.ts';
+import type { AABB, Transform3D } from '../value-types/index.ts';
+import type { Mesh } from './Mesh.ts';
+
+/**
+ * Container for parsed source geometry data used in navigation mesh baking.
+ */
+export class NavigationMeshSourceGeometryData3D extends Resource {
+    constructor(name = 441) { super(name); }
+
+    /**
+     * Appends arrays of `vertices` and `indices` at the end of the existing arrays. Adds the existing index as an offset to the appended indices.
+     */
+    appendArrays(vertices: PackedFloat32Array, indices: PackedInt32Array): void { _C(this, 1514, vertices, indices); }
+
+    /**
+     * Clears the internal data.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Returns `true` when parsed source geometry data exists.
+     */
+    hasData(): boolean { return _C(this, 7385) as boolean; }
+
+    /**
+     * 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`.
+     */
+    addMesh(mesh: Mesh, xform: Transform3D): void { _C(this, 1248, mesh, xform); }
+
+    /**
+     * 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`.
+     */
+    addMeshArray(meshArray: GodotArray, xform: Transform3D): void { _C(this, 1249, meshArray, xform); }
+
+    /**
+     * 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`.
+     */
+    addFaces(faces: PackedVector3Array, xform: Transform3D): void { _C(this, 1215, faces, xform); }
+
+    /**
+     * Adds the geometry data of another {@link NavigationMeshSourceGeometryData3D} to the navigation mesh baking data.
+     */
+    merge(otherGeometry: NavigationMeshSourceGeometryData3D): void { _C(this, 8850, otherGeometry); }
+
+    /**
+     * 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.
+     */
+    addProjectedObstruction(vertices: PackedVector3Array, elevation: number, height: number, carve: boolean): void { _C(this, 1276, vertices, elevation, height, carve); }
+
+    /**
+     * Clears all projected obstructions.
+     */
+    clearProjectedObstructions(): void { _C(this, 2289); }
+
+    /**
+     * 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.
+     */
+    getBounds(): AABB { return _C(this, 3997) as AABB; }
+
+    get vertices(): PackedFloat32Array { return _C(this, 7068) as PackedFloat32Array; }
+    set vertices(v: PackedFloat32Array) { _C(this, 13308, v); }
+
+    get indices(): PackedInt32Array { return _C(this, 5091) as PackedInt32Array; }
+    set indices(v: PackedInt32Array) { _C(this, 11692, v); }
+
+    get projectedObstructions(): GodotArray { return _C(this, 6042) as GodotArray; }
+    set projectedObstructions(v: GodotArray) { _C(this, 12441, v); }
+
+    static readonly name = _R(441, NavigationMeshSourceGeometryData3D);
+}

package/gen/classes/NavigationObstacle2D.ts

@@ -0,0 +1,87 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { PackedVector2Array, RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * An obstacle needs a navigation map and outline {@link vertices} defined to work correctly. The outlines can not cross or overlap.
+ * Obstacles can be included in the navigation mesh baking process when {@link affectNavigationMesh} is enabled. They do not add walkable geometry, instead their role is to discard other source geometry inside the shape. This can be used to prevent navigation mesh from appearing in unwanted places. If {@link carveNavigationMesh} is enabled the baked shape will not be affected by offsets of the navigation mesh baking, e.g. the agent radius.
+ * With {@link avoidanceEnabled} the obstacle can constrain the avoidance velocities of avoidance using agents. If the obstacle's vertices are wound in clockwise order, avoidance agents will be pushed in by the obstacle, otherwise, avoidance agents will be pushed out. Obstacles using vertices and avoidance can warp to a new position but should not be moved every single frame as each change requires a rebuild of the avoidance map.
+ */
+export class NavigationObstacle2D extends Node2D {
+    constructor(name = 442) { super(name); }
+
+    /**
+     * Returns the {@link RID} of this obstacle on the {@link NavigationServer2D}.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * Sets the {@link RID} of the navigation map this NavigationObstacle node should use and also updates the `obstacle` on the NavigationServer.
+     */
+    setNavigationMap(navigationMap: RID): void { _C(this, 12120, navigationMap); }
+
+    /**
+     * 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 setNavigationMap} to change the navigation map for the NavigationObstacle and also update the obstacle on the NavigationServer.
+     */
+    getNavigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link avoidanceLayers} bitmask, given a `layerNumber` between 1 and 32.
+     */
+    setAvoidanceLayerValue(layerNumber: number, value: boolean): void { _C(this, 10599, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link avoidanceLayers} bitmask is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getAvoidanceLayerValue(layerNumber: number): boolean { return _C(this, 3854, layerNumber) as boolean; }
+
+    /**
+     * Sets the avoidance radius for the obstacle.
+     */
+    get radius(): number { return _C(this, 6068) as number; }
+    set radius(v: number) { _C(this, 12467, v); }
+
+    /**
+     * 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.
+     */
+    get vertices(): PackedVector2Array { return _C(this, 7068) as PackedVector2Array; }
+    set vertices(v: PackedVector2Array) { _C(this, 13308, v); }
+
+    /**
+     * If enabled and parsed in a navigation mesh baking process the obstacle will discard source geometry inside its {@link vertices} defined shape.
+     */
+    get affectNavigationMesh(): boolean { return _C(this, 3705) as boolean; }
+    set affectNavigationMesh(v: boolean) { _C(this, 10441, v); }
+
+    /**
+     * 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 affectNavigationMesh} to be enabled.
+     */
+    get carveNavigationMesh(): boolean { return _C(this, 4095) as boolean; }
+    set carveNavigationMesh(v: boolean) { _C(this, 10809, v); }
+
+    /**
+     * If `true` the obstacle affects avoidance using agents.
+     */
+    get avoidanceEnabled(): boolean { return _C(this, 3853) as boolean; }
+    set avoidanceEnabled(v: boolean) { _C(this, 10598, v); }
+
+    /**
+     * 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.
+     */
+    get velocity(): Vector2 { return _C(this, 7035) as Vector2; }
+    set velocity(v: Vector2) { _C(this, 13279, v); }
+
+    /**
+     * A bitfield determining the avoidance layers for this obstacle. Agents with a matching bit on the their avoidance mask will avoid this obstacle.
+     */
+    get avoidanceLayers(): number { return _C(this, 3855) as number; }
+    set avoidanceLayers(v: number) { _C(this, 10600, v); }
+
+    static readonly name = _R(442, NavigationObstacle2D);
+}