@ringozz/godot 0.1.0

package/gen/classes/NavigationPolygon.ts

@@ -0,0 +1,259 @@
+// 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, PackedVector2Array, StringName } from '../heap-types/index.ts';
+import type { Rect2, Vector2 } from '../value-types/index.ts';
+import type { NavigationMesh } from './NavigationMesh.ts';
+
+/**
+ * A navigation mesh can be created either by baking it with the help of the {@link NavigationServer2D}, or by adding vertices and convex polygon indices arrays manually.
+ * To bake a navigation mesh at least one outline needs to be added that defines the outer bounds of the baked area.
+ *
+ *
+ * ```gdscript
+ *
+ * var new_navigation_mesh = NavigationPolygon.new()
+ * var bounding_outline = PackedVector2Array([Vector2(0, 0), Vector2(0, 50), Vector2(50, 50), Vector2(50, 0)])
+ * new_navigation_mesh.add_outline(bounding_outline)
+ * NavigationServer2D.bake_from_source_geometry_data(new_navigation_mesh, NavigationMeshSourceGeometryData2D.new());
+ * $NavigationRegion2D.navigation_polygon = new_navigation_mesh
+ *
+ * ```
+ *
+ *
+ *
+ * Adding vertices and polygon indices manually.
+ *
+ *
+ * ```gdscript
+ *
+ * var new_navigation_mesh = NavigationPolygon.new()
+ * var new_vertices = PackedVector2Array([Vector2(0, 0), Vector2(0, 50), Vector2(50, 50), Vector2(50, 0)])
+ * new_navigation_mesh.vertices = new_vertices
+ * var new_polygon_indices = PackedInt32Array([0, 1, 2, 3])
+ * new_navigation_mesh.add_polygon(new_polygon_indices)
+ * $NavigationRegion2D.navigation_polygon = new_navigation_mesh
+ *
+ * ```
+ */
+export class NavigationPolygon extends Resource {
+    constructor(name = 448) { super(name); }
+
+    /**
+     * 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 count of all polygons.
+     */
+    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 outlines and vertices.
+     */
+    clearPolygons(): void { _C(this, 2288); }
+
+    /**
+     * Returns the {@link NavigationMesh} resulting from this navigation polygon. This navigation mesh can be used to update the navigation mesh of a region with the {@link NavigationServer3D.regionSetNavigationMesh} API directly.
+     */
+    getNavigationMesh(): NavigationMesh { return _C(this, 5613) as NavigationMesh; }
+
+    /**
+     * Appends a {@link PackedVector2Array} that contains the vertices of an outline to the internal array that contains all the outlines.
+     */
+    addOutline(outline: PackedVector2Array): void { _C(this, 1263, outline); }
+
+    /**
+     * Adds a {@link PackedVector2Array} that contains the vertices of an outline to the internal array that contains all the outlines at a fixed position.
+     */
+    addOutlineAtIndex(outline: PackedVector2Array, index: number): void { _C(this, 1264, outline, index); }
+
+    /**
+     * Returns the number of outlines that were created in the editor or by script.
+     */
+    getOutlineCount(): number { return _C(this, 5757) as number; }
+
+    /**
+     * Changes an outline created in the editor or by script. You have to call {@link makePolygonsFromOutlines} for the polygons to update.
+     */
+    setOutline(idx: number, outline: PackedVector2Array): void { _C(this, 12214, idx, outline); }
+
+    /**
+     * Returns a {@link PackedVector2Array} containing the vertices of an outline that was created in the editor or by script.
+     */
+    getOutline(idx: number): PackedVector2Array { return _C(this, 5755, idx) as PackedVector2Array; }
+
+    /**
+     * Removes an outline created in the editor or by script. You have to call {@link makePolygonsFromOutlines} for the polygons to update.
+     */
+    removeOutline(idx: number): void { _C(this, 9940, idx); }
+
+    /**
+     * Clears the array of the outlines, but it doesn't clear the vertices and the polygons that were created by them.
+     */
+    clearOutlines(): void { _C(this, 2285); }
+
+    /**
+     * Creates polygons from the outlines added in the editor or by script.
+     */
+    makePolygonsFromOutlines(): void { _C(this, 8737); }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link parsedCollisionMask}, given a `layerNumber` between 1 and 32.
+     */
+    setParsedCollisionMaskValue(layerNumber: number, value: boolean): void { _C(this, 12261, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link parsedCollisionMask} is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getParsedCollisionMaskValue(layerNumber: number): boolean { return _C(this, 5828, layerNumber) as boolean; }
+
+    /**
+     * Clears the internal arrays for vertices and polygon indices.
+     */
+    clear(): void { _C(this, 2232); }
+
+    get vertices(): PackedVector2Array { return _C(this, 7068) as PackedVector2Array; }
+    set vertices(v: PackedVector2Array) { _C(this, 13308, v); }
+
+    get polygons(): GodotArray { return _C(this, 1009) as GodotArray; }
+    set polygons(v: GodotArray) { _C(this, 1037, v); }
+
+    get outlines(): GodotArray { return _C(this, 1006) as GodotArray; }
+    set outlines(v: GodotArray) { _C(this, 1034, 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 parsedGeometryType(): ParsedGeometryType { return _C(this, 5829) as ParsedGeometryType; }
+    set parsedGeometryType(v: ParsedGeometryType) { _C(this, 12262, v); }
+
+    /**
+     * The physics layers to scan for static colliders.
+     * Only used when {@link parsedGeometryType} is {@link PARSED_GEOMETRY_STATIC_COLLIDERS} or {@link PARSED_GEOMETRY_BOTH}.
+     */
+    get parsedCollisionMask(): number { return _C(this, 5827) as number; }
+    set parsedCollisionMask(v: number) { _C(this, 12260, v); }
+
+    /**
+     * The source of the geometry used when baking.
+     */
+    get sourceGeometryMode(): SourceGeometryMode { return _C(this, 6459) as SourceGeometryMode; }
+    set sourceGeometryMode(v: SourceGeometryMode) { _C(this, 12815, v); }
+
+    /**
+     * The group name of nodes that should be parsed for baking source geometry.
+     * Only used when {@link sourceGeometryMode} is {@link SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN} or {@link SOURCE_GEOMETRY_GROUPS_EXPLICIT}.
+     */
+    get sourceGeometryGroupName(): StringName { return _C(this, 6458) as StringName; }
+    set sourceGeometryGroupName(v: StringName) { _C(this, 12814, v); }
+
+    /**
+     * The cell size used to rasterize the navigation mesh vertices. 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 size of the non-navigable border around the bake bounding area defined by the {@link bakingRect} {@link Rect2}.
+     * In conjunction with the {@link bakingRect} the border size can be used to bake tile aligned navigation meshes without the tile edges being shrunk by {@link agentRadius}.
+     */
+    get borderSize(): number { return _C(this, 3987) as number; }
+    set borderSize(v: number) { _C(this, 10727, v); }
+
+    /**
+     * The distance to erode/shrink the walkable surface when baking the navigation mesh.
+     * **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); }
+
+    /**
+     * If the baking {@link Rect2} has an area the navigation mesh baking will be restricted to its enclosing area.
+     */
+    get bakingRect(): Rect2 { return _C(this, 3887) as Rect2; }
+    set bakingRect(v: Rect2) { _C(this, 10636, v); }
+
+    /**
+     * The position offset applied to the {@link bakingRect} {@link Rect2}.
+     */
+    get bakingRectOffset(): Vector2 { return _C(this, 3888) as Vector2; }
+    set bakingRectOffset(v: Vector2) { _C(this, 10637, v); }
+
+    static readonly name = _R(448, NavigationPolygon);
+}
+
+export const SamplePartitionType = {
+    /**
+     * Convex partitioning that results in a navigation mesh with convex polygons.
+     */
+    SAMPLE_PARTITION_CONVEX_PARTITION: 0,
+    /**
+     * Triangulation partitioning that results in a navigation mesh with triangle polygons.
+     */
+    SAMPLE_PARTITION_TRIANGULATE: 1,
+    /**
+     * Represents the size of the {@link SamplePartitionType} enum.
+     */
+    SAMPLE_PARTITION_MAX: 2,
+} as const;
+
+export type SamplePartitionType = (typeof SamplePartitionType)[keyof typeof SamplePartitionType];
+
+export const ParsedGeometryType = {
+    /**
+     * Parses mesh instances as obstruction geometry. This includes {@link Polygon2D}, {@link MeshInstance2D}, {@link MultiMeshInstance2D}, and {@link TileMap} nodes.
+     * Meshes are only parsed when they use a 2D vertices surface format.
+     */
+    PARSED_GEOMETRY_MESH_INSTANCES: 0,
+    /**
+     * Parses {@link StaticBody2D} and {@link TileMap} colliders as obstruction geometry. The collider should be in any of the layers specified by {@link parsedCollisionMask}.
+     */
+    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 sourceGeometryGroupName}.
+     */
+    SOURCE_GEOMETRY_GROUPS_WITH_CHILDREN: 1,
+    /**
+     * Uses nodes in a group for geometry. The group is specified by {@link sourceGeometryGroupName}.
+     */
+    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/NavigationRegion2D.ts

@@ -0,0 +1,116 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+import type { Rect2 } from '../value-types/index.ts';
+import type { NavigationPolygon } from './NavigationPolygon.ts';
+
+/**
+ * A traversable 2D region based on a {@link NavigationPolygon} that {@link NavigationAgent2D}s can use for pathfinding.
+ * Two regions can be connected to each other if they share a similar edge. You can set the minimum distance between two vertices required to connect two edges by using {@link NavigationServer2D.mapSetEdgeConnectionMargin}.
+ * **Note:** Overlapping two regions' navigation polygons is not enough for connecting two regions. They must share a similar edge.
+ * The pathfinding cost of entering a region from another region can be controlled with the {@link enterCost} value.
+ * **Note:** This value is not added to the path cost when the start position is already inside this region.
+ * The pathfinding cost of traveling distances inside this region can be controlled with the {@link travelCost} multiplier.
+ * **Note:** This node caches changes to its properties, so if you make changes to the underlying region {@link RID} in {@link NavigationServer2D}, they will not be reflected in this node's properties.
+ */
+export class NavigationRegion2D extends Node2D {
+    constructor(name = 449) { super(name); }
+
+    /**
+     * Returns the {@link RID} of this region on the {@link NavigationServer2D}. Combined with {@link NavigationServer2D.mapGetClosestPointOwner} can be used to identify the {@link NavigationRegion2D} closest to a point on the merged navigation map.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * Sets the {@link RID} of the navigation map this region should use. By default the region will automatically join the {@link World2D} default navigation map so this function is only required to override the default map.
+     */
+    setNavigationMap(navigationMap: RID): void { _C(this, 12120, navigationMap); }
+
+    /**
+     * Returns the current navigation map {@link RID} used by this region.
+     */
+    getNavigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link navigationLayers} bitmask, given a `layerNumber` between 1 and 32.
+     */
+    setNavigationLayerValue(layerNumber: number, value: boolean): void { _C(this, 12118, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link navigationLayers} bitmask is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getNavigationLayerValue(layerNumber: number): boolean { return _C(this, 5609, layerNumber) as boolean; }
+
+    /**
+     * Returns the {@link RID} of this region on the {@link NavigationServer2D}.
+     */
+    getRegionRid(): RID { return _C(this, 6116) as RID; }
+
+    /**
+     * Bakes the {@link NavigationPolygon}. If `onThread` is set to `true` (default), the baking is done on a separate thread.
+     */
+    bakeNavigationPolygon(onThread?: boolean /* = true */): void { _C(this, 1720, onThread); }
+
+    /**
+     * Returns `true` when the {@link NavigationPolygon} is being baked on a background thread.
+     */
+    isBaking(): boolean { return _C(this, 7789) as boolean; }
+
+    /**
+     * Returns the axis-aligned rectangle for the region's transformed navigation mesh.
+     */
+    getBounds(): Rect2 { return _C(this, 3997) as Rect2; }
+
+    /**
+     * The {@link NavigationPolygon} resource to use.
+     */
+    get navigationPolygon(): NavigationPolygon { return _C(this, 5614) as NavigationPolygon; }
+    set navigationPolygon(v: NavigationPolygon) { _C(this, 12122, v); }
+
+    /**
+     * Determines if the {@link NavigationRegion2D} is enabled or disabled.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * If enabled the navigation region will use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+     */
+    get useEdgeConnections(): boolean { return _C(this, 6975) as boolean; }
+    set useEdgeConnections(v: boolean) { _C(this, 13211, v); }
+
+    /**
+     * A bitfield determining all navigation layers the region belongs to. These navigation layers can be checked upon when requesting a path with {@link NavigationServer2D.mapGetPath}.
+     */
+    get navigationLayers(): number { return _C(this, 5610) as number; }
+    set navigationLayers(v: number) { _C(this, 12119, v); }
+
+    /**
+     * When pathfinding enters this region's navigation mesh from another regions navigation mesh the {@link enterCost} value is added to the path distance for determining the shortest path.
+     */
+    get enterCost(): number { return _C(this, 4671) as number; }
+    set enterCost(v: number) { _C(this, 11298, v); }
+
+    /**
+     * When pathfinding moves inside this region's navigation mesh the traveled distances are multiplied with {@link travelCost} for determining the shortest path.
+     */
+    get travelCost(): number { return _C(this, 6902) as number; }
+    set travelCost(v: number) { _C(this, 13151, v); }
+
+    /**
+     * Emitted when the used navigation polygon is replaced or changes to the internals of the current navigation polygon are committed.
+     */
+    get navigationPolygonChanged(): Signal<() => void> { return _G(this, 9059) as Signal<() => void>; }
+    set navigationPolygonChanged(v: (() => void) | null) { _G(this, 9059, v); }
+
+    /**
+     * Emitted when a navigation polygon bake operation is completed.
+     */
+    get bakeFinished(): Signal<() => void> { return _G(this, 1710) as Signal<() => void>; }
+    set bakeFinished(v: (() => void) | null) { _G(this, 1710, v); }
+
+    static readonly name = _R(449, NavigationRegion2D);
+}

package/gen/classes/NavigationRegion3D.ts

@@ -0,0 +1,116 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { RID, Signal } from '../heap-types/index.ts';
+import type { AABB } from '../value-types/index.ts';
+import type { NavigationMesh } from './NavigationMesh.ts';
+
+/**
+ * A traversable 3D region based on a {@link NavigationMesh} that {@link NavigationAgent3D}s can use for pathfinding.
+ * Two regions can be connected to each other if they share a similar edge. You can set the minimum distance between two vertices required to connect two edges by using {@link NavigationServer3D.mapSetEdgeConnectionMargin}.
+ * **Note:** Overlapping two regions' navigation meshes is not enough for connecting two regions. They must share a similar edge.
+ * The cost of entering this region from another region can be controlled with the {@link enterCost} value.
+ * **Note:** This value is not added to the path cost when the start position is already inside this region.
+ * The cost of traveling distances inside this region can be controlled with the {@link travelCost} multiplier.
+ * **Note:** This node caches changes to its properties, so if you make changes to the underlying region {@link RID} in {@link NavigationServer3D}, they will not be reflected in this node's properties.
+ */
+export class NavigationRegion3D extends Node3D {
+    constructor(name = 450) { super(name); }
+
+    /**
+     * Returns the {@link RID} of this region on the {@link NavigationServer3D}. Combined with {@link NavigationServer3D.mapGetClosestPointOwner} can be used to identify the {@link NavigationRegion3D} closest to a point on the merged navigation map.
+     */
+    getRid(): RID { return _C(this, 6177) as RID; }
+
+    /**
+     * Sets the {@link RID} of the navigation map this region should use. By default the region will automatically join the {@link World3D} default navigation map so this function is only required to override the default map.
+     */
+    setNavigationMap(navigationMap: RID): void { _C(this, 12120, navigationMap); }
+
+    /**
+     * Returns the current navigation map {@link RID} used by this region.
+     */
+    getNavigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link navigationLayers} bitmask, given a `layerNumber` between 1 and 32.
+     */
+    setNavigationLayerValue(layerNumber: number, value: boolean): void { _C(this, 12118, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link navigationLayers} bitmask is enabled, given a `layerNumber` between 1 and 32.
+     */
+    getNavigationLayerValue(layerNumber: number): boolean { return _C(this, 5609, layerNumber) as boolean; }
+
+    /**
+     * Returns the {@link RID} of this region on the {@link NavigationServer3D}.
+     */
+    getRegionRid(): RID { return _C(this, 6116) as RID; }
+
+    /**
+     * Bakes the {@link NavigationMesh}. If `onThread` is set to `true` (default), the baking is done on a separate thread. Baking on separate thread is useful because navigation baking is not a cheap operation. When it is completed, it automatically sets the new {@link NavigationMesh}. Please note that baking on separate thread may be very slow if geometry is parsed from meshes as async access to each mesh involves heavy synchronization. Also, please note that baking on a separate thread is automatically disabled on operating systems that cannot use threads (such as Web with threads disabled).
+     */
+    bakeNavigationMesh(onThread?: boolean /* = true */): void { _C(this, 1719, onThread); }
+
+    /**
+     * Returns `true` when the {@link NavigationMesh} is being baked on a background thread.
+     */
+    isBaking(): boolean { return _C(this, 7789) as boolean; }
+
+    /**
+     * Returns the axis-aligned bounding box for the region's transformed navigation mesh.
+     */
+    getBounds(): AABB { return _C(this, 3997) as AABB; }
+
+    /**
+     * The {@link NavigationMesh} resource to use.
+     */
+    get navigationMesh(): NavigationMesh { return _C(this, 5613) as NavigationMesh; }
+    set navigationMesh(v: NavigationMesh) { _C(this, 12121, v); }
+
+    /**
+     * Determines if the {@link NavigationRegion3D} is enabled or disabled.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * If enabled the navigation region will use edge connections to connect with other navigation regions within proximity of the navigation map edge connection margin.
+     */
+    get useEdgeConnections(): boolean { return _C(this, 6975) as boolean; }
+    set useEdgeConnections(v: boolean) { _C(this, 13211, v); }
+
+    /**
+     * A bitfield determining all navigation layers the region belongs to. These navigation layers can be checked upon when requesting a path with {@link NavigationServer3D.mapGetPath}.
+     */
+    get navigationLayers(): number { return _C(this, 5610) as number; }
+    set navigationLayers(v: number) { _C(this, 12119, v); }
+
+    /**
+     * When pathfinding enters this region's navigation mesh from another regions navigation mesh the {@link enterCost} value is added to the path distance for determining the shortest path.
+     */
+    get enterCost(): number { return _C(this, 4671) as number; }
+    set enterCost(v: number) { _C(this, 11298, v); }
+
+    /**
+     * When pathfinding moves inside this region's navigation mesh the traveled distances are multiplied with {@link travelCost} for determining the shortest path.
+     */
+    get travelCost(): number { return _C(this, 6902) as number; }
+    set travelCost(v: number) { _C(this, 13151, v); }
+
+    /**
+     * Notifies when the {@link NavigationMesh} has changed.
+     */
+    get navigationMeshChanged(): Signal<() => void> { return _G(this, 9057) as Signal<() => void>; }
+    set navigationMeshChanged(v: (() => void) | null) { _G(this, 9057, v); }
+
+    /**
+     * Notifies when the navigation mesh bake operation is completed.
+     */
+    get bakeFinished(): Signal<() => void> { return _G(this, 1710) as Signal<() => void>; }
+    set bakeFinished(v: (() => void) | null) { _G(this, 1710, v); }
+
+    static readonly name = _R(450, NavigationRegion3D);
+}