@ringozz/godot 0.1.0

package/gen/classes/WorkerThreadPool.ts

@@ -0,0 +1,100 @@
+// 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 { Error } from '../global-enums.ts';
+import type { Callable } from '../heap-types/index.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 965));
+
+/**
+ * The {@link WorkerThreadPool} singleton allocates a set of {@link Thread}s (called worker threads) on project startup and provides methods for offloading tasks to them. This can be used for simple multithreading without having to create {@link Thread}s.
+ * Tasks hold the {@link Callable} to be run by the threads. {@link WorkerThreadPool} can be used to create regular tasks, which will be taken by one worker thread, or group tasks, which can be distributed between multiple worker threads. Group tasks execute the {@link Callable} multiple times, which makes them useful for iterating over a lot of elements, such as the enemies in an arena.
+ * Here's a sample on how to offload an expensive function to worker threads:
+ *
+ *
+ * ```gdscript
+ *
+ * var enemies = [] # An array to be filled with enemies.
+ *
+ * func process_enemy_ai(enemy_index):
+ * 	var processed_enemy = enemies[enemy_index]
+ * 	# Expensive logic...
+ *
+ * func _process(delta):
+ * 	var task_id = WorkerThreadPool.add_group_task(process_enemy_ai, enemies.size())
+ * 	# Other code...
+ * 	WorkerThreadPool.wait_for_group_task_completion(task_id)
+ * 	# Other code that depends on the enemy AI already being processed.
+ *
+ * ```
+ *
+ *
+ *
+ * The above code relies on the number of elements in the `enemies` array remaining constant during the multithreaded part.
+ * **Note:** Using this singleton could affect performance negatively if the task being distributed between threads is not computationally expensive.
+ */
+export class WorkerThreadPool extends GodotVar {
+
+    /**
+     * Adds `action` as a task to be executed by a worker thread. `highPriority` determines if the task has a high priority or a low priority (default). You can optionally provide a `description` to help with debugging.
+     * Returns a task ID that can be used by other methods.
+     * **Warning:** Every task must be waited for completion using {@link waitForTaskCompletion} or {@link waitForGroupTaskCompletion} at some point so that any allocated resources inside the task can be cleaned up.
+     */
+    static addTask(action: Callable, highPriority?: boolean /* = false */, description?: string /* = "" */): number { return _C($(), 1304, action, highPriority, description) as number; }
+
+    /**
+     * Returns `true` if the task with the given ID is completed.
+     * **Note:** You should only call this method between adding the task and awaiting its completion.
+     */
+    static isTaskCompleted(taskId: number /* int64 */): boolean { return _C($(), 8362, taskId) as boolean; }
+
+    /**
+     * Pauses the thread that calls this method until the task with the given ID is completed.
+     * Returns {@link OK} if the task could be successfully awaited.
+     * Returns {@link ERR_INVALID_PARAMETER} if a task with the passed ID does not exist (maybe because it was already awaited and disposed of).
+     * Returns {@link ERR_BUSY} if the call is made from another running task and, due to task scheduling, there's potential for deadlocking (e.g., the task to await may be at a lower level in the call stack and therefore can't progress). This is an advanced situation that should only matter when some tasks depend on others (in the current implementation, the tricky case is a task trying to wait on an older one).
+     */
+    static waitForTaskCompletion(taskId: number /* int64 */): Error { return _C($(), 14836, taskId) as Error; }
+
+    /**
+     * Returns the task ID of the current thread calling this method, or `-1` if the task is a group task, invalid or the current thread is not part of the thread pool (e.g. the main thread).
+     * Can be used by a task to get its own task ID, or to determine whether the current code is running inside the worker thread pool.
+     * **Note:** Group tasks have their own IDs, so this method will return `-1` for group tasks.
+     */
+    static getCallerTaskId(): number { return _C($(), 4056) as number; }
+
+    /**
+     * Adds `action` as a group task to be executed by the worker threads. The {@link Callable} will be called a number of times based on `elements`, with the first thread calling it with the value `0` as a parameter, and each consecutive execution incrementing this value by 1 until it reaches `element - 1`.
+     * The number of threads the task is distributed to is defined by `tasksNeeded`, where the default value `-1` means it is distributed to all worker threads. `highPriority` determines if the task has a high priority or a low priority (default). You can optionally provide a `description` to help with debugging.
+     * Returns a group task ID that can be used by other methods.
+     * **Warning:** Every task must be waited for completion using {@link waitForTaskCompletion} or {@link waitForGroupTaskCompletion} at some point so that any allocated resources inside the task can be cleaned up.
+     */
+    static addGroupTask(action: Callable, elements: number, tasksNeeded?: number /* = -1 */, highPriority?: boolean /* = false */, description?: string /* = "" */): number { return _C($(), 1224, action, elements, tasksNeeded, highPriority, description) as number; }
+
+    /**
+     * Returns `true` if the group task with the given ID is completed.
+     * **Note:** You should only call this method between adding the group task and awaiting its completion.
+     */
+    static isGroupTaskCompleted(groupId: number /* int64 */): boolean { return _C($(), 7979, groupId) as boolean; }
+
+    /**
+     * Returns how many times the {@link Callable} of the group task with the given ID has already been executed by the worker threads.
+     * **Note:** If a thread has started executing the {@link Callable} but is yet to finish, it won't be counted.
+     */
+    static getGroupProcessedElementCount(groupId: number /* int64 */): number { return _C($(), 4988, groupId) as number; }
+
+    /**
+     * Pauses the thread that calls this method until the group task with the given ID is completed.
+     */
+    static waitForGroupTaskCompletion(groupId: number /* int64 */): void { _C($(), 14835, groupId); }
+
+    /**
+     * Returns the task group ID of the current thread calling this method, or `-1` if invalid or the current thread is not part of a task group.
+     */
+    static getCallerGroupId(): number { return _C($(), 4055) as number; }
+
+    static readonly name = _R(965, WorkerThreadPool);
+}

package/gen/classes/World2D.ts

@@ -0,0 +1,36 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { PhysicsDirectSpaceState2D } from './PhysicsDirectSpaceState2D.ts';
+
+/**
+ * Class that has everything pertaining to a 2D world: A physics space, a canvas, and a sound space. 2D nodes register their resources into the current 2D world.
+ */
+export class World2D extends Resource {
+    constructor(name = 966) { super(name); }
+
+    /**
+     * The {@link RID} of this world's canvas resource. Used by the {@link RenderingServer} for 2D drawing.
+     */
+    get canvas(): RID { return _C(this, 4071) as RID; }
+
+    /**
+     * The {@link RID} of this world's navigation map. Used by the {@link NavigationServer2D}.
+     */
+    get navigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * The {@link RID} of this world's physics space resource. Used by the {@link PhysicsServer2D} for 2D physics, treating it as both a space and an area.
+     */
+    get space(): RID { return _C(this, 6463) as RID; }
+
+    /**
+     * Direct access to the world's physics 2D space state. Used for querying current and potential collisions. When using multi-threaded physics, access is limited to {@link Node.PhysicsProcess} in the main thread.
+     */
+    get directSpaceState(): PhysicsDirectSpaceState2D { return _C(this, 4505) as PhysicsDirectSpaceState2D; }
+
+    static readonly name = _R(966, World2D);
+}

package/gen/classes/World3D.ts

@@ -0,0 +1,56 @@
+// 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 { RID } from '../heap-types/index.ts';
+import type { CameraAttributes } from './CameraAttributes.ts';
+import type { Environment } from './Environment.ts';
+import type { PhysicsDirectSpaceState3D } from './PhysicsDirectSpaceState3D.ts';
+
+/**
+ * Class that has everything pertaining to a world: A physics space, a visual scenario, and a sound space. 3D nodes register their resources into the current 3D world.
+ */
+export class World3D extends Resource {
+    constructor(name = 967) { super(name); }
+
+    /**
+     * The World3D's {@link Environment}.
+     */
+    get environment(): Environment { return _C(this, 4678) as Environment; }
+    set environment(v: Environment) { _C(this, 11301, v); }
+
+    /**
+     * The World3D's fallback environment will be used if {@link environment} fails or is missing.
+     */
+    get fallbackEnvironment(): Environment { return _C(this, 4749) as Environment; }
+    set fallbackEnvironment(v: Environment) { _C(this, 11360, v); }
+
+    /**
+     * The default {@link CameraAttributes} resource to use if none set on the {@link Camera3D}.
+     */
+    get cameraAttributes(): CameraAttributes { return _C(this, 4063) as CameraAttributes; }
+    set cameraAttributes(v: CameraAttributes) { _C(this, 10785, v); }
+
+    /**
+     * The World3D's physics space.
+     */
+    get space(): RID { return _C(this, 6463) as RID; }
+
+    /**
+     * The {@link RID} of this world's navigation map. Used by the {@link NavigationServer3D}.
+     */
+    get navigationMap(): RID { return _C(this, 5612) as RID; }
+
+    /**
+     * The World3D's visual scenario.
+     */
+    get scenario(): RID { return _C(this, 6246) as RID; }
+
+    /**
+     * Direct access to the world's physics 3D space state. Used for querying current and potential collisions. When using multi-threaded physics, access is limited to {@link Node.PhysicsProcess} in the main thread.
+     */
+    get directSpaceState(): PhysicsDirectSpaceState3D { return _C(this, 4505) as PhysicsDirectSpaceState3D; }
+
+    static readonly name = _R(967, World3D);
+}

package/gen/classes/WorldBoundaryShape2D.ts

@@ -0,0 +1,28 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shape2D } from './Shape2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A 2D world boundary shape, intended for use in physics. {@link WorldBoundaryShape2D} works like an infinite straight line that forces all physics bodies to stay above it. The line's normal determines which direction is considered as "above" and in the editor, the smaller line over it represents this direction. It can for example be used for endless flat floors.
+ */
+export class WorldBoundaryShape2D extends Shape2D {
+    constructor(name = 968) { super(name); }
+
+    /**
+     * The line's normal, typically a unit vector. Its direction indicates the non-colliding half-plane. Can be of any length but zero. Defaults to {@link Vector2.UP}.
+     */
+    get normal(): Vector2 { return _C(this, 5675) as Vector2; }
+    set normal(v: Vector2) { _C(this, 12145, v); }
+
+    /**
+     * The distance from the origin to the line, expressed in terms of {@link normal} (according to its direction and magnitude). Actual absolute distance from the origin to the line can be calculated as `abs(distance) / normal.length()`.
+     * In the scalar equation of the line `ax + by = d`, this is `d`, while the `(a, b)` coordinates are represented by the {@link normal} property.
+     */
+    get distance(): number { return _C(this, 4523) as number; }
+    set distance(v: number) { _C(this, 11133, v); }
+
+    static readonly name = _R(968, WorldBoundaryShape2D);
+}

package/gen/classes/WorldBoundaryShape3D.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 { Shape3D } from './Shape3D.ts';
+import type { Plane } from '../value-types/index.ts';
+
+/**
+ * A 3D world boundary shape, intended for use in physics. {@link WorldBoundaryShape3D} works like an infinite plane that forces all physics bodies to stay above it. The {@link plane}'s normal determines which direction is considered as "above" and in the editor, the line over the plane represents this direction. It can for example be used for endless flat floors.
+ * **Note:** When the physics engine is set to **Jolt Physics** in the project settings ({@link ProjectSettings.physics/3d/physicsEngine}), {@link WorldBoundaryShape3D} has a finite size (centered at the shape's origin). It can be adjusted by changing {@link ProjectSettings.physics/joltPhysics3d/limits/worldBoundaryShapeSize}.
+ */
+export class WorldBoundaryShape3D extends Shape3D {
+    constructor(name = 969) { super(name); }
+
+    /**
+     * The {@link Plane} used by the {@link WorldBoundaryShape3D} for collision.
+     */
+    get plane(): Plane { return _C(this, 5918) as Plane; }
+    set plane(v: Plane) { _C(this, 12337, v); }
+
+    static readonly name = _R(969, WorldBoundaryShape3D);
+}

package/gen/classes/WorldEnvironment.ts

@@ -0,0 +1,37 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { CameraAttributes } from './CameraAttributes.ts';
+import type { Compositor } from './Compositor.ts';
+import type { Environment } from './Environment.ts';
+
+/**
+ * The {@link WorldEnvironment} node is used to configure the default {@link Environment} for the scene.
+ * The parameters defined in the {@link WorldEnvironment} can be overridden by an {@link Environment} node set on the current {@link Camera3D}. Additionally, only one {@link WorldEnvironment} may be instantiated in a given scene at a time.
+ * The {@link WorldEnvironment} allows the user to specify default lighting parameters (e.g. ambient lighting), various post-processing effects (e.g. SSAO, DOF, Tonemapping), and how to draw the background (e.g. solid color, skybox). Usually, these are added in order to improve the realism/color balance of the scene.
+ */
+export class WorldEnvironment extends Node {
+    constructor(name = 970) { super(name); }
+
+    /**
+     * The {@link Environment} resource used by this {@link WorldEnvironment}, defining the default properties.
+     */
+    get environment(): Environment { return _C(this, 4678) as Environment; }
+    set environment(v: Environment) { _C(this, 11301, v); }
+
+    /**
+     * The default {@link CameraAttributes} resource to use if none set on the {@link Camera3D}.
+     */
+    get cameraAttributes(): CameraAttributes { return _C(this, 4063) as CameraAttributes; }
+    set cameraAttributes(v: CameraAttributes) { _C(this, 10785, v); }
+
+    /**
+     * The default {@link Compositor} resource to use if none set on the {@link Camera3D}.
+     */
+    get compositor(): Compositor { return _C(this, 4250) as Compositor; }
+    set compositor(v: Compositor) { _C(this, 10931, v); }
+
+    static readonly name = _R(970, WorldEnvironment);
+}

package/gen/classes/X509Certificate.ts

@@ -0,0 +1,36 @@
+// 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 { Error } from '../global-enums.ts';
+
+/**
+ * The X509Certificate class represents an X509 certificate. Certificates can be loaded and saved like any other {@link Resource}.
+ * They can be used as the server certificate in {@link StreamPeerTLS.acceptStream} (along with the proper {@link CryptoKey}), and to specify the only certificate that should be accepted when connecting to a TLS server via {@link StreamPeerTLS.connectToStream}.
+ */
+export class X509Certificate extends Resource {
+    constructor(name = 971) { super(name); }
+
+    /**
+     * Saves a certificate to the given `path` (should be a "*.crt" file).
+     */
+    save(path: string): Error { return _C(this, 10195, path) as Error; }
+
+    /**
+     * Loads a certificate from `path` ("*.crt" file).
+     */
+    load(path: string): Error { return _C(this, 8665, path) as Error; }
+
+    /**
+     * Returns a string representation of the certificate, or an empty string if the certificate is invalid.
+     */
+    saveToString(): string { return _C(this, 10208) as string; }
+
+    /**
+     * Loads a certificate from the given `string`.
+     */
+    loadFromString(string: string): Error { return _C(this, 8679, string) as Error; }
+
+    static readonly name = _R(971, X509Certificate);
+}

package/gen/classes/XMLParser.ts

@@ -0,0 +1,154 @@
+// 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 { Error } from '../global-enums.ts';
+import type { PackedByteArray } from '../heap-types/index.ts';
+
+/**
+ * Provides a low-level interface for creating parsers for [XML](https://en.wikipedia.org/wiki/XML) files. This class can serve as base to make custom XML parsers.
+ * To parse XML, you must open a file with the {@link open} method or a buffer with the {@link openBuffer} method. Then, the {@link read} method must be called to parse the next nodes. Most of the methods take into consideration the currently parsed node.
+ * Here is an example of using {@link XMLParser} to parse an SVG file (which is based on XML), printing each element and its attributes as a dictionary:
+ *
+ *
+ * ```gdscript
+ *
+ * var parser = XMLParser.new()
+ * parser.open("path/to/file.svg")
+ * while parser.read() != ERR_FILE_EOF:
+ * 	if parser.get_node_type() == XMLParser.NODE_ELEMENT:
+ * 		var node_name = parser.get_node_name()
+ * 		var attributes_dict = {}
+ * 		for idx in range(parser.get_attribute_count()):
+ * 			attributes_dict[parser.get_attribute_name(idx)] = parser.get_attribute_value(idx)
+ * 		print("The ", node_name, " element has the following attributes: ", attributes_dict)
+ *
+ * ```
+ */
+export class XMLParser extends RefCounted {
+    constructor(name = 972) { super(name); }
+
+    /**
+     * Parses the next node in the file. This method returns an error code.
+     */
+    read(): Error { return _C(this, 9755) as Error; }
+
+    /**
+     * Returns the type of the current node. Compare with {@link NodeType} constants.
+     */
+    getNodeType(): NodeType { return _C(this, 5662) as NodeType; }
+
+    /**
+     * Returns the name of a node. This method will raise an error if the currently parsed node is a text node.
+     * **Note:** The content of a {@link NODE_CDATA} node and the comment string of a {@link NODE_COMMENT} node are also considered names.
+     */
+    getNodeName(): string { return _C(this, 5651) as string; }
+
+    /**
+     * Returns the contents of a text node. This method will raise an error if the current parsed node is of any other type.
+     */
+    getNodeData(): string { return _C(this, 5645) as string; }
+
+    /**
+     * Returns the byte offset of the currently parsed node since the beginning of the file or buffer. This is usually equivalent to the number of characters before the read position.
+     */
+    getNodeOffset(): number { return _C(this, 5652) as number; }
+
+    /**
+     * Returns the number of attributes in the currently parsed element.
+     * **Note:** If this method is used while the currently parsed node is not {@link NODE_ELEMENT} or {@link NODE_ELEMENT_END}, this count will not be updated and will still reflect the last element.
+     */
+    getAttributeCount(): number { return _C(this, 3813) as number; }
+
+    /**
+     * Returns the name of an attribute of the currently parsed element, specified by the `idx` index.
+     */
+    getAttributeName(idx: number): string { return _C(this, 3814, idx) as string; }
+
+    /**
+     * Returns the value of an attribute of the currently parsed element, specified by the `idx` index.
+     */
+    getAttributeValue(idx: number): string { return _C(this, 3815, idx) as string; }
+
+    /**
+     * Returns `true` if the currently parsed element has an attribute with the `name`.
+     */
+    hasAttribute(name: string): boolean { return _C(this, 7359, name) as boolean; }
+
+    /**
+     * Returns the value of an attribute of the currently parsed element, specified by its `name`. This method will raise an error if the element has no such attribute.
+     */
+    getNamedAttributeValue(name: string): string { return _C(this, 5604, name) as string; }
+
+    /**
+     * Returns the value of an attribute of the currently parsed element, specified by its `name`. This method will return an empty string if the element has no such attribute.
+     */
+    getNamedAttributeValueSafe(name: string): string { return _C(this, 5605, name) as string; }
+
+    /**
+     * Returns `true` if the currently parsed element is empty, e.g. `<element />`.
+     */
+    isEmpty(): boolean { return _C(this, 7931) as boolean; }
+
+    /**
+     * Returns the current line in the parsed file, counting from 0.
+     */
+    getCurrentLine(): number { return _C(this, 4355) as number; }
+
+    /**
+     * Skips the current section. If the currently parsed node contains more inner nodes, they will be ignored and the cursor will go to the closing of the current element.
+     */
+    skipSection(): void { _C(this, 13636); }
+
+    /**
+     * Moves the buffer cursor to a certain offset (since the beginning) and reads the next node there. This method returns an error code.
+     */
+    seek(position: number /* uint64 */): Error { return _C(this, 10343, position) as Error; }
+
+    /**
+     * Opens an XML `file` for parsing. This method returns an error code.
+     */
+    open(file: string): Error { return _C(this, 9189, file) as Error; }
+
+    /**
+     * Opens an XML raw `buffer` for parsing. This method returns an error code.
+     */
+    openBuffer(buffer: PackedByteArray): Error { return _C(this, 9190, buffer) as Error; }
+
+    static readonly name = _R(972, XMLParser);
+}
+
+export const NodeType = {
+    /**
+     * There's no node (no file or buffer opened).
+     */
+    NODE_NONE: 0,
+    /**
+     * An element node type, also known as a tag, e.g. `<title>`.
+     */
+    NODE_ELEMENT: 1,
+    /**
+     * An end of element node type, e.g. `</title>`.
+     */
+    NODE_ELEMENT_END: 2,
+    /**
+     * A text node type, i.e. text that is not inside an element. This includes whitespace.
+     */
+    NODE_TEXT: 3,
+    /**
+     * A comment node type, e.g. `<!--A comment-->`.
+     */
+    NODE_COMMENT: 4,
+    /**
+     * A node type for CDATA (Character Data) sections, e.g. `<![CDATA[CDATA section]]>`.
+     */
+    NODE_CDATA: 5,
+    /**
+     * An unknown node type.
+     */
+    NODE_UNKNOWN: 6,
+} as const;
+
+export type NodeType = (typeof NodeType)[keyof typeof NodeType];
+

package/gen/classes/XRAnchor3D.ts

@@ -0,0 +1,27 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { XRNode3D } from './XRNode3D.ts';
+import type { Plane, Vector3 } from '../value-types/index.ts';
+
+/**
+ * The {@link XRAnchor3D} point is an {@link XRNode3D} that maps a real world location identified by the AR platform to a position within the game world. For example, as long as plane detection in ARKit is on, ARKit will identify and update the position of planes (tables, floors, etc.) and create anchors for them.
+ * This node is mapped to one of the anchors through its unique ID. When you receive a signal that a new anchor is available, you should add this node to your scene for that anchor. You can predefine nodes and set the ID; the nodes will simply remain on `(0, 0, 0)` until a plane is recognized.
+ * Keep in mind that, as long as plane detection is enabled, the size, placing and orientation of an anchor will be updated as the detection logic learns more about the real world out there especially if only part of the surface is in view.
+ */
+export class XRAnchor3D extends XRNode3D {
+    constructor(name = 973) { super(name); }
+
+    /**
+     * Returns the estimated size of the plane that was detected. Say when the anchor relates to a table in the real world, this is the estimated size of the surface of that table.
+     */
+    getSize(): Vector3 { return _C(this, 6399) as Vector3; }
+
+    /**
+     * Returns a plane aligned with our anchor; handy for intersection testing.
+     */
+    getPlane(): Plane { return _C(this, 5918) as Plane; }
+
+    static readonly name = _R(973, XRAnchor3D);
+}

package/gen/classes/XRBodyModifier3D.ts

@@ -0,0 +1,70 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { SkeletonModifier3D } from './SkeletonModifier3D.ts';
+import type { StringName } from '../heap-types/index.ts';
+
+/**
+ * This node uses body tracking data from an {@link XRBodyTracker} to pose the skeleton of a body mesh.
+ * Positioning of the body is performed by creating an {@link XRNode3D} ancestor of the body mesh driven by the same {@link XRBodyTracker}.
+ * The body tracking position-data is scaled by {@link Skeleton3D.motionScale} when applied to the skeleton, which can be used to adjust the tracked body to match the scale of the body model.
+ */
+export class XRBodyModifier3D extends SkeletonModifier3D {
+    constructor(name = 974) { super(name); }
+
+    /**
+     * The name of the {@link XRBodyTracker} registered with {@link XRServer} to obtain the body tracking data from.
+     */
+    get bodyTracker(): StringName { return _C(this, 3950) as StringName; }
+    set bodyTracker(v: StringName) { _C(this, 10695, v); }
+
+    /**
+     * Specifies the body parts to update.
+     */
+    get bodyUpdate(): BodyUpdate { return _C(this, 3952) as BodyUpdate; }
+    set bodyUpdate(v: BodyUpdate) { _C(this, 10697, v); }
+
+    /**
+     * Specifies the type of updates to perform on the bones.
+     */
+    get boneUpdate(): BoneUpdate { return _C(this, 3982) as BoneUpdate; }
+    set boneUpdate(v: BoneUpdate) { _C(this, 10720, v); }
+
+    static readonly name = _R(974, XRBodyModifier3D);
+}
+
+export const BodyUpdate = {
+    /**
+     * The skeleton's upper body joints are updated.
+     */
+    BODY_UPDATE_UPPER_BODY: 1,
+    /**
+     * The skeleton's lower body joints are updated.
+     */
+    BODY_UPDATE_LOWER_BODY: 2,
+    /**
+     * The skeleton's hand joints are updated.
+     */
+    BODY_UPDATE_HANDS: 4,
+} as const;
+
+export type BodyUpdate = (typeof BodyUpdate)[keyof typeof BodyUpdate];
+
+export const BoneUpdate = {
+    /**
+     * The skeleton's bones are fully updated (both position and rotation) to match the tracked bones.
+     */
+    BONE_UPDATE_FULL: 0,
+    /**
+     * The skeleton's bones are only rotated to align with the tracked bones, preserving bone length.
+     */
+    BONE_UPDATE_ROTATION_ONLY: 1,
+    /**
+     * Represents the size of the {@link BoneUpdate} enum.
+     */
+    BONE_UPDATE_MAX: 2,
+} as const;
+
+export type BoneUpdate = (typeof BoneUpdate)[keyof typeof BoneUpdate];
+