@ringozz/godot 0.1.0

package/gen/classes/OpenXRInterface.ts

@@ -0,0 +1,550 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { XRInterface } from './XRInterface.ts';
+import type { GodotArray, Signal } from '../heap-types/index.ts';
+import type { Quaternion, Vector3 } from '../value-types/index.ts';
+
+/**
+ * The OpenXR interface allows Godot to interact with OpenXR runtimes and make it possible to create XR experiences and games.
+ * Due to the needs of OpenXR this interface works slightly different than other plugin based XR interfaces. It needs to be initialized when Godot starts. You need to enable OpenXR, settings for this can be found in your games project settings under the XR heading. You do need to mark a viewport for use with XR in order for Godot to know which render result should be output to the headset.
+ */
+export class OpenXRInterface extends XRInterface {
+    constructor(name = 498) { super(name); }
+
+    /**
+     * Returns the current state of our OpenXR session.
+     */
+    getSessionState(): SessionState { return _C(this, 6348) as SessionState; }
+
+    /**
+     * Returns `true` if OpenXR's user presence extension is supported and enabled.
+     * **Note:** This only returns a valid value after OpenXR has been initialized.
+     */
+    isUserPresenceSupported(): boolean { return _C(this, 8389) as boolean; }
+
+    /**
+     * Returns `true` if system has detected the presence of a user in the XR experience.
+     */
+    isUserPresent(): boolean { return _C(this, 8390) as boolean; }
+
+    /**
+     * Returns `true` if OpenXR's foveation extension is supported. The interface must be initialized before this returns a valid value.
+     * **Note:** When using the Vulkan rendering driver, {@link Viewport.vrsMode} must be set to {@link Viewport.VRS_XR} to support foveation.
+     */
+    isFoveationSupported(): boolean { return _C(this, 7971) as boolean; }
+
+    /**
+     * Returns `true` if the given action set is active.
+     */
+    isActionSetActive(name: string): boolean { return _C(this, 7744, name) as boolean; }
+
+    /**
+     * Sets the given action set as active or inactive.
+     */
+    setActionSetActive(name: string, active: boolean): void { _C(this, 10421, name, active); }
+
+    /**
+     * Returns a list of action sets registered with Godot (loaded from the action map at runtime).
+     */
+    getActionSets(): GodotArray { return _C(this, 3687) as GodotArray; }
+
+    /**
+     * Returns a list of display refresh rates supported by the current HMD. Only returned if this feature is supported by the OpenXR runtime and after the interface has been initialized.
+     */
+    getAvailableDisplayRefreshRates(): GodotArray { return _C(this, 3850) as GodotArray; }
+
+    /**
+     * If handtracking is enabled and motion range is supported, sets the currently configured motion range for `hand` to `motionRange`.
+     */
+    setMotionRange(hand: Hand, motionRange: HandMotionRange): void { _C(this, 12089, hand, motionRange); }
+
+    /**
+     * If handtracking is enabled and motion range is supported, gets the currently configured motion range for `hand`.
+     */
+    getMotionRange(hand: Hand): HandMotionRange { return _C(this, 5582, hand) as HandMotionRange; }
+
+    /**
+     * If handtracking is enabled and hand tracking source is supported, gets the source of the hand tracking data for `hand`.
+     */
+    getHandTrackingSource(hand: Hand): HandTrackedSource { return _C(this, 5016, hand) as HandTrackedSource; }
+
+    /**
+     * If handtracking is enabled, returns flags that inform us of the validity of the tracking data.
+     */
+    getHandJointFlags(hand: Hand, joint: HandJoints): HandJointFlags { return _C(this, 5008, hand, joint) as HandJointFlags; }
+
+    /**
+     * If handtracking is enabled, returns the rotation of a joint (`joint`) of a hand (`hand`) as provided by OpenXR.
+     */
+    getHandJointRotation(hand: Hand, joint: HandJoints): Quaternion { return _C(this, 5012, hand, joint) as Quaternion; }
+
+    /**
+     * If handtracking is enabled, returns the position of a joint (`joint`) of a hand (`hand`) as provided by OpenXR. This is relative to {@link XROrigin3D} without worldscale applied!
+     */
+    getHandJointPosition(hand: Hand, joint: HandJoints): Vector3 { return _C(this, 5010, hand, joint) as Vector3; }
+
+    /**
+     * If handtracking is enabled, returns the radius of a joint (`joint`) of a hand (`hand`) as provided by OpenXR. This is without worldscale applied!
+     */
+    getHandJointRadius(hand: Hand, joint: HandJoints): number { return _C(this, 5011, hand, joint) as number; }
+
+    /**
+     * If handtracking is enabled, returns the linear velocity of a joint (`joint`) of a hand (`hand`) as provided by OpenXR. This is relative to {@link XROrigin3D} without worldscale applied!
+     */
+    getHandJointLinearVelocity(hand: Hand, joint: HandJoints): Vector3 { return _C(this, 5009, hand, joint) as Vector3; }
+
+    /**
+     * If handtracking is enabled, returns the angular velocity of a joint (`joint`) of a hand (`hand`) as provided by OpenXR. This is relative to {@link XROrigin3D}!
+     */
+    getHandJointAngularVelocity(hand: Hand, joint: HandJoints): Vector3 { return _C(this, 5007, hand, joint) as Vector3; }
+
+    /**
+     * Returns `true` if OpenXR's hand tracking is supported and enabled.
+     * **Note:** This only returns a valid value after OpenXR has been initialized.
+     */
+    isHandTrackingSupported(): boolean { return _C(this, 7986) as boolean; }
+
+    /**
+     * Returns `true` if OpenXR's hand interaction profile is supported and enabled.
+     * **Note:** This only returns a valid value after OpenXR has been initialized.
+     */
+    isHandInteractionSupported(): boolean { return _C(this, 7985) as boolean; }
+
+    /**
+     * Returns the capabilities of the eye gaze interaction extension.
+     * **Note:** This only returns a valid value after OpenXR has been initialized.
+     */
+    isEyeGazeInteractionSupported(): boolean { return _C(this, 7946) as boolean; }
+
+    /**
+     * Sets the CPU performance level of the OpenXR device.
+     */
+    setCpuLevel(level: PerfSettingsLevel): void { _C(this, 10976, level); }
+
+    /**
+     * Sets the GPU performance level of the OpenXR device.
+     */
+    setGpuLevel(level: PerfSettingsLevel): void { _C(this, 11550, level); }
+
+    /**
+     * The display refresh rate for the current HMD. Only functional if this feature is supported by the OpenXR runtime and after the interface has been initialized.
+     */
+    get displayRefreshRate(): number { return _C(this, 4519) as number; }
+    set displayRefreshRate(v: number) { _C(this, 11130, v); }
+
+    /**
+     * The render size multiplier for the current HMD. Must be set before the interface has been initialized.
+     */
+    get renderTargetSizeMultiplier(): number { return _C(this, 6138) as number; }
+    set renderTargetSizeMultiplier(v: number) { _C(this, 12523, v); }
+
+    /**
+     * The foveation level, from `0` (off) to `3` (high). The interface must be initialized before this is accessible.
+     */
+    get foveationLevel(): number { return _C(this, 4868) as number; }
+    set foveationLevel(v: number) { _C(this, 11471, v); }
+
+    /**
+     * If `true`, enables dynamic foveation adjustment. The interface must be initialized before this is accessible. If enabled, foveation will automatically be adjusted between low and {@link foveationLevel}.
+     */
+    get foveationDynamic(): boolean { return _C(this, 4867) as boolean; }
+    set foveationDynamic(v: boolean) { _C(this, 11470, v); }
+
+    /**
+     * If `true`, enables subsampled images with foveation, which can provide a performance boost on Vulkan.
+     */
+    get foveationWithSubsampledImages(): boolean { return _C(this, 4869) as boolean; }
+    set foveationWithSubsampledImages(v: boolean) { _C(this, 11472, v); }
+
+    /**
+     * The minimum radius around the focal point where full quality is guaranteed if VRS is used as a percentage of screen size.
+     * **Note:** Mobile and Forward+ renderers only. Requires {@link Viewport.vrsMode} to be set to {@link Viewport.VRS_XR}.
+     */
+    get vrsMinRadius(): number { return _C(this, 7134) as number; }
+    set vrsMinRadius(v: number) { _C(this, 13359, v); }
+
+    /**
+     * The strength used to calculate the VRS density map. The greater this value, the more noticeable VRS is. This improves performance at the cost of quality.
+     * **Note:** Mobile and Forward+ renderers only. Requires {@link Viewport.vrsMode} to be set to {@link Viewport.VRS_XR}.
+     */
+    get vrsStrength(): number { return _C(this, 7137) as number; }
+    set vrsStrength(v: number) { _C(this, 13362, v); }
+
+    /**
+     * Informs our OpenXR session has been started.
+     */
+    get sessionBegun(): Signal<() => void> { return _G(this, 10380) as Signal<() => void>; }
+    set sessionBegun(v: (() => void) | null) { _G(this, 10380, v); }
+
+    /**
+     * Informs our OpenXR session is stopping.
+     */
+    get sessionStopping(): Signal<() => void> { return _G(this, 10388) as Signal<() => void>; }
+    set sessionStopping(v: (() => void) | null) { _G(this, 10388, v); }
+
+    /**
+     * Informs our OpenXR session has been synchronized.
+     */
+    get sessionSynchronized(): Signal<() => void> { return _G(this, 10390) as Signal<() => void>; }
+    set sessionSynchronized(v: (() => void) | null) { _G(this, 10390, v); }
+
+    /**
+     * Informs our OpenXR session now has focus, for example output is sent to the HMD and we're receiving XR input.
+     */
+    get sessionFocussed(): Signal<() => void> { return _G(this, 10384) as Signal<() => void>; }
+    set sessionFocussed(v: (() => void) | null) { _G(this, 10384, v); }
+
+    /**
+     * Informs our OpenXR session is now visible, for example output is sent to the HMD but we don't receive XR input.
+     */
+    get sessionVisible(): Signal<() => void> { return _G(this, 10391) as Signal<() => void>; }
+    set sessionVisible(v: (() => void) | null) { _G(this, 10391, v); }
+
+    /**
+     * Informs our OpenXR session is in the process of being lost.
+     */
+    get sessionLossPending(): Signal<() => void> { return _G(this, 10385) as Signal<() => void>; }
+    set sessionLossPending(v: (() => void) | null) { _G(this, 10385, v); }
+
+    /**
+     * Informs our OpenXR instance is exiting.
+     */
+    get instanceExiting(): Signal<() => void> { return _G(this, 7645) as Signal<() => void>; }
+    set instanceExiting(v: (() => void) | null) { _G(this, 7645, v); }
+
+    /**
+     * Informs the user queued a recenter of the player position.
+     */
+    get poseRecentered(): Signal<() => void> { return _G(this, 9502) as Signal<() => void>; }
+    set poseRecentered(v: (() => void) | null) { _G(this, 9502, v); }
+
+    /**
+     * Informs the user the HMD refresh rate has changed.
+     * **Note:** Only emitted if XR runtime supports the refresh rate extension.
+     */
+    get refreshRateChanged(): Signal<(refreshRate: number) => void> { return _G(this, 9800) as Signal<(refreshRate: number) => void>; }
+    set refreshRateChanged(v: ((refreshRate: number) => void) | null) { _G(this, 9800, v); }
+
+    /**
+     * Informs the device CPU performance level has changed in the specified subdomain.
+     */
+    get cpuLevelChanged(): Signal<(subDomain: number, fromLevel: number, toLevel: number) => void> { return _G(this, 2504) as Signal<(subDomain: number, fromLevel: number, toLevel: number) => void>; }
+    set cpuLevelChanged(v: ((subDomain: number, fromLevel: number, toLevel: number) => void) | null) { _G(this, 2504, v); }
+
+    /**
+     * Informs the device GPU performance level has changed in the specified subdomain.
+     */
+    get gpuLevelChanged(): Signal<(subDomain: number, fromLevel: number, toLevel: number) => void> { return _G(this, 7283) as Signal<(subDomain: number, fromLevel: number, toLevel: number) => void>; }
+    set gpuLevelChanged(v: ((subDomain: number, fromLevel: number, toLevel: number) => void) | null) { _G(this, 7283, v); }
+
+    /**
+     * Signal emitted when the user presence value changes.
+     * **Note:** This signal will not be emitted during application startup and application shutdown. Developers should assume user presence is gained on startup and lost on shutdown.
+     */
+    get userPresenceChanged(): Signal<(isUserPresent: boolean) => void> { return _G(this, 14644) as Signal<(isUserPresent: boolean) => void>; }
+    set userPresenceChanged(v: ((isUserPresent: boolean) => void) | null) { _G(this, 14644, v); }
+
+    static readonly name = _R(498, OpenXRInterface);
+}
+
+export const SessionState = {
+    /**
+     * The state of the session is unknown, we haven't tried setting up OpenXR yet.
+     */
+    SESSION_STATE_UNKNOWN: 0,
+    /**
+     * The initial state after the OpenXR session is created or after the session is destroyed.
+     */
+    SESSION_STATE_IDLE: 1,
+    /**
+     * OpenXR is ready to begin our session. {@link session_begun} is emitted when we change to this state.
+     */
+    SESSION_STATE_READY: 2,
+    /**
+     * The application has synched its frame loop with the runtime but we're not rendering anything. {@link session_synchronized} is emitted when we change to this state.
+     */
+    SESSION_STATE_SYNCHRONIZED: 3,
+    /**
+     * The application has synched its frame loop with the runtime and we're rendering output to the user, however we receive no user input. {@link session_visible} is emitted when we change to this state.
+     * **Note:** This is the current state just before we get the focused state, whenever the user opens a system menu, switches to another application, or takes off their headset.
+     */
+    SESSION_STATE_VISIBLE: 4,
+    /**
+     * The application has synched its frame loop with the runtime, we're rendering output to the user and we're receiving XR input. {@link session_focussed} is emitted when we change to this state.
+     * **Note:** This is the state OpenXR will be in when the user can fully interact with your game.
+     */
+    SESSION_STATE_FOCUSED: 5,
+    /**
+     * Our session is being stopped. {@link session_stopping} is emitted when we change to this state.
+     */
+    SESSION_STATE_STOPPING: 6,
+    /**
+     * The session is about to be lost. {@link session_loss_pending} is emitted when we change to this state.
+     */
+    SESSION_STATE_LOSS_PENDING: 7,
+    /**
+     * The OpenXR instance is about to be destroyed and we're exiting. {@link instance_exiting} is emitted when we change to this state.
+     */
+    SESSION_STATE_EXITING: 8,
+} as const;
+
+export type SessionState = (typeof SessionState)[keyof typeof SessionState];
+
+export const Hand = {
+    /**
+     * Left hand.
+     */
+    HAND_LEFT: 0,
+    /**
+     * Right hand.
+     */
+    HAND_RIGHT: 1,
+    /**
+     * Maximum value for the hand enum.
+     */
+    HAND_MAX: 2,
+} as const;
+
+export type Hand = (typeof Hand)[keyof typeof Hand];
+
+export const HandMotionRange = {
+    /**
+     * Full hand range, if user closes their hands, we make a full fist.
+     */
+    HAND_MOTION_RANGE_UNOBSTRUCTED: 0,
+    /**
+     * Conform to controller, if user closes their hands, the tracked data conforms to the shape of the controller.
+     */
+    HAND_MOTION_RANGE_CONFORM_TO_CONTROLLER: 1,
+    /**
+     * Maximum value for the motion range enum.
+     */
+    HAND_MOTION_RANGE_MAX: 2,
+} as const;
+
+export type HandMotionRange = (typeof HandMotionRange)[keyof typeof HandMotionRange];
+
+export const HandTrackedSource = {
+    /**
+     * The source of hand tracking data is unknown (the extension is likely unsupported).
+     */
+    HAND_TRACKED_SOURCE_UNKNOWN: 0,
+    /**
+     * The source of hand tracking is unobstructed, this means that an accurate method of hand tracking is used, e.g. optical hand tracking, data gloves, etc.
+     */
+    HAND_TRACKED_SOURCE_UNOBSTRUCTED: 1,
+    /**
+     * The source of hand tracking is a controller, bone positions are inferred from controller inputs.
+     */
+    HAND_TRACKED_SOURCE_CONTROLLER: 2,
+    /**
+     * Represents the size of the {@link HandTrackedSource} enum.
+     */
+    HAND_TRACKED_SOURCE_MAX: 3,
+} as const;
+
+export type HandTrackedSource = (typeof HandTrackedSource)[keyof typeof HandTrackedSource];
+
+export const HandJoints = {
+    /**
+     * Palm joint.
+     */
+    HAND_JOINT_PALM: 0,
+    /**
+     * Wrist joint.
+     */
+    HAND_JOINT_WRIST: 1,
+    /**
+     * Thumb metacarpal joint.
+     */
+    HAND_JOINT_THUMB_METACARPAL: 2,
+    /**
+     * Thumb proximal joint.
+     */
+    HAND_JOINT_THUMB_PROXIMAL: 3,
+    /**
+     * Thumb distal joint.
+     */
+    HAND_JOINT_THUMB_DISTAL: 4,
+    /**
+     * Thumb tip joint.
+     */
+    HAND_JOINT_THUMB_TIP: 5,
+    /**
+     * Index finger metacarpal joint.
+     */
+    HAND_JOINT_INDEX_METACARPAL: 6,
+    /**
+     * Index finger phalanx proximal joint.
+     */
+    HAND_JOINT_INDEX_PROXIMAL: 7,
+    /**
+     * Index finger phalanx intermediate joint.
+     */
+    HAND_JOINT_INDEX_INTERMEDIATE: 8,
+    /**
+     * Index finger phalanx distal joint.
+     */
+    HAND_JOINT_INDEX_DISTAL: 9,
+    /**
+     * Index finger tip joint.
+     */
+    HAND_JOINT_INDEX_TIP: 10,
+    /**
+     * Middle finger metacarpal joint.
+     */
+    HAND_JOINT_MIDDLE_METACARPAL: 11,
+    /**
+     * Middle finger phalanx proximal joint.
+     */
+    HAND_JOINT_MIDDLE_PROXIMAL: 12,
+    /**
+     * Middle finger phalanx intermediate joint.
+     */
+    HAND_JOINT_MIDDLE_INTERMEDIATE: 13,
+    /**
+     * Middle finger phalanx distal joint.
+     */
+    HAND_JOINT_MIDDLE_DISTAL: 14,
+    /**
+     * Middle finger tip joint.
+     */
+    HAND_JOINT_MIDDLE_TIP: 15,
+    /**
+     * Ring finger metacarpal joint.
+     */
+    HAND_JOINT_RING_METACARPAL: 16,
+    /**
+     * Ring finger phalanx proximal joint.
+     */
+    HAND_JOINT_RING_PROXIMAL: 17,
+    /**
+     * Ring finger phalanx intermediate joint.
+     */
+    HAND_JOINT_RING_INTERMEDIATE: 18,
+    /**
+     * Ring finger phalanx distal joint.
+     */
+    HAND_JOINT_RING_DISTAL: 19,
+    /**
+     * Ring finger tip joint.
+     */
+    HAND_JOINT_RING_TIP: 20,
+    /**
+     * Pinky finger metacarpal joint.
+     */
+    HAND_JOINT_LITTLE_METACARPAL: 21,
+    /**
+     * Pinky finger phalanx proximal joint.
+     */
+    HAND_JOINT_LITTLE_PROXIMAL: 22,
+    /**
+     * Pinky finger phalanx intermediate joint.
+     */
+    HAND_JOINT_LITTLE_INTERMEDIATE: 23,
+    /**
+     * Pinky finger phalanx distal joint.
+     */
+    HAND_JOINT_LITTLE_DISTAL: 24,
+    /**
+     * Pinky finger tip joint.
+     */
+    HAND_JOINT_LITTLE_TIP: 25,
+    /**
+     * Represents the size of the {@link HandJoints} enum.
+     */
+    HAND_JOINT_MAX: 26,
+} as const;
+
+export type HandJoints = (typeof HandJoints)[keyof typeof HandJoints];
+
+export const PerfSettingsLevel = {
+    /**
+     * The application has entered a non-XR section (head-locked / static screen), during which power savings are to be prioritized.
+     */
+    PERF_SETTINGS_LEVEL_POWER_SAVINGS: 0,
+    /**
+     * The application has entered a low and stable complexity section, during which reducing power is more important than occasional late rendering frames.
+     */
+    PERF_SETTINGS_LEVEL_SUSTAINED_LOW: 1,
+    /**
+     * The application has entered a high or dynamic complexity section, during which the XR Runtime strives for consistent XR compositing and frame rendering within a thermally sustainable range.
+     */
+    PERF_SETTINGS_LEVEL_SUSTAINED_HIGH: 2,
+    /**
+     * The application has entered a section with very high complexity, during which the XR Runtime is allowed to step up beyond the thermally sustainable range.
+     */
+    PERF_SETTINGS_LEVEL_BOOST: 3,
+} as const;
+
+export type PerfSettingsLevel = (typeof PerfSettingsLevel)[keyof typeof PerfSettingsLevel];
+
+export const PerfSettingsSubDomain = {
+    /**
+     * The compositing performance within the runtime has reached a new level.
+     */
+    PERF_SETTINGS_SUB_DOMAIN_COMPOSITING: 0,
+    /**
+     * The application rendering performance has reached a new level.
+     */
+    PERF_SETTINGS_SUB_DOMAIN_RENDERING: 1,
+    /**
+     * The temperature of the device has reached a new level.
+     */
+    PERF_SETTINGS_SUB_DOMAIN_THERMAL: 2,
+} as const;
+
+export type PerfSettingsSubDomain = (typeof PerfSettingsSubDomain)[keyof typeof PerfSettingsSubDomain];
+
+export const PerfSettingsNotificationLevel = {
+    /**
+     * The sub-domain has reached a level where no further actions other than currently applied are necessary.
+     */
+    PERF_SETTINGS_NOTIF_LEVEL_NORMAL: 0,
+    /**
+     * The sub-domain has reached an early warning level where the application should start proactive mitigation actions.
+     */
+    PERF_SETTINGS_NOTIF_LEVEL_WARNING: 1,
+    /**
+     * The sub-domain has reached a critical level where the application should start drastic mitigation actions.
+     */
+    PERF_SETTINGS_NOTIF_LEVEL_IMPAIRED: 2,
+} as const;
+
+export type PerfSettingsNotificationLevel = (typeof PerfSettingsNotificationLevel)[keyof typeof PerfSettingsNotificationLevel];
+
+export const HandJointFlags = {
+    /**
+     * No flags are set.
+     */
+    HAND_JOINT_NONE: 0,
+    /**
+     * If set, the orientation data is valid, otherwise, the orientation data is unreliable and should not be used.
+     */
+    HAND_JOINT_ORIENTATION_VALID: 1,
+    /**
+     * If set, the orientation data comes from tracking data, otherwise, the orientation data contains predicted data.
+     */
+    HAND_JOINT_ORIENTATION_TRACKED: 2,
+    /**
+     * If set, the positional data is valid, otherwise, the positional data is unreliable and should not be used.
+     */
+    HAND_JOINT_POSITION_VALID: 4,
+    /**
+     * If set, the positional data comes from tracking data, otherwise, the positional data contains predicted data.
+     */
+    HAND_JOINT_POSITION_TRACKED: 8,
+    /**
+     * If set, our linear velocity data is valid, otherwise, the linear velocity data is unreliable and should not be used.
+     */
+    HAND_JOINT_LINEAR_VELOCITY_VALID: 16,
+    /**
+     * If set, our angular velocity data is valid, otherwise, the angular velocity data is unreliable and should not be used.
+     */
+    HAND_JOINT_ANGULAR_VELOCITY_VALID: 32,
+} as const;
+
+export type HandJointFlags = (typeof HandJointFlags)[keyof typeof HandJointFlags];
+

package/gen/classes/OpenXRMarkerTracker.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { OpenXRSpatialEntityTracker } from './OpenXRSpatialEntityTracker.ts';
+import type { Variant } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { MarkerType } from './OpenXRSpatialComponentMarkerList.ts';
+
+/**
+ * Spatial entity tracker for our OpenXR spatial entity marker tracking extension. These trackers identify entities in our real space detected by a visual marker such as a QRCode or Aruco code, and map their location to our virtual space.
+ */
+export class OpenXRMarkerTracker extends OpenXRSpatialEntityTracker {
+    constructor(name = 499) { super(name); }
+
+    /**
+     * Sets the marker data for this marker.
+     * **Note:** This should only be set by marker discovery logic.
+     */
+    setMarkerData(markerData: Variant): void { _C(this, 11973, markerData); }
+
+    /**
+     * Returns the marker data for this marker. This can return a {@link String} or {@link PackedByteArray}. Only applicable to QR Code based markers.
+     */
+    getMarkerData(): Variant { return _C(this, 5445) as Variant; }
+
+    /**
+     * The bounds size for this marker.
+     */
+    get boundsSize(): Vector2 { return _C(this, 3998) as Vector2; }
+    set boundsSize(v: Vector2) { _C(this, 10734, v); }
+
+    /**
+     * The type of marker.
+     */
+    get markerType(): MarkerType { return _C(this, 5449) as MarkerType; }
+    set markerType(v: MarkerType) { _C(this, 11975, v); }
+
+    /**
+     * The marker ID for this marker, this is only returned for Aruco and April Tag markers. Call {@link getMarkerData} for QRCode markers.
+     */
+    get markerId(): number { return _C(this, 5446) as number; }
+    set markerId(v: number) { _C(this, 11974, v); }
+
+    static readonly name = _R(499, OpenXRMarkerTracker);
+}

package/gen/classes/OpenXRPlaneTracker.ts

@@ -0,0 +1,68 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { OpenXRSpatialEntityTracker } from './OpenXRSpatialEntityTracker.ts';
+import type { PackedInt32Array, PackedVector2Array, Signal } from '../heap-types/index.ts';
+import type { Transform3D, Vector2 } from '../value-types/index.ts';
+import type { Mesh } from './Mesh.ts';
+import type { PlaneAlignment } from './OpenXRSpatialComponentPlaneAlignmentList.ts';
+import type { Shape3D } from './Shape3D.ts';
+
+/**
+ * Spatial entity tracker for our OpenXR spatial entity plane tracking extension. These trackers identify entities in our real space such as walls, floors, tables, etc. and map their location to our virtual space.
+ */
+export class OpenXRPlaneTracker extends OpenXRSpatialEntityTracker {
+    constructor(name = 500) { super(name); }
+
+    /**
+     * Sets the mesh data for this plane. You should only call this if you are handling your own discovery logic.
+     */
+    setMeshData(origin: Transform3D, vertices: PackedVector2Array, indices?: PackedInt32Array /* = PackedInt32Array() */): void { _C(this, 12025, origin, vertices, indices); }
+
+    /**
+     * Clears the mesh data for this tracker. You should only call this if you are handling your own discovery logic.
+     */
+    clearMeshData(): void { _C(this, 2283); }
+
+    /**
+     * Gets the transform by which to offset the mesh and collision shape from our pose to display these correctly.
+     */
+    getMeshOffset(): Transform3D { return _C(this, 5516) as Transform3D; }
+
+    /**
+     * Gets a mesh created from either the mesh data or from our bounding size for this plane.
+     */
+    getMesh(): Mesh { return _C(this, 5511) as Mesh; }
+
+    /**
+     * Gets a collision shape built either from the mesh data or from our bounding size for this plane.
+     */
+    getShape(thickness?: number /* = 0.01 */): Shape3D { return _C(this, 6370, thickness) as Shape3D; }
+
+    /**
+     * The bounding size of the plane. This is a 2D size.
+     */
+    get boundsSize(): Vector2 { return _C(this, 3998) as Vector2; }
+    set boundsSize(v: Vector2) { _C(this, 10734, v); }
+
+    /**
+     * The main alignment in space of this plane.
+     */
+    get planeAlignment(): PlaneAlignment { return _C(this, 5919) as PlaneAlignment; }
+    set planeAlignment(v: PlaneAlignment) { _C(this, 12338, v); }
+
+    /**
+     * The semantic label for this plane.
+     */
+    get planeLabel(): string { return _C(this, 5921) as string; }
+    set planeLabel(v: string) { _C(this, 12340, v); }
+
+    /**
+     * Emitted when our mesh data has changed the mesh instance and collision needs to be updated.
+     */
+    get meshChanged(): Signal<() => void> { return _G(this, 8860) as Signal<() => void>; }
+    set meshChanged(v: (() => void) | null) { _G(this, 8860, v); }
+
+    static readonly name = _R(500, OpenXRPlaneTracker);
+}