@ringozz/godot 0.1.0

package/gen/classes/Path2D.ts

@@ -0,0 +1,22 @@
+// 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 { Curve2D } from './Curve2D.ts';
+
+/**
+ * Can have {@link PathFollow2D} child nodes moving along the {@link Curve2D}. See {@link PathFollow2D} for more information on usage.
+ * **Note:** The path is considered as relative to the moved nodes (children of {@link PathFollow2D}). As such, the curve should usually start with a zero vector (`(0, 0)`).
+ */
+export class Path2D extends Node2D {
+    constructor(name = 550) { super(name); }
+
+    /**
+     * A {@link Curve2D} describing the path.
+     */
+    get curve(): Curve2D { return _C(this, 4370) as Curve2D; }
+    set curve(v: Curve2D) { _C(this, 10993, v); }
+
+    static readonly name = _R(550, Path2D);
+}

package/gen/classes/Path3D.ts

@@ -0,0 +1,42 @@
+// 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 { Signal } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+import type { Curve3D } from './Curve3D.ts';
+
+/**
+ * Can have {@link PathFollow3D} child nodes moving along the {@link Curve3D}. See {@link PathFollow3D} for more information on the usage.
+ * Note that the path is considered as relative to the moved nodes (children of {@link PathFollow3D}). As such, the curve should usually start with a zero vector `(0, 0, 0)`.
+ */
+export class Path3D extends Node3D {
+    constructor(name = 551) { super(name); }
+
+    /**
+     * A {@link Curve3D} describing the path.
+     */
+    get curve(): Curve3D { return _C(this, 4370) as Curve3D; }
+    set curve(v: Curve3D) { _C(this, 10993, v); }
+
+    /**
+     * The custom color used to draw the path in the editor. If set to {@link Color.BLACK} (as by default), the color set in {@link ProjectSettings.debug/shapes/paths/geometryColor} is used.
+     */
+    get debugCustomColor(): Color { return _C(this, 4430) as Color; }
+    set debugCustomColor(v: Color) { _C(this, 11041, v); }
+
+    /**
+     * Emitted when the {@link curve} changes.
+     */
+    get curveChanged(): Signal<() => void> { return _G(this, 2613) as Signal<() => void>; }
+    set curveChanged(v: (() => void) | null) { _G(this, 2613, v); }
+
+    /**
+     * Emitted when the {@link debugCustomColor} changes.
+     */
+    get debugColorChanged(): Signal<() => void> { return _G(this, 2663) as Signal<() => void>; }
+    set debugColorChanged(v: (() => void) | null) { _G(this, 2663, v); }
+
+    static readonly name = _R(551, Path3D);
+}

package/gen/classes/PathFollow2D.ts

@@ -0,0 +1,60 @@
+// 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';
+
+/**
+ * This node takes its parent {@link Path2D}, and returns the coordinates of a point within it, given a distance from the first vertex.
+ * It is useful for making other nodes follow a path, without coding the movement pattern. For that, the nodes must be children of this node. The descendant nodes will then move accordingly when setting the {@link progress} in this node.
+ */
+export class PathFollow2D extends Node2D {
+    constructor(name = 552) { super(name); }
+
+    /**
+     * The distance along the path, in pixels. Changing this value sets this node's position to a point within the path.
+     */
+    get progress(): number { return _C(this, 6036) as number; }
+    set progress(v: number) { _C(this, 12436, v); }
+
+    /**
+     * The distance along the path as a number in the range 0.0 (for the first vertex) to 1.0 (for the last). This is just another way of expressing the progress within the path, as the offset supplied is multiplied internally by the path's length.
+     * It can be set or get only if the {@link PathFollow2D} is the child of a {@link Path2D} which is part of the scene tree, and that this {@link Path2D} has a {@link Curve2D} with a non-zero length. Otherwise, trying to set this field will print an error, and getting this field will return `0.0`.
+     */
+    get progressRatio(): number { return _C(this, 6038) as number; }
+    set progressRatio(v: number) { _C(this, 12438, v); }
+
+    /**
+     * The node's offset along the curve.
+     */
+    get hOffset(): number { return _C(this, 5001) as number; }
+    set hOffset(v: number) { _C(this, 11586, v); }
+
+    /**
+     * The node's offset perpendicular to the curve.
+     */
+    get vOffset(): number { return _C(this, 7012) as number; }
+    set vOffset(v: number) { _C(this, 13263, v); }
+
+    /**
+     * If `true`, this node rotates to follow the path, with the +X direction facing forward on the path.
+     */
+    get rotates(): boolean { return _C(this, 8253) as boolean; }
+    set rotates(v: boolean) { _C(this, 12576, v); }
+
+    /**
+     * If `true`, the position between two cached points is interpolated cubically, and linearly otherwise.
+     * The points along the {@link Curve2D} of the {@link Path2D} are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough.
+     * There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations.
+     */
+    get cubicInterp(): boolean { return _C(this, 4338) as boolean; }
+    set cubicInterp(v: boolean) { _C(this, 10980, v); }
+
+    /**
+     * If `true`, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths.
+     */
+    get loop(): boolean { return _C(this, 7412) as boolean; }
+    set loop(v: boolean) { _C(this, 11949, v); }
+
+    static readonly name = _R(552, PathFollow2D);
+}

package/gen/classes/PathFollow3D.ts

@@ -0,0 +1,104 @@
+// 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 { Transform3D } from '../value-types/index.ts';
+
+/**
+ * This node takes its parent {@link Path3D}, and returns the coordinates of a point within it, given a distance from the first vertex.
+ * It is useful for making other nodes follow a path, without coding the movement pattern. For that, the nodes must be children of this node. The descendant nodes will then move accordingly when setting the {@link progress} in this node.
+ */
+export class PathFollow3D extends Node3D {
+    constructor(name = 553) { super(name); }
+
+    /**
+     * Correct the `transform`. `rotationMode` implicitly specifies how posture (forward, up and sideway direction) is calculated.
+     */
+    static correctPosture(transform: Transform3D, rotationMode: RotationMode): Transform3D { return _C(553, 2499, transform, rotationMode) as Transform3D; }
+
+    /**
+     * The distance from the first vertex, measured in 3D units along the path. Changing this value sets this node's position to a point within the path.
+     */
+    get progress(): number { return _C(this, 6036) as number; }
+    set progress(v: number) { _C(this, 12436, v); }
+
+    /**
+     * The distance from the first vertex, considering 0.0 as the first vertex and 1.0 as the last. This is just another way of expressing the progress within the path, as the progress supplied is multiplied internally by the path's length.
+     * It can be set or get only if the {@link PathFollow3D} is the child of a {@link Path3D} which is part of the scene tree, and that this {@link Path3D} has a {@link Curve3D} with a non-zero length. Otherwise, trying to set this field will print an error, and getting this field will return `0.0`.
+     */
+    get progressRatio(): number { return _C(this, 6038) as number; }
+    set progressRatio(v: number) { _C(this, 12438, v); }
+
+    /**
+     * The node's offset along the curve.
+     */
+    get hOffset(): number { return _C(this, 5001) as number; }
+    set hOffset(v: number) { _C(this, 11586, v); }
+
+    /**
+     * The node's offset perpendicular to the curve.
+     */
+    get vOffset(): number { return _C(this, 7012) as number; }
+    set vOffset(v: number) { _C(this, 13263, v); }
+
+    /**
+     * Allows or forbids rotation on one or more axes, depending on the {@link RotationMode} constants being used.
+     */
+    get rotationMode(): RotationMode { return _C(this, 6211) as RotationMode; }
+    set rotationMode(v: RotationMode) { _C(this, 12585, v); }
+
+    /**
+     * If `true`, the node moves on the travel path with orienting the +Z axis as forward. See also {@link Vector3.FORWARD} and {@link Vector3.MODEL_FRONT}.
+     */
+    get useModelFront(): boolean { return _C(this, 8411) as boolean; }
+    set useModelFront(v: boolean) { _C(this, 13227, v); }
+
+    /**
+     * If `true`, the position between two cached points is interpolated cubically, and linearly otherwise.
+     * The points along the {@link Curve3D} of the {@link Path3D} are precomputed before use, for faster calculations. The point at the requested offset is then calculated interpolating between two adjacent cached points. This may present a problem if the curve makes sharp turns, as the cached points may not follow the curve closely enough.
+     * There are two answers to this problem: either increase the number of cached points and increase memory consumption, or make a cubic interpolation between two points at the cost of (slightly) slower calculations.
+     */
+    get cubicInterp(): boolean { return _C(this, 4338) as boolean; }
+    set cubicInterp(v: boolean) { _C(this, 10980, v); }
+
+    /**
+     * If `true`, any offset outside the path's length will wrap around, instead of stopping at the ends. Use it for cyclic paths.
+     */
+    get loop(): boolean { return _C(this, 7412) as boolean; }
+    set loop(v: boolean) { _C(this, 11949, v); }
+
+    /**
+     * If `true`, the tilt property of {@link Curve3D} takes effect.
+     */
+    get tiltEnabled(): boolean { return _C(this, 8364) as boolean; }
+    set tiltEnabled(v: boolean) { _C(this, 13080, v); }
+
+    static readonly name = _R(553, PathFollow3D);
+}
+
+export const RotationMode = {
+    /**
+     * Forbids the PathFollow3D to rotate.
+     */
+    ROTATION_NONE: 0,
+    /**
+     * Allows the PathFollow3D to rotate in the Y axis only.
+     */
+    ROTATION_Y: 1,
+    /**
+     * Allows the PathFollow3D to rotate in both the X, and Y axes.
+     */
+    ROTATION_XY: 2,
+    /**
+     * Allows the PathFollow3D to rotate in any axis.
+     */
+    ROTATION_XYZ: 3,
+    /**
+     * Uses the up vector information in a {@link Curve3D} to enforce orientation. This rotation mode requires the {@link Path3D}'s {@link Curve3D.upVectorEnabled} property to be set to `true`.
+     */
+    ROTATION_ORIENTED: 4,
+} as const;
+
+export type RotationMode = (typeof RotationMode)[keyof typeof RotationMode];
+

package/gen/classes/Performance.ts

@@ -0,0 +1,370 @@
+// 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, GodotArray, PackedInt32Array, StringName, Variant } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 554));
+
+/**
+ * This class provides access to a number of different monitors related to performance, such as memory usage, draw calls, and FPS. These are the same as the values displayed in the **Monitor** tab in the editor's **Debugger** panel. By using the {@link getMonitor} method of this class, you can access this data from your code.
+ * You can add custom monitors using the {@link addCustomMonitor} method. Custom monitors are available in **Monitor** tab in the editor's **Debugger** panel together with built-in monitors.
+ * **Note:** Some of the built-in monitors are only available in debug mode and will always return `0` when used in a project exported in release mode.
+ * **Note:** Some of the built-in monitors are not updated in real-time for performance reasons, so there may be a delay of up to 1 second between changes.
+ * **Note:** Custom monitors do not support negative values. Negative values are clamped to 0.
+ */
+export class Performance extends GodotVar {
+
+    /**
+     * Returns the value of one of the available built-in monitors. You should provide one of the {@link Monitor} constants as the argument, like this:
+     *
+     *
+     * ```gdscript
+     *
+     * print(Performance.get_monitor(Performance.TIME_FPS)) # Prints the FPS to the console.
+     *
+     * ```
+     *
+     *
+     *
+     * See {@link getCustomMonitor} to query custom performance monitors' values.
+     */
+    static getMonitor(monitor: Monitor): number { return _C($(), 5577, monitor) as number; }
+
+    /**
+     * Adds a custom monitor with the name `id`. You can specify the category of the monitor using slash delimiters in `id` (for example: `"Game/NumberOfNPCs"`). If there is more than one slash delimiter, then the default category is used. The default category is `"Custom"`. Prints an error if given `id` is already present.
+     *
+     *
+     * ```gdscript
+     *
+     * func _ready():
+     * 	var monitor_value = Callable(self, "get_monitor_value")
+     *
+     * 	# Adds monitor with name "MyName" to category "MyCategory".
+     * 	Performance.add_custom_monitor("MyCategory/MyMonitor", monitor_value)
+     *
+     * 	# Adds monitor with name "MyName" to category "Custom".
+     * 	# Note: "MyCategory/MyMonitor" and "MyMonitor" have same name but different IDs, so the code is valid.
+     * 	Performance.add_custom_monitor("MyMonitor", monitor_value)
+     *
+     * 	# Adds monitor with name "MyName" to category "Custom".
+     * 	# Note: "MyMonitor" and "Custom/MyMonitor" have same name and same category but different IDs, so the code is valid.
+     * 	Performance.add_custom_monitor("Custom/MyMonitor", monitor_value)
+     *
+     * 	# Adds monitor with name "MyCategoryOne/MyCategoryTwo/MyMonitor" to category "Custom".
+     * 	Performance.add_custom_monitor("MyCategoryOne/MyCategoryTwo/MyMonitor", monitor_value)
+     *
+     * func get_monitor_value():
+     * 	return randi() % 25
+     *
+     * ```
+     *
+     *
+     *
+     * The debugger calls the callable to get the value of custom monitor. The callable must return a zero or positive integer or floating-point number.
+     * Callables are called with arguments supplied in argument array.
+     */
+    static addCustomMonitor(id: StringName, callable: Callable, _arguments?: GodotArray /* = [] */, type?: MonitorType /* = 0 */): void { _C($(), 1206, id, callable, _arguments, type); }
+
+    /**
+     * Removes the custom monitor with given `id`. Prints an error if the given `id` is already absent.
+     */
+    static removeCustomMonitor(id: StringName): void { _C($(), 9905, id); }
+
+    /**
+     * Returns `true` if custom monitor with the given `id` is present, `false` otherwise.
+     */
+    static hasCustomMonitor(id: StringName): boolean { return _C($(), 7384, id) as boolean; }
+
+    /**
+     * Returns the value of custom monitor with given `id`. The callable is called to get the value of custom monitor. See also {@link hasCustomMonitor}. Prints an error if the given `id` is absent.
+     */
+    static getCustomMonitor(id: StringName): Variant { return _C($(), 4393, id) as Variant; }
+
+    /**
+     * Returns the last tick in which custom monitor was added/removed (in microseconds since the engine started). This is set to {@link Time.getTicksUsec} when the monitor is updated.
+     */
+    static getMonitorModificationTime(): number { return _C($(), 5578) as number; }
+
+    /**
+     * Returns the names of active custom monitors in an {@link Array}.
+     */
+    static getCustomMonitorNames(): GodotArray<StringName> { return _C($(), 4394) as GodotArray<StringName>; }
+
+    /**
+     * Returns the {@link MonitorType} values of active custom monitors in an {@link Array}.
+     */
+    static getCustomMonitorTypes(): PackedInt32Array { return _C($(), 4395) as PackedInt32Array; }
+
+    static readonly name = _R(554, Performance);
+}
+
+export const Monitor = {
+    /**
+     * The number of frames rendered in the last second. This metric is only updated once per second, even if queried more often. *Higher is better.*
+     */
+    TIME_FPS: 0,
+    /**
+     * Time it took to complete one frame, in seconds. *Lower is better.*
+     */
+    TIME_PROCESS: 1,
+    /**
+     * Time it took to complete one physics frame, in seconds. *Lower is better.*
+     */
+    TIME_PHYSICS_PROCESS: 2,
+    /**
+     * Time it took to complete one navigation step, in seconds. This includes navigation map updates as well as agent avoidance calculations. *Lower is better.*
+     */
+    TIME_NAVIGATION_PROCESS: 3,
+    /**
+     * Static memory currently used, in bytes. Not available in release builds. *Lower is better.*
+     */
+    MEMORY_STATIC: 4,
+    /**
+     * Available static memory. Not available in release builds. *Lower is better.*
+     */
+    MEMORY_STATIC_MAX: 5,
+    /**
+     * Largest amount of memory the message queue buffer has used, in bytes. The message queue is used for deferred functions calls and notifications. *Lower is better.*
+     */
+    MEMORY_MESSAGE_BUFFER_MAX: 6,
+    /**
+     * Number of objects currently instantiated (including nodes). *Lower is better.*
+     */
+    OBJECT_COUNT: 7,
+    /**
+     * Number of resources currently used. *Lower is better.*
+     */
+    OBJECT_RESOURCE_COUNT: 8,
+    /**
+     * Number of nodes currently instantiated in the scene tree. This also includes the root node. *Lower is better.*
+     */
+    OBJECT_NODE_COUNT: 9,
+    /**
+     * Number of orphan nodes, i.e. nodes which are not parented to a node of the scene tree. *Lower is better.*
+     * **Note:** This is only available in debug mode and will always return `0` when used in a project exported in release mode.
+     */
+    OBJECT_ORPHAN_NODE_COUNT: 10,
+    /**
+     * The total number of objects in the last rendered frame. This metric doesn't include culled objects (either via hiding nodes, frustum culling or occlusion culling). *Lower is better.*
+     */
+    RENDER_TOTAL_OBJECTS_IN_FRAME: 11,
+    /**
+     * The total number of vertices or indices rendered in the last rendered frame. This metric doesn't include primitives from culled objects (either via hiding nodes, frustum culling or occlusion culling). Due to the depth prepass and shadow passes, the number of primitives is always higher than the actual number of vertices in the scene (typically double or triple the original vertex count). *Lower is better.*
+     */
+    RENDER_TOTAL_PRIMITIVES_IN_FRAME: 12,
+    /**
+     * The total number of draw calls performed in the last rendered frame. This metric doesn't include culled objects (either via hiding nodes, frustum culling or occlusion culling), since they do not result in draw calls. *Lower is better.*
+     */
+    RENDER_TOTAL_DRAW_CALLS_IN_FRAME: 13,
+    /**
+     * The amount of video memory used (texture and vertex memory combined, in bytes). Since this metric also includes miscellaneous allocations, this value is always greater than the sum of {@link RENDER_TEXTURE_MEM_USED} and {@link RENDER_BUFFER_MEM_USED}. *Lower is better.*
+     */
+    RENDER_VIDEO_MEM_USED: 14,
+    /**
+     * The amount of texture memory used (in bytes). *Lower is better.*
+     */
+    RENDER_TEXTURE_MEM_USED: 15,
+    /**
+     * The amount of render buffer memory used (in bytes). *Lower is better.*
+     */
+    RENDER_BUFFER_MEM_USED: 16,
+    /**
+     * Number of active {@link RigidBody2D} nodes in the game. *Lower is better.*
+     */
+    PHYSICS_2D_ACTIVE_OBJECTS: 17,
+    /**
+     * Number of collision pairs in the 2D physics engine. *Lower is better.*
+     */
+    PHYSICS_2D_COLLISION_PAIRS: 18,
+    /**
+     * Number of islands in the 2D physics engine. *Lower is better.*
+     */
+    PHYSICS_2D_ISLAND_COUNT: 19,
+    /**
+     * Number of active {@link RigidBody3D} and {@link VehicleBody3D} nodes in the game. *Lower is better.*
+     */
+    PHYSICS_3D_ACTIVE_OBJECTS: 20,
+    /**
+     * Number of collision pairs in the 3D physics engine. *Lower is better.*
+     */
+    PHYSICS_3D_COLLISION_PAIRS: 21,
+    /**
+     * Number of islands in the 3D physics engine. *Lower is better.*
+     */
+    PHYSICS_3D_ISLAND_COUNT: 22,
+    /**
+     * Output latency of the {@link AudioServer}. Equivalent to calling {@link AudioServer.getOutputLatency}, it is not recommended to call this every frame.
+     */
+    AUDIO_OUTPUT_LATENCY: 23,
+    /**
+     * Number of active navigation maps in {@link NavigationServer2D} and {@link NavigationServer3D}. This also includes the empty default navigation maps created by {@link World2D} and {@link World3D} instances.
+     */
+    NAVIGATION_ACTIVE_MAPS: 24,
+    /**
+     * Number of active navigation regions in {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_REGION_COUNT: 25,
+    /**
+     * Number of active navigation agents processing avoidance in {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_AGENT_COUNT: 26,
+    /**
+     * Number of active navigation links in {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_LINK_COUNT: 27,
+    /**
+     * Number of navigation mesh polygons in {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_POLYGON_COUNT: 28,
+    /**
+     * Number of navigation mesh polygon edges in {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_EDGE_COUNT: 29,
+    /**
+     * Number of navigation mesh polygon edges that were merged due to edge key overlap in {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_EDGE_MERGE_COUNT: 30,
+    /**
+     * Number of polygon edges that are considered connected by edge proximity {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_EDGE_CONNECTION_COUNT: 31,
+    /**
+     * Number of navigation mesh polygon edges that could not be merged in {@link NavigationServer2D} and {@link NavigationServer3D}. The edges still may be connected by edge proximity or with links.
+     */
+    NAVIGATION_EDGE_FREE_COUNT: 32,
+    /**
+     * Number of active navigation obstacles in the {@link NavigationServer2D} and {@link NavigationServer3D}.
+     */
+    NAVIGATION_OBSTACLE_COUNT: 33,
+    /**
+     * Number of pipeline compilations that were triggered by the 2D canvas renderer.
+     */
+    PIPELINE_COMPILATIONS_CANVAS: 34,
+    /**
+     * Number of pipeline compilations that were triggered by loading meshes. These compilations will show up as longer loading times the first time a user runs the game and the pipeline is required.
+     */
+    PIPELINE_COMPILATIONS_MESH: 35,
+    /**
+     * Number of pipeline compilations that were triggered by building the surface cache before rendering the scene. These compilations will show up as a stutter when loading a scene the first time a user runs the game and the pipeline is required.
+     */
+    PIPELINE_COMPILATIONS_SURFACE: 36,
+    /**
+     * Number of pipeline compilations that were triggered while drawing the scene. These compilations will show up as stutters during gameplay the first time a user runs the game and the pipeline is required.
+     */
+    PIPELINE_COMPILATIONS_DRAW: 37,
+    /**
+     * Number of pipeline compilations that were triggered to optimize the current scene. These compilations are done in the background and should not cause any stutters whatsoever.
+     */
+    PIPELINE_COMPILATIONS_SPECIALIZATION: 38,
+    /**
+     * Number of active navigation maps in the {@link NavigationServer2D}. This also includes the empty default navigation maps created by {@link World2D} instances.
+     */
+    NAVIGATION_2D_ACTIVE_MAPS: 39,
+    /**
+     * Number of active navigation regions in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_REGION_COUNT: 40,
+    /**
+     * Number of active navigation agents processing avoidance in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_AGENT_COUNT: 41,
+    /**
+     * Number of active navigation links in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_LINK_COUNT: 42,
+    /**
+     * Number of navigation mesh polygons in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_POLYGON_COUNT: 43,
+    /**
+     * Number of navigation mesh polygon edges in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_EDGE_COUNT: 44,
+    /**
+     * Number of navigation mesh polygon edges that were merged due to edge key overlap in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_EDGE_MERGE_COUNT: 45,
+    /**
+     * Number of polygon edges that are considered connected by edge proximity {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_EDGE_CONNECTION_COUNT: 46,
+    /**
+     * Number of navigation mesh polygon edges that could not be merged in the {@link NavigationServer2D}. The edges still may be connected by edge proximity or with links.
+     */
+    NAVIGATION_2D_EDGE_FREE_COUNT: 47,
+    /**
+     * Number of active navigation obstacles in the {@link NavigationServer2D}.
+     */
+    NAVIGATION_2D_OBSTACLE_COUNT: 48,
+    /**
+     * Number of active navigation maps in the {@link NavigationServer3D}. This also includes the empty default navigation maps created by {@link World3D} instances.
+     */
+    NAVIGATION_3D_ACTIVE_MAPS: 49,
+    /**
+     * Number of active navigation regions in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_REGION_COUNT: 50,
+    /**
+     * Number of active navigation agents processing avoidance in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_AGENT_COUNT: 51,
+    /**
+     * Number of active navigation links in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_LINK_COUNT: 52,
+    /**
+     * Number of navigation mesh polygons in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_POLYGON_COUNT: 53,
+    /**
+     * Number of navigation mesh polygon edges in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_EDGE_COUNT: 54,
+    /**
+     * Number of navigation mesh polygon edges that were merged due to edge key overlap in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_EDGE_MERGE_COUNT: 55,
+    /**
+     * Number of polygon edges that are considered connected by edge proximity {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_EDGE_CONNECTION_COUNT: 56,
+    /**
+     * Number of navigation mesh polygon edges that could not be merged in the {@link NavigationServer3D}. The edges still may be connected by edge proximity or with links.
+     */
+    NAVIGATION_3D_EDGE_FREE_COUNT: 57,
+    /**
+     * Number of active navigation obstacles in the {@link NavigationServer3D}.
+     */
+    NAVIGATION_3D_OBSTACLE_COUNT: 58,
+    /**
+     * Represents the size of the {@link Monitor} enum.
+     */
+    MONITOR_MAX: 59,
+} as const;
+
+export type Monitor = (typeof Monitor)[keyof typeof Monitor];
+
+export const MonitorType = {
+    /**
+     * Monitor output is formatted as an integer value.
+     */
+    MONITOR_TYPE_QUANTITY: 0,
+    /**
+     * Monitor output is formatted as computer memory. Submitted values should represent a number of bytes.
+     */
+    MONITOR_TYPE_MEMORY: 1,
+    /**
+     * Monitor output is formatted as time in milliseconds. Submitted values should represent a time in seconds (not milliseconds).
+     */
+    MONITOR_TYPE_TIME: 2,
+    /**
+     * Monitor output is formatted as a percentage. Submitted values should represent a fractional value rather than the percentage directly, e.g. `0.5` for `50.00%`.
+     */
+    MONITOR_TYPE_PERCENTAGE: 3,
+} as const;
+
+export type MonitorType = (typeof MonitorType)[keyof typeof MonitorType];
+

package/gen/classes/PhysicalBone2D.ts

@@ -0,0 +1,59 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RigidBody2D } from './RigidBody2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+import type { Joint2D } from './Joint2D.ts';
+
+/**
+ * The {@link PhysicalBone2D} node is a {@link RigidBody2D}-based node that can be used to make {@link Bone2D}s in a {@link Skeleton2D} react to physics.
+ * **Note:** To make the {@link Bone2D}s visually follow the {@link PhysicalBone2D} node, use a {@link SkeletonModification2DPhysicalBones} modification on the {@link Skeleton2D} parent.
+ * **Note:** The {@link PhysicalBone2D} node does not automatically create a {@link Joint2D} node to keep {@link PhysicalBone2D} nodes together. They must be created manually. For most cases, you want to use a {@link PinJoint2D} node. The {@link PhysicalBone2D} node will automatically configure the {@link Joint2D} node once it's been added as a child node.
+ */
+export class PhysicalBone2D extends RigidBody2D {
+    constructor(name = 555) { super(name); }
+
+    /**
+     * Returns the first {@link Joint2D} child node, if one exists. This is mainly a helper function to make it easier to get the {@link Joint2D} that the {@link PhysicalBone2D} is autoconfiguring.
+     */
+    getJoint(): Joint2D { return _C(this, 5233) as Joint2D; }
+
+    /**
+     * Returns a boolean that indicates whether the {@link PhysicalBone2D} is running and simulating using the Godot 2D physics engine. When `true`, the PhysicalBone2D node is using physics.
+     */
+    isSimulatingPhysics(): boolean { return _C(this, 8316) as boolean; }
+
+    /**
+     * The {@link NodePath} to the {@link Bone2D} that this {@link PhysicalBone2D} should simulate.
+     */
+    get bone2dNodepath(): NodePath { return _C(this, 3956) as NodePath; }
+    set bone2dNodepath(v: NodePath) { _C(this, 10701, v); }
+
+    /**
+     * The index of the {@link Bone2D} that this {@link PhysicalBone2D} should simulate.
+     */
+    get bone2dIndex(): number { return _C(this, 3954) as number; }
+    set bone2dIndex(v: number) { _C(this, 10699, v); }
+
+    /**
+     * If `true`, the {@link PhysicalBone2D} will automatically configure the first {@link Joint2D} child node. The automatic configuration is limited to setting up the node properties and positioning the {@link Joint2D}.
+     */
+    get autoConfigureJoint(): boolean { return _C(this, 3831) as boolean; }
+    set autoConfigureJoint(v: boolean) { _C(this, 10569, v); }
+
+    /**
+     * If `true`, the {@link PhysicalBone2D} will start simulating using physics. If `false`, the {@link PhysicalBone2D} will follow the transform of the {@link Bone2D} node.
+     * **Note:** To have the {@link Bone2D}s visually follow the {@link PhysicalBone2D}, use a {@link SkeletonModification2DPhysicalBones} modification on the {@link Skeleton2D} node with the {@link Bone2D} nodes.
+     */
+    get simulatePhysics(): boolean { return _C(this, 6395) as boolean; }
+    set simulatePhysics(v: boolean) { _C(this, 12750, v); }
+
+    /**
+     * If `true`, the {@link PhysicalBone2D} will keep the transform of the bone it is bound to when simulating physics.
+     */
+    get followBoneWhenSimulating(): boolean { return _C(this, 4843) as boolean; }
+    set followBoneWhenSimulating(v: boolean) { _C(this, 11447, v); }
+
+    static readonly name = _R(555, PhysicalBone2D);
+}