@ringozz/godot 0.1.0

package/gen/classes/OpenXRDpadBindingModifier.ts

@@ -0,0 +1,73 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRIPBindingModifier } from './OpenXRIPBindingModifier.ts';
+import type { OpenXRActionSet } from './OpenXRActionSet.ts';
+import type { OpenXRHapticBase } from './OpenXRHapticBase.ts';
+
+/**
+ * The DPad binding modifier converts an axis input to a dpad output, emulating a DPad. New input paths for each dpad direction will be added to the interaction profile. When bound to actions the DPad emulation will be activated. You should **not** combine dpad inputs with normal inputs in the same action set for the same control, this will result in an error being returned when suggested bindings are submitted to OpenXR.
+ * See [XR_EXT_dpad_binding](https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XR_EXT_dpad_binding) for in-depth details.
+ * **Note:** If the DPad binding modifier extension is enabled, all dpad binding paths will be available in the action map. Adding the modifier to an interaction profile allows you to further customize the behavior.
+ */
+export class OpenXRDpadBindingModifier extends OpenXRIPBindingModifier {
+    constructor(name = 485) { super(name); }
+
+    /**
+     * Action set for which this dpad binding modifier is active.
+     */
+    get actionSet(): OpenXRActionSet { return _C(this, 3685) as OpenXRActionSet; }
+    set actionSet(v: OpenXRActionSet) { _C(this, 10420, v); }
+
+    /**
+     * Input path for this dpad binding modifier.
+     */
+    get inputPath(): string { return _C(this, 5117) as string; }
+    set inputPath(v: string) { _C(this, 11717, v); }
+
+    /**
+     * When our input value is equal or larger than this value, our dpad in that direction becomes `true`. It stays `true` until it falls under the {@link thresholdReleased} value.
+     */
+    get threshold(): number { return _C(this, 6775) as number; }
+    set threshold(v: number) { _C(this, 13059, v); }
+
+    /**
+     * When our input value falls below this, our output becomes `false`.
+     */
+    get thresholdReleased(): number { return _C(this, 6777) as number; }
+    set thresholdReleased(v: number) { _C(this, 13061, v); }
+
+    /**
+     * Center region in which our center position of our dpad return `true`.
+     */
+    get centerRegion(): number { return _C(this, 4131) as number; }
+    set centerRegion(v: number) { _C(this, 10843, v); }
+
+    /**
+     * The angle of each wedge that identifies the 4 directions of the emulated dpad.
+     */
+    get wedgeAngle(): number { return _C(this, 7143) as number; }
+    set wedgeAngle(v: number) { _C(this, 13367, v); }
+
+    /**
+     * If `false`, when the joystick enters a new dpad zone this becomes `true`.
+     * If `true`, when the joystick remains in active dpad zone, this remains `true` even if we overlap with another zone.
+     */
+    get isSticky(): boolean { return _C(this, 5174) as boolean; }
+    set isSticky(v: boolean) { _C(this, 11756, v); }
+
+    /**
+     * Haptic pulse to emit when the user presses the input.
+     */
+    get onHaptic(): OpenXRHapticBase { return _C(this, 5716) as OpenXRHapticBase; }
+    set onHaptic(v: OpenXRHapticBase) { _C(this, 12183, v); }
+
+    /**
+     * Haptic pulse to emit when the user releases the input.
+     */
+    get offHaptic(): OpenXRHapticBase { return _C(this, 5701) as OpenXRHapticBase; }
+    set offHaptic(v: OpenXRHapticBase) { _C(this, 12168, v); }
+
+    static readonly name = _R(485, OpenXRDpadBindingModifier);
+}

package/gen/classes/OpenXRExtensionWrapper.ts

@@ -0,0 +1,33 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, GodotDictionary, PackedStringArray, RID } from '../heap-types/index.ts';
+import type { OpenXRAPIExtension } from './OpenXRAPIExtension.ts';
+import type { OpenXRInteractionProfileMetadata } from './OpenXRInteractionProfileMetadata.ts';
+
+/**
+ * {@link OpenXRExtensionWrapper} allows implementing OpenXR extensions with GDExtension. The extension should be registered with {@link registerExtensionWrapper}.
+ * When {@link OpenXRInterface} is initialized as the primary interface and any {@link Viewport} has {@link Viewport.useXr} set to `true`, OpenXR will become involved in Godot's rendering process. If {@link ProjectSettings.rendering/driver/threads/threadModel} is set to "Separate", Godot's renderer will run on its own thread, and special care must be taken in all {@link OpenXRExtensionWrapper}s in order to prevent crashes or unexpected behavior. Some virtual methods will be called on the render thread, and any data they access should not be directly written to on the main thread. This is to prevent two potential issues:
+ * 1. Changes intended for the next frame, taking effect on the current frame. When using the "Separate" thread model, the main thread will immediately start working on the next frame while the render thread may still be rendering the current frame. If the main thread changes anything used by the render thread directly, the change could end up being used one frame earlier than intended.
+ * 2. Reading and writing to the same data at the same time from different threads can lead to the render thread using data in an invalid state.
+ * In most cases, the solution is to use {@link RenderingServer.callOnRenderThread} to schedule {@link Callable}s to write to any data used on the render thread. When using the "Separate" thread model, these {@link Callable}s will run after the renderer finishes the current frame and before it starts rendering the next frame. When not using this mode, they'll run immediately, so it's recommended to always use {@link RenderingServer.callOnRenderThread} in these cases, which will allow your code to do the right thing regardless of the thread model.
+ * Any virtual methods that run on the render thread will be noted below.
+ */
+export class OpenXRExtensionWrapper extends Object {
+    constructor(name = 486) { super(name); }
+
+    /**
+     * Returns the created {@link OpenXRAPIExtension}, which can be used to access the OpenXR API.
+     */
+    getOpenxrApi(): OpenXRAPIExtension { return _C(this, 5725) as OpenXRAPIExtension; }
+
+    /**
+     * Registers the extension. This should happen at core module initialization level.
+     * **Note:** This cannot be called once OpenXR has been initialized.
+     */
+    registerExtensionWrapper(): void { _C(this, 9843); }
+
+    static readonly name = _R(486, OpenXRExtensionWrapper);
+}

package/gen/classes/OpenXRExtensionWrapperExtension.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+
+/**
+ * {@link OpenXRExtensionWrapperExtension} allows implementing OpenXR extensions with GDExtension. The extension should be registered with {@link OpenXRExtensionWrapper.registerExtensionWrapper}.
+ */
+export class OpenXRExtensionWrapperExtension extends OpenXRExtensionWrapper {
+    constructor(name = 487) { super(name); }
+
+    static readonly name = _R(487, OpenXRExtensionWrapperExtension);
+}

package/gen/classes/OpenXRFrameSynthesisExtension.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 { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+
+/**
+ * This class implements the [OpenXR Frame synthesis extension](https://registry.khronos.org/OpenXR/specs/1.1/html/xrspec.html#XR_EXT_frame_synthesis). When enabled in the project settings and supported by the XR runtime in use, frame synthesis uses advanced reprojection techniques to inject additional frames so that your XR experience hits the full frame rate of the device.
+ */
+export class OpenXRFrameSynthesisExtension extends OpenXRExtensionWrapper {
+    constructor(name = 488) { super(name); }
+
+    /**
+     * Returns `true` if frame synthesis is enabled in the project settings and the current XR runtime supports frame synthesis. The value returned will only be valid once OpenXR has been initialized.
+     */
+    isAvailable(): boolean { return _C(this, 7780) as boolean; }
+
+    /**
+     * Queues the next frame to be skipped when supplying motion vector and depth data. Call this after teleporting your player or a similar action has moved the player to prevent incorrect reprojection results due to this movement.
+     */
+    skipNextFrame(): void { _C(this, 13635); }
+
+    /**
+     * Enable frame synthesis. When `true` motion vector and depth data is provided to the XR runtime.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * If `true` this informs the XR runtime we will be providing frames at a greatly reduced rate. Enable this when you expect your application to run at low framerates and wish to inject multiple reprojected frames.
+     */
+    get relaxFrameInterval(): boolean { return _C(this, 6120) as boolean; }
+    set relaxFrameInterval(v: boolean) { _C(this, 12513, v); }
+
+    static readonly name = _R(488, OpenXRFrameSynthesisExtension);
+}

package/gen/classes/OpenXRFutureExtension.ts

@@ -0,0 +1,43 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRExtensionWrapper } from './OpenXRExtensionWrapper.ts';
+import type { Callable } from '../heap-types/index.ts';
+import type { OpenXRFutureResult } from './OpenXRFutureResult.ts';
+
+/**
+ * This is a support extension in OpenXR that allows other OpenXR extensions to start asynchronous functions and get a callback after this function finishes. It is not intended for consumption within GDScript but can be accessed from GDExtension.
+ */
+export class OpenXRFutureExtension extends OpenXRExtensionWrapper {
+    constructor(name = 489) { super(name); }
+
+    /**
+     * Returns `true` if futures are available in the OpenXR runtime used. This function will only return a usable result after OpenXR has been initialized.
+     */
+    isActive(): boolean { return _C(this, 7746) as boolean; }
+
+    /**
+     * Register an OpenXR Future object so we monitor for completion. `future` must be an `XrFutureEXT` value previously returned by an API that started an asynchronous function.
+     * You can optionally specify `onSuccess`, it will be invoked on successful completion of the future.
+     * Or you can use the returned {@link OpenXRFutureResult} object to `await` its {@link OpenXRFutureResult.completed} signal.
+     *
+     * ```text
+     *
+     * var future_result = OpenXRFutureExtension.register_future(future)
+     * await future_result.completed
+     * if future_result.get_status() == OpenXRFutureResult.RESULT_FINISHED:
+     * 	# Handle your success
+     * 	pass
+     *
+     * ```
+     */
+    registerFuture(future: number /* uint64 */, onSuccess?: Callable /* = Callable() */): OpenXRFutureResult { return _C(this, 9845, future, onSuccess) as OpenXRFutureResult; }
+
+    /**
+     * Cancels an in-progress future. `future` must be an `XrFutureEXT` value previously returned by an API that started an asynchronous function.
+     */
+    cancelFuture(future: number /* uint64 */): void { _C(this, 2022, future); }
+
+    static readonly name = _R(489, OpenXRFutureExtension);
+}

package/gen/classes/OpenXRFutureResult.ts

@@ -0,0 +1,64 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Signal, Variant } from '../heap-types/index.ts';
+
+/**
+ * Result object tracking the asynchronous result of an OpenXR Future object, you can use this object to track the result status.
+ */
+export class OpenXRFutureResult extends RefCounted {
+
+    /**
+     * Returns the status of this result.
+     */
+    getStatus(): ResultStatus { return _C(this, 6542) as ResultStatus; }
+
+    /**
+     * Return the `XrFutureEXT` value this result relates to.
+     */
+    getFuture(): number { return _C(this, 4913) as number; }
+
+    /**
+     * Cancel this future, this will interrupt and stop the asynchronous function.
+     */
+    cancelFuture(): void { _C(this, 2022); }
+
+    /**
+     * Stores the result value we expose to the user.
+     * **Note:** This method should only be called by an OpenXR extension that implements an asynchronous function.
+     */
+    setResultValue(resultValue: Variant): void { _C(this, 12548, resultValue); }
+
+    /**
+     * Returns the result value of our asynchronous function (if set by the extension). The type of this result value depends on the function being called. Consult the documentation of the relevant function.
+     */
+    getResultValue(): Variant { return _C(this, 6172) as Variant; }
+
+    /**
+     * Emitted when the asynchronous function is finished or has been cancelled.
+     */
+    get completed(): Signal<(result: OpenXRFutureResult) => void> { return _G(this, 2400) as Signal<(result: OpenXRFutureResult) => void>; }
+    set completed(v: ((result: OpenXRFutureResult) => void) | null) { _G(this, 2400, v); }
+
+    static readonly name = _R(490, OpenXRFutureResult);
+}
+
+export const ResultStatus = {
+    /**
+     * The asynchronous function is running.
+     */
+    RESULT_RUNNING: 0,
+    /**
+     * The asynchronous function has finished.
+     */
+    RESULT_FINISHED: 1,
+    /**
+     * The asynchronous function has been cancelled.
+     */
+    RESULT_CANCELLED: 2,
+} as const;
+
+export type ResultStatus = (typeof ResultStatus)[keyof typeof ResultStatus];
+

package/gen/classes/OpenXRHand.ts

@@ -0,0 +1,117 @@
+// 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 { NodePath } from '../heap-types/index.ts';
+
+/**
+ * This node enables OpenXR's hand tracking functionality. The node should be a child node of an {@link XROrigin3D} node, tracking will update its position to the player's tracked hand Palm joint location (the center of the middle finger's metacarpal bone). This node also updates the skeleton of a properly skinned hand or avatar model.
+ * If the skeleton is a hand (one of the hand bones is the root node of the skeleton), then the skeleton will be placed relative to the hand palm location and the hand mesh and skeleton should be children of the OpenXRHand node.
+ * If the hand bones are part of a full skeleton, then the root of the hand will keep its location with the assumption that IK is used to position the hand and arm.
+ * By default the skeleton hand bones are repositioned to match the size of the tracked hand. To preserve the modeled bone sizes change {@link boneUpdate} to apply rotation only.
+ */
+export class OpenXRHand extends Node3D {
+    constructor(name = 491) { super(name); }
+
+    /**
+     * Specifies whether this node tracks the left or right hand of the player.
+     */
+    get hand(): Hands { return _C(this, 5006) as Hands; }
+    set hand(v: Hands) { _C(this, 11590, v); }
+
+    /**
+     * Set the motion range (if supported) limiting the hand motion.
+     */
+    get motionRange(): MotionRange { return _C(this, 5582) as MotionRange; }
+    set motionRange(v: MotionRange) { _C(this, 12089, v); }
+
+    /**
+     * Set a {@link Skeleton3D} node for which the pose positions will be updated.
+     */
+    get handSkeleton(): NodePath { return _C(this, 5014) as NodePath; }
+    set handSkeleton(v: NodePath) { _C(this, 11596, v); }
+
+    /**
+     * Set the type of skeleton rig the {@link handSkeleton} is compliant with.
+     */
+    get skeletonRig(): SkeletonRig { return _C(this, 6409) as SkeletonRig; }
+    set skeletonRig(v: SkeletonRig) { _C(this, 12760, v); }
+
+    /**
+     * Specify the type of updates to perform on the bone.
+     */
+    get boneUpdate(): BoneUpdate { return _C(this, 3982) as BoneUpdate; }
+    set boneUpdate(v: BoneUpdate) { _C(this, 10720, v); }
+
+    static readonly name = _R(491, OpenXRHand);
+}
+
+export const Hands = {
+    /**
+     * Tracking the player's left hand.
+     */
+    HAND_LEFT: 0,
+    /**
+     * Tracking the player's right hand.
+     */
+    HAND_RIGHT: 1,
+    /**
+     * Maximum supported hands.
+     */
+    HAND_MAX: 2,
+} as const;
+
+export type Hands = (typeof Hands)[keyof typeof Hands];
+
+export const MotionRange = {
+    /**
+     * When player grips, hand skeleton will form a full fist.
+     */
+    MOTION_RANGE_UNOBSTRUCTED: 0,
+    /**
+     * When player grips, hand skeleton conforms to the controller the player is holding.
+     */
+    MOTION_RANGE_CONFORM_TO_CONTROLLER: 1,
+    /**
+     * Maximum supported motion ranges.
+     */
+    MOTION_RANGE_MAX: 2,
+} as const;
+
+export type MotionRange = (typeof MotionRange)[keyof typeof MotionRange];
+
+export const SkeletonRig = {
+    /**
+     * An OpenXR compliant skeleton.
+     */
+    SKELETON_RIG_OPENXR: 0,
+    /**
+     * A {@link SkeletonProfileHumanoid} compliant skeleton.
+     */
+    SKELETON_RIG_HUMANOID: 1,
+    /**
+     * Maximum supported hands.
+     */
+    SKELETON_RIG_MAX: 2,
+} as const;
+
+export type SkeletonRig = (typeof SkeletonRig)[keyof typeof SkeletonRig];
+
+export const BoneUpdate = {
+    /**
+     * The skeletons bones are fully updated (both position and rotation) to match the tracked bones.
+     */
+    BONE_UPDATE_FULL: 0,
+    /**
+     * The skeletons bones are only rotated to align with the tracked bones, preserving bone length.
+     */
+    BONE_UPDATE_ROTATION_ONLY: 1,
+    /**
+     * Maximum supported bone update mode.
+     */
+    BONE_UPDATE_MAX: 2,
+} as const;
+
+export type BoneUpdate = (typeof BoneUpdate)[keyof typeof BoneUpdate];
+

package/gen/classes/OpenXRHapticBase.ts

@@ -0,0 +1,13 @@
+// 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';
+
+/**
+ * This is a base class for haptic feedback resources.
+ */
+export class OpenXRHapticBase extends Resource {
+
+    static readonly name = _R(492, OpenXRHapticBase);
+}

package/gen/classes/OpenXRHapticVibration.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRHapticBase } from './OpenXRHapticBase.ts';
+
+/**
+ * This haptic feedback resource makes it possible to define a vibration based haptic feedback pulse that can be triggered through actions in the OpenXR action map.
+ */
+export class OpenXRHapticVibration extends OpenXRHapticBase {
+    constructor(name = 493) { super(name); }
+
+    /**
+     * The duration of the pulse in nanoseconds. Use `-1` for a minimum duration pulse for the current XR runtime.
+     */
+    get duration(): number { return _C(this, 4590) as number; }
+    set duration(v: number) { _C(this, 11204, v); }
+
+    /**
+     * The frequency of the pulse in Hz. `0.0` will let the XR runtime chose an optimal frequency for the device used.
+     */
+    get frequency(): number { return _C(this, 4896) as number; }
+    set frequency(v: number) { _C(this, 11489, v); }
+
+    /**
+     * The amplitude of the pulse between `0.0` and `1.0`.
+     */
+    get amplitude(): number { return _C(this, 3743) as number; }
+    set amplitude(v: number) { _C(this, 10484, v); }
+
+    static readonly name = _R(493, OpenXRHapticVibration);
+}

package/gen/classes/OpenXRIPBinding.ts

@@ -0,0 +1,72 @@
+// 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, PackedStringArray } from '../heap-types/index.ts';
+import type { OpenXRAction } from './OpenXRAction.ts';
+import type { OpenXRActionBindingModifier } from './OpenXRActionBindingModifier.ts';
+
+/**
+ * This binding resource binds an {@link OpenXRAction} to an input or output. As most controllers have left hand and right versions that are handled by the same interaction profile we can specify multiple bindings. For instance an action "Fire" could be bound to both "/user/hand/left/input/trigger" and "/user/hand/right/input/trigger". This would require two binding entries.
+ */
+export class OpenXRIPBinding extends Resource {
+    constructor(name = 494) { super(name); }
+
+    /**
+     * Get the number of binding modifiers for this binding.
+     */
+    getBindingModifierCount(): number { return _C(this, 3922) as number; }
+
+    /**
+     * Get the {@link OpenXRBindingModifier} at this index.
+     */
+    getBindingModifier(index: number): OpenXRActionBindingModifier { return _C(this, 3921, index) as OpenXRActionBindingModifier; }
+
+    /**
+     * Get the number of input/output paths in this binding.
+     */
+    getPathCount(): number { return _C(this, 5843) as number; }
+
+    /**
+     * Returns `true` if this input/output path is part of this binding.
+     */
+    hasPath(path: string): boolean { return _C(this, 7428, path) as boolean; }
+
+    /**
+     * Add an input/output path to this binding.
+     */
+    addPath(path: string): void { _C(this, 1266, path); }
+
+    /**
+     * Removes this input/output path from this binding.
+     */
+    removePath(path: string): void { _C(this, 9943, path); }
+
+    /**
+     * {@link OpenXRAction} that is bound to {@link bindingPath}.
+     */
+    get action(): OpenXRAction { return _C(this, 3676) as OpenXRAction; }
+    set action(v: OpenXRAction) { _C(this, 10415, v); }
+
+    /**
+     * Binding path that defines the input or output bound to {@link action}.
+     * **Note:** Binding paths are suggestions, an XR runtime may choose to bind the action to a different input or output emulating this input or output.
+     */
+    get bindingPath(): string { return _C(this, 3924) as string; }
+    set bindingPath(v: string) { _C(this, 10668, v); }
+
+    /**
+     * Binding modifiers for this binding.
+     */
+    get bindingModifiers(): GodotArray { return _C(this, 3923) as GodotArray; }
+    set bindingModifiers(v: GodotArray) { _C(this, 10667, v); }
+
+    /**
+     * Paths that define the inputs or outputs bound on the device.
+     */
+    get paths(): PackedStringArray { return _C(this, 5866) as PackedStringArray; }
+    set paths(v: PackedStringArray) { _C(this, 12298, v); }
+
+    static readonly name = _R(494, OpenXRIPBinding);
+}

package/gen/classes/OpenXRIPBindingModifier.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRBindingModifier } from './OpenXRBindingModifier.ts';
+
+/**
+ * Binding modifier that applies directly on an interaction profile.
+ */
+export class OpenXRIPBindingModifier extends OpenXRBindingModifier {
+    constructor(name = 495) { super(name); }
+
+    static readonly name = _R(495, OpenXRIPBindingModifier);
+}

package/gen/classes/OpenXRInteractionProfile.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 { GodotArray } from '../heap-types/index.ts';
+import type { OpenXRIPBinding } from './OpenXRIPBinding.ts';
+import type { OpenXRIPBindingModifier } from './OpenXRIPBindingModifier.ts';
+
+/**
+ * This object stores suggested bindings for an interaction profile. Interaction profiles define the metadata for a tracked XR device such as an XR controller.
+ * For more information see the [interaction profiles info in the OpenXR specification](https://www.khronos.org/registry/OpenXR/specs/1.0/html/xrspec.html#semantic-path-interaction-profiles).
+ */
+export class OpenXRInteractionProfile extends Resource {
+    constructor(name = 496) { super(name); }
+
+    /**
+     * Get the number of bindings in this interaction profile.
+     */
+    getBindingCount(): number { return _C(this, 3920) as number; }
+
+    /**
+     * Retrieve the binding at this index.
+     */
+    getBinding(index: number): OpenXRIPBinding { return _C(this, 3919, index) as OpenXRIPBinding; }
+
+    /**
+     * Get the number of binding modifiers in this interaction profile.
+     */
+    getBindingModifierCount(): number { return _C(this, 3922) as number; }
+
+    /**
+     * Get the {@link OpenXRBindingModifier} at this index.
+     */
+    getBindingModifier(index: number): OpenXRIPBindingModifier { return _C(this, 3921, index) as OpenXRIPBindingModifier; }
+
+    /**
+     * The interaction profile path identifying the XR device.
+     */
+    get interactionProfilePath(): string { return _C(this, 5145) as string; }
+    set interactionProfilePath(v: string) { _C(this, 11734, v); }
+
+    /**
+     * Action bindings for this interaction profile.
+     */
+    get bindings(): GodotArray { return _C(this, 3925) as GodotArray; }
+    set bindings(v: GodotArray) { _C(this, 10669, v); }
+
+    /**
+     * Binding modifiers for this interaction profile.
+     */
+    get bindingModifiers(): GodotArray { return _C(this, 3923) as GodotArray; }
+    set bindingModifiers(v: GodotArray) { _C(this, 10667, v); }
+
+    static readonly name = _R(496, OpenXRInteractionProfile);
+}

package/gen/classes/OpenXRInteractionProfileMetadata.ts

@@ -0,0 +1,43 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { ActionType } from './OpenXRAction.ts';
+
+/**
+ * This class allows OpenXR core and extensions to register metadata relating to supported interaction devices such as controllers, trackers, haptic devices, etc. It is primarily used by the action map editor and to sanitize any action map by removing extension-dependent entries when applicable.
+ */
+export class OpenXRInteractionProfileMetadata extends Object {
+    constructor(name = 497) { super(name); }
+
+    /**
+     * Allows for renaming old interaction profile paths to new paths in order to load and process older action maps.
+     */
+    registerProfileRename(oldName: string, newName: string): void { _C(this, 9851, oldName, newName); }
+
+    /**
+     * Allows for renaming old input/output paths to new paths in order to load and process older action maps.
+     */
+    registerPathRename(oldName: string, newName: string): void { _C(this, 9850, oldName, newName); }
+
+    /**
+     * Registers a top level path to which profiles can be bound. For instance `/user/hand/left` refers to the bind point for the player's left hand. Extensions can register additional top level paths, for instance a haptic vest extension might register `/user/body/vest`.
+     * `displayName` is the name shown to the user. `openxrPath` is the top level path being registered. `openxrExtensionNames` is optional and ensures the top level path is only used if the specified extension is available/enabled.
+     * When a top level path ends up being bound by OpenXR, an {@link XRPositionalTracker} is instantiated to manage the state of the device.
+     */
+    registerTopLevelPath(displayName: string, openxrPath: string, openxrExtensionNames: string): void { _C(this, 9861, displayName, openxrPath, openxrExtensionNames); }
+
+    /**
+     * Registers an interaction profile using its OpenXR designation (e.g. `/interaction_profiles/khr/simple_controller` is the profile for OpenXR's simple controller profile).
+     * `displayName` is the description shown to the user. `openxrPath` is the interaction profile path being registered. `openxrExtensionNames` optionally restricts this profile to the given extension being enabled/available. If the extension is not available, the profile and all related entries used in an action map are filtered out.
+     */
+    registerInteractionProfile(displayName: string, openxrPath: string, openxrExtensionNames: string): void { _C(this, 9847, displayName, openxrPath, openxrExtensionNames); }
+
+    /**
+     * Registers an input/output path for the given `interactionProfile`. The profile should previously have been registered using {@link registerInteractionProfile}. `displayName` is the description shown to the user. `toplevelPath` specifies the bind path this input/output can be bound to (e.g. `/user/hand/left` or `/user/hand/right`). `openxrPath` is the action input/output being registered (e.g. `/user/hand/left/input/aim/pose`). `openxrExtensionNames` restricts this input/output to an enabled/available extension, this doesn't need to repeat the extension on the profile but relates to overlapping extension (e.g. `XR_EXT_palm_pose` that introduces `…/input/palm_ext/pose` input paths). `actionType` defines the type of input or output provided by OpenXR.
+     */
+    registerIoPath(interactionProfile: string, displayName: string, toplevelPath: string, openxrPath: string, openxrExtensionNames: string, actionType: ActionType): void { _C(this, 9848, interactionProfile, displayName, toplevelPath, openxrPath, openxrExtensionNames, actionType); }
+
+    static readonly name = _R(497, OpenXRInteractionProfileMetadata);
+}