@ringozz/godot 0.1.0

package/gen/classes/NavigationObstacle3D.ts

@@ -0,0 +1,100 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { PackedVector3Array, RID } from '../heap-types/index.ts';
+import type { Vector3 } 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 and are restricted to a plane projection. This means the y-axis of the vertices is ignored, instead the obstacle's global y-axis position is used for placement. The projected shape is extruded by the obstacles height along the y-axis.
+ * 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, e.g. inside "solid" geometry or on top of it. 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 NavigationObstacle3D extends Node3D {
+    constructor(name = 443) { super(name); }
+
+    /**
+     * Returns the {@link RID} of this obstacle on the {@link NavigationServer3D}.
+     */
+    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); }
+
+    /**
+     * Sets the obstacle height used in 2D avoidance. 2D avoidance using agent's ignore obstacles that are below or above them.
+     */
+    get height(): number { return _C(this, 5024) as number; }
+    set height(v: number) { _C(this, 11609, 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(): PackedVector3Array { return _C(this, 7068) as PackedVector3Array; }
+    set vertices(v: PackedVector3Array) { _C(this, 13308, v); }
+
+    /**
+     * 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.
+     */
+    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(): Vector3 { return _C(this, 7035) as Vector3; }
+    set velocity(v: Vector3) { _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); }
+
+    /**
+     * 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}.
+     */
+    get use3dAvoidance(): boolean { return _C(this, 6970) as boolean; }
+    set use3dAvoidance(v: boolean) { _C(this, 13191, v); }
+
+    static readonly name = _R(443, NavigationObstacle3D);
+}

package/gen/classes/NavigationPathQueryParameters2D.ts

@@ -0,0 +1,162 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the start and target position, you can configure path queries to the {@link NavigationServer2D}.
+ */
+export class NavigationPathQueryParameters2D extends RefCounted {
+    constructor(name = 444) { super(name); }
+
+    /**
+     * The navigation map {@link RID} used in the path query.
+     */
+    get map(): RID { return _C(this, 5436) as RID; }
+    set map(v: RID) { _C(this, 11965, v); }
+
+    /**
+     * The pathfinding start position in global coordinates.
+     */
+    get startPosition(): Vector2 { return _C(this, 6536) as Vector2; }
+    set startPosition(v: Vector2) { _C(this, 12881, v); }
+
+    /**
+     * The pathfinding target position in global coordinates.
+     */
+    get targetPosition(): Vector2 { return _C(this, 6702) as Vector2; }
+    set targetPosition(v: Vector2) { _C(this, 13007, v); }
+
+    /**
+     * The navigation layers the query will use (as a bitmask).
+     */
+    get navigationLayers(): number { return _C(this, 5610) as number; }
+    set navigationLayers(v: number) { _C(this, 12119, v); }
+
+    /**
+     * The pathfinding algorithm used in the path query.
+     */
+    get pathfindingAlgorithm(): PathfindingAlgorithm { return _C(this, 5865) as PathfindingAlgorithm; }
+    set pathfindingAlgorithm(v: PathfindingAlgorithm) { _C(this, 12297, v); }
+
+    /**
+     * The path postprocessing applied to the raw path corridor found by the {@link pathfindingAlgorithm}.
+     */
+    get pathPostprocessing(): PathPostProcessing { return _C(this, 5853) as PathPostProcessing; }
+    set pathPostprocessing(v: PathPostProcessing) { _C(this, 12286, v); }
+
+    /**
+     * Additional information to include with the navigation path.
+     */
+    get metadataFlags(): PathMetadataFlags { return _C(this, 5524) as PathMetadataFlags; }
+    set metadataFlags(v: PathMetadataFlags) { _C(this, 12036, v); }
+
+    /**
+     * If `true` a simplified version of the path will be returned with less critical path points removed. The simplification amount is controlled by {@link simplifyEpsilon}. The simplification uses a variant of Ramer-Douglas-Peucker algorithm for curve point decimation.
+     * Path simplification can be helpful to mitigate various path following issues that can arise with certain agent types and script behaviors. E.g. "steering" agents or avoidance in "open fields".
+     */
+    get simplifyPath(): boolean { return _C(this, 6394) as boolean; }
+    set simplifyPath(v: boolean) { _C(this, 12749, v); }
+
+    /**
+     * The path simplification amount in worlds units.
+     */
+    get simplifyEpsilon(): number { return _C(this, 6393) as number; }
+    set simplifyEpsilon(v: number) { _C(this, 12748, v); }
+
+    /**
+     * The list of region {@link RID}s that will be excluded from the path query. Use {@link NavigationRegion2D.getRid} to get the {@link RID} associated with a {@link NavigationRegion2D} node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+     */
+    get excludedRegions(): GodotArray<RID> { return _C(this, 4700) as GodotArray<RID>; }
+    set excludedRegions(v: GodotArray<RID>) { _C(this, 11316, v); }
+
+    /**
+     * The list of region {@link RID}s that will be included by the path query. Use {@link NavigationRegion2D.getRid} to get the {@link RID} associated with a {@link NavigationRegion2D} node. If left empty all regions are included. If a region ends up being both included and excluded at the same time it will be excluded.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+     */
+    get includedRegions(): GodotArray<RID> { return _C(this, 5081) as GodotArray<RID>; }
+    set includedRegions(v: GodotArray<RID>) { _C(this, 11682, v); }
+
+    /**
+     * The maximum allowed length of the returned path in world units. A path will be clipped when going over this length. A value of `0` or below counts as disabled.
+     */
+    get pathReturnMaxLength(): number { return _C(this, 5854) as number; }
+    set pathReturnMaxLength(v: number) { _C(this, 12287, v); }
+
+    /**
+     * The maximum allowed radius in world units that the returned path can be from the path start. The path will be clipped when going over this radius. A value of `0` or below counts as disabled.
+     * **Note:** This will perform a circle shaped clip operation on the path with the first path position being the circle's center position.
+     */
+    get pathReturnMaxRadius(): number { return _C(this, 5855) as number; }
+    set pathReturnMaxRadius(v: number) { _C(this, 12288, v); }
+
+    /**
+     * The maximum number of polygons that are searched before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+     */
+    get pathSearchMaxPolygons(): number { return _C(this, 5860) as number; }
+    set pathSearchMaxPolygons(v: number) { _C(this, 12293, v); }
+
+    /**
+     * The maximum distance a searched polygon can be away from the start polygon before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+     */
+    get pathSearchMaxDistance(): number { return _C(this, 5859) as number; }
+    set pathSearchMaxDistance(v: number) { _C(this, 12292, v); }
+
+    static readonly name = _R(444, NavigationPathQueryParameters2D);
+}
+
+export const PathfindingAlgorithm = {
+    /**
+     * The path query uses the default A* pathfinding algorithm.
+     */
+    PATHFINDING_ALGORITHM_ASTAR: 0,
+} as const;
+
+export type PathfindingAlgorithm = (typeof PathfindingAlgorithm)[keyof typeof PathfindingAlgorithm];
+
+export const PathPostProcessing = {
+    /**
+     * Applies a funnel algorithm to the raw path corridor found by the pathfinding algorithm. This will result in the shortest path possible inside the path corridor. This postprocessing very much depends on the navigation mesh polygon layout and the created corridor. Especially tile- or gridbased layouts can face artificial corners with diagonal movement due to a jagged path corridor imposed by the cell shapes.
+     */
+    PATH_POSTPROCESSING_CORRIDORFUNNEL: 0,
+    /**
+     * Centers every path position in the middle of the traveled navigation mesh polygon edge. This creates better paths for tile- or gridbased layouts that restrict the movement to the cells center.
+     */
+    PATH_POSTPROCESSING_EDGECENTERED: 1,
+    /**
+     * Applies no postprocessing and returns the raw path corridor as found by the pathfinding algorithm.
+     */
+    PATH_POSTPROCESSING_NONE: 2,
+} as const;
+
+export type PathPostProcessing = (typeof PathPostProcessing)[keyof typeof PathPostProcessing];
+
+export const PathMetadataFlags = {
+    /**
+     * Don't include any additional metadata about the returned path.
+     */
+    PATH_METADATA_INCLUDE_NONE: 0,
+    /**
+     * Include the type of navigation primitive (region or link) that each point of the path goes through.
+     */
+    PATH_METADATA_INCLUDE_TYPES: 1,
+    /**
+     * Include the {@link RID}s of the regions and links that each point of the path goes through.
+     */
+    PATH_METADATA_INCLUDE_RIDS: 2,
+    /**
+     * Include the `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+     */
+    PATH_METADATA_INCLUDE_OWNERS: 4,
+    /**
+     * Include all available metadata about the returned path.
+     */
+    PATH_METADATA_INCLUDE_ALL: 7,
+} as const;
+
+export type PathMetadataFlags = (typeof PathMetadataFlags)[keyof typeof PathMetadataFlags];
+

package/gen/classes/NavigationPathQueryParameters3D.ts

@@ -0,0 +1,162 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Vector3 } from '../value-types/index.ts';
+
+/**
+ * By changing various properties of this object, such as the start and target position, you can configure path queries to the {@link NavigationServer3D}.
+ */
+export class NavigationPathQueryParameters3D extends RefCounted {
+    constructor(name = 445) { super(name); }
+
+    /**
+     * The navigation map {@link RID} used in the path query.
+     */
+    get map(): RID { return _C(this, 5436) as RID; }
+    set map(v: RID) { _C(this, 11965, v); }
+
+    /**
+     * The pathfinding start position in global coordinates.
+     */
+    get startPosition(): Vector3 { return _C(this, 6536) as Vector3; }
+    set startPosition(v: Vector3) { _C(this, 12881, v); }
+
+    /**
+     * The pathfinding target position in global coordinates.
+     */
+    get targetPosition(): Vector3 { return _C(this, 6702) as Vector3; }
+    set targetPosition(v: Vector3) { _C(this, 13007, v); }
+
+    /**
+     * The navigation layers the query will use (as a bitmask).
+     */
+    get navigationLayers(): number { return _C(this, 5610) as number; }
+    set navigationLayers(v: number) { _C(this, 12119, v); }
+
+    /**
+     * The pathfinding algorithm used in the path query.
+     */
+    get pathfindingAlgorithm(): PathfindingAlgorithm { return _C(this, 5865) as PathfindingAlgorithm; }
+    set pathfindingAlgorithm(v: PathfindingAlgorithm) { _C(this, 12297, v); }
+
+    /**
+     * The path postprocessing applied to the raw path corridor found by the {@link pathfindingAlgorithm}.
+     */
+    get pathPostprocessing(): PathPostProcessing { return _C(this, 5853) as PathPostProcessing; }
+    set pathPostprocessing(v: PathPostProcessing) { _C(this, 12286, v); }
+
+    /**
+     * Additional information to include with the navigation path.
+     */
+    get metadataFlags(): PathMetadataFlags { return _C(this, 5524) as PathMetadataFlags; }
+    set metadataFlags(v: PathMetadataFlags) { _C(this, 12036, v); }
+
+    /**
+     * If `true` a simplified version of the path will be returned with less critical path points removed. The simplification amount is controlled by {@link simplifyEpsilon}. The simplification uses a variant of Ramer-Douglas-Peucker algorithm for curve point decimation.
+     * Path simplification can be helpful to mitigate various path following issues that can arise with certain agent types and script behaviors. E.g. "steering" agents or avoidance in "open fields".
+     */
+    get simplifyPath(): boolean { return _C(this, 6394) as boolean; }
+    set simplifyPath(v: boolean) { _C(this, 12749, v); }
+
+    /**
+     * The path simplification amount in worlds units.
+     */
+    get simplifyEpsilon(): number { return _C(this, 6393) as number; }
+    set simplifyEpsilon(v: number) { _C(this, 12748, v); }
+
+    /**
+     * The list of region {@link RID}s that will be excluded from the path query. Use {@link NavigationRegion3D.getRid} to get the {@link RID} associated with a {@link NavigationRegion3D} node.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+     */
+    get excludedRegions(): GodotArray<RID> { return _C(this, 4700) as GodotArray<RID>; }
+    set excludedRegions(v: GodotArray<RID>) { _C(this, 11316, v); }
+
+    /**
+     * The list of region {@link RID}s that will be included by the path query. Use {@link NavigationRegion3D.getRid} to get the {@link RID} associated with a {@link NavigationRegion3D} node. If left empty all regions are included. If a region ends up being both included and excluded at the same time it will be excluded.
+     * **Note:** The returned array is copied and any changes to it will not update the original property value. To update the value you need to modify the returned array, and then set it to the property again.
+     */
+    get includedRegions(): GodotArray<RID> { return _C(this, 5081) as GodotArray<RID>; }
+    set includedRegions(v: GodotArray<RID>) { _C(this, 11682, v); }
+
+    /**
+     * The maximum allowed length of the returned path in world units. A path will be clipped when going over this length. A value of `0` or below counts as disabled.
+     */
+    get pathReturnMaxLength(): number { return _C(this, 5854) as number; }
+    set pathReturnMaxLength(v: number) { _C(this, 12287, v); }
+
+    /**
+     * The maximum allowed radius in world units that the returned path can be from the path start. The path will be clipped when going over this radius. A value of `0` or below counts as disabled.
+     * **Note:** This will perform a sphere shaped clip operation on the path with the first path position being the sphere's center position.
+     */
+    get pathReturnMaxRadius(): number { return _C(this, 5855) as number; }
+    set pathReturnMaxRadius(v: number) { _C(this, 12288, v); }
+
+    /**
+     * The maximum number of polygons that are searched before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+     */
+    get pathSearchMaxPolygons(): number { return _C(this, 5860) as number; }
+    set pathSearchMaxPolygons(v: number) { _C(this, 12293, v); }
+
+    /**
+     * The maximum distance a searched polygon can be away from the start polygon before the pathfinding cancels the search for a path to the (possibly unreachable or very far away) target position polygon. In this case the pathfinding resets and builds a path from the start polygon to the polygon that was found closest to the target position so far. A value of `0` or below counts as unlimited. In case of unlimited the pathfinding will search all polygons connected with the start polygon until either the target position polygon is found or all available polygon search options are exhausted.
+     */
+    get pathSearchMaxDistance(): number { return _C(this, 5859) as number; }
+    set pathSearchMaxDistance(v: number) { _C(this, 12292, v); }
+
+    static readonly name = _R(445, NavigationPathQueryParameters3D);
+}
+
+export const PathfindingAlgorithm = {
+    /**
+     * The path query uses the default A* pathfinding algorithm.
+     */
+    PATHFINDING_ALGORITHM_ASTAR: 0,
+} as const;
+
+export type PathfindingAlgorithm = (typeof PathfindingAlgorithm)[keyof typeof PathfindingAlgorithm];
+
+export const PathPostProcessing = {
+    /**
+     * Applies a funnel algorithm to the raw path corridor found by the pathfinding algorithm. This will result in the shortest path possible inside the path corridor. This postprocessing very much depends on the navigation mesh polygon layout and the created corridor. Especially tile- or gridbased layouts can face artificial corners with diagonal movement due to a jagged path corridor imposed by the cell shapes.
+     */
+    PATH_POSTPROCESSING_CORRIDORFUNNEL: 0,
+    /**
+     * Centers every path position in the middle of the traveled navigation mesh polygon edge. This creates better paths for tile- or gridbased layouts that restrict the movement to the cells center.
+     */
+    PATH_POSTPROCESSING_EDGECENTERED: 1,
+    /**
+     * Applies no postprocessing and returns the raw path corridor as found by the pathfinding algorithm.
+     */
+    PATH_POSTPROCESSING_NONE: 2,
+} as const;
+
+export type PathPostProcessing = (typeof PathPostProcessing)[keyof typeof PathPostProcessing];
+
+export const PathMetadataFlags = {
+    /**
+     * Don't include any additional metadata about the returned path.
+     */
+    PATH_METADATA_INCLUDE_NONE: 0,
+    /**
+     * Include the type of navigation primitive (region or link) that each point of the path goes through.
+     */
+    PATH_METADATA_INCLUDE_TYPES: 1,
+    /**
+     * Include the {@link RID}s of the regions and links that each point of the path goes through.
+     */
+    PATH_METADATA_INCLUDE_RIDS: 2,
+    /**
+     * Include the `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+     */
+    PATH_METADATA_INCLUDE_OWNERS: 4,
+    /**
+     * Include all available metadata about the returned path.
+     */
+    PATH_METADATA_INCLUDE_ALL: 7,
+} as const;
+
+export type PathMetadataFlags = (typeof PathMetadataFlags)[keyof typeof PathMetadataFlags];
+

package/gen/classes/NavigationPathQueryResult2D.ts

@@ -0,0 +1,64 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, PackedInt32Array, PackedInt64Array, PackedVector2Array, RID } from '../heap-types/index.ts';
+
+/**
+ * This class stores the result of a 2D navigation path query from the {@link NavigationServer2D}.
+ */
+export class NavigationPathQueryResult2D extends RefCounted {
+    constructor(name = 446) { super(name); }
+
+    /**
+     * Reset the result object to its initial state. This is useful to reuse the object across multiple queries.
+     */
+    reset(): void { _C(this, 10064); }
+
+    /**
+     * The resulting path array from the navigation query. All path array positions are in global coordinates. Without customized query parameters this is the same path as returned by {@link NavigationServer2D.mapGetPath}.
+     */
+    get path(): PackedVector2Array { return _C(this, 5840) as PackedVector2Array; }
+    set path(v: PackedVector2Array) { _C(this, 12271, v); }
+
+    /**
+     * The type of navigation primitive (region or link) that each point of the path goes through.
+     */
+    get pathTypes(): PackedInt32Array { return _C(this, 5863) as PackedInt32Array; }
+    set pathTypes(v: PackedInt32Array) { _C(this, 12295, v); }
+
+    /**
+     * The {@link RID}s of the regions and links that each point of the path goes through.
+     */
+    get pathRids(): GodotArray<RID> { return _C(this, 5856) as GodotArray<RID>; }
+    set pathRids(v: GodotArray<RID>) { _C(this, 12289, v); }
+
+    /**
+     * The `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+     */
+    get pathOwnerIds(): PackedInt64Array { return _C(this, 5852) as PackedInt64Array; }
+    set pathOwnerIds(v: PackedInt64Array) { _C(this, 12285, v); }
+
+    /**
+     * Returns the length of the path.
+     */
+    get pathLength(): number { return _C(this, 5848) as number; }
+    set pathLength(v: number) { _C(this, 12280, v); }
+
+    static readonly name = _R(446, NavigationPathQueryResult2D);
+}
+
+export const PathSegmentType = {
+    /**
+     * This segment of the path goes through a region.
+     */
+    PATH_SEGMENT_TYPE_REGION: 0,
+    /**
+     * This segment of the path goes through a link.
+     */
+    PATH_SEGMENT_TYPE_LINK: 1,
+} as const;
+
+export type PathSegmentType = (typeof PathSegmentType)[keyof typeof PathSegmentType];
+

package/gen/classes/NavigationPathQueryResult3D.ts

@@ -0,0 +1,64 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { GodotArray, PackedInt32Array, PackedInt64Array, PackedVector3Array, RID } from '../heap-types/index.ts';
+
+/**
+ * This class stores the result of a 3D navigation path query from the {@link NavigationServer3D}.
+ */
+export class NavigationPathQueryResult3D extends RefCounted {
+    constructor(name = 447) { super(name); }
+
+    /**
+     * Reset the result object to its initial state. This is useful to reuse the object across multiple queries.
+     */
+    reset(): void { _C(this, 10064); }
+
+    /**
+     * The resulting path array from the navigation query. All path array positions are in global coordinates. Without customized query parameters this is the same path as returned by {@link NavigationServer3D.mapGetPath}.
+     */
+    get path(): PackedVector3Array { return _C(this, 5840) as PackedVector3Array; }
+    set path(v: PackedVector3Array) { _C(this, 12271, v); }
+
+    /**
+     * The type of navigation primitive (region or link) that each point of the path goes through.
+     */
+    get pathTypes(): PackedInt32Array { return _C(this, 5863) as PackedInt32Array; }
+    set pathTypes(v: PackedInt32Array) { _C(this, 12295, v); }
+
+    /**
+     * The {@link RID}s of the regions and links that each point of the path goes through.
+     */
+    get pathRids(): GodotArray<RID> { return _C(this, 5856) as GodotArray<RID>; }
+    set pathRids(v: GodotArray<RID>) { _C(this, 12289, v); }
+
+    /**
+     * The `ObjectID`s of the {@link Object}s which manage the regions and links each point of the path goes through.
+     */
+    get pathOwnerIds(): PackedInt64Array { return _C(this, 5852) as PackedInt64Array; }
+    set pathOwnerIds(v: PackedInt64Array) { _C(this, 12285, v); }
+
+    /**
+     * Returns the length of the path.
+     */
+    get pathLength(): number { return _C(this, 5848) as number; }
+    set pathLength(v: number) { _C(this, 12280, v); }
+
+    static readonly name = _R(447, NavigationPathQueryResult3D);
+}
+
+export const PathSegmentType = {
+    /**
+     * This segment of the path goes through a region.
+     */
+    PATH_SEGMENT_TYPE_REGION: 0,
+    /**
+     * This segment of the path goes through a link.
+     */
+    PATH_SEGMENT_TYPE_LINK: 1,
+} as const;
+
+export type PathSegmentType = (typeof PathSegmentType)[keyof typeof PathSegmentType];
+