typescript-to-gdscript 0.1.0

package/typings/classes/XRFaceTracker.d.ts

@@ -0,0 +1,308 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A tracked face. */
+declare class XRFaceTracker extends XRTracker {
+  /**
+   * The array of face blend shape weights with indices corresponding to the {@link BlendShapeEntry} enum.
+   */
+  blend_shapes: PackedFloat32Array;
+  type: int;
+  set_blend_shapes(value: PackedFloat32Array | Array<unknown>): void;
+  get_blend_shapes(): PackedFloat32Array;
+
+  /** Returns the requested face blend shape weight. */
+  get_blend_shape(blend_shape: int): float;
+  /** Sets a face blend shape weight. */
+  set_blend_shape(blend_shape: int, weight: float): void;
+
+  // enum BlendShapeEntry
+  /** Right eye looks outwards. */
+  static readonly FT_EYE_LOOK_OUT_RIGHT: int;
+  /** Right eye looks inwards. */
+  static readonly FT_EYE_LOOK_IN_RIGHT: int;
+  /** Right eye looks upwards. */
+  static readonly FT_EYE_LOOK_UP_RIGHT: int;
+  /** Right eye looks downwards. */
+  static readonly FT_EYE_LOOK_DOWN_RIGHT: int;
+  /** Left eye looks outwards. */
+  static readonly FT_EYE_LOOK_OUT_LEFT: int;
+  /** Left eye looks inwards. */
+  static readonly FT_EYE_LOOK_IN_LEFT: int;
+  /** Left eye looks upwards. */
+  static readonly FT_EYE_LOOK_UP_LEFT: int;
+  /** Left eye looks downwards. */
+  static readonly FT_EYE_LOOK_DOWN_LEFT: int;
+  /** Closes the right eyelid. */
+  static readonly FT_EYE_CLOSED_RIGHT: int;
+  /** Closes the left eyelid. */
+  static readonly FT_EYE_CLOSED_LEFT: int;
+  /** Squeezes the right eye socket muscles. */
+  static readonly FT_EYE_SQUINT_RIGHT: int;
+  /** Squeezes the left eye socket muscles. */
+  static readonly FT_EYE_SQUINT_LEFT: int;
+  /** Right eyelid widens beyond relaxed. */
+  static readonly FT_EYE_WIDE_RIGHT: int;
+  /** Left eyelid widens beyond relaxed. */
+  static readonly FT_EYE_WIDE_LEFT: int;
+  /** Dilates the right eye pupil. */
+  static readonly FT_EYE_DILATION_RIGHT: int;
+  /** Dilates the left eye pupil. */
+  static readonly FT_EYE_DILATION_LEFT: int;
+  /** Constricts the right eye pupil. */
+  static readonly FT_EYE_CONSTRICT_RIGHT: int;
+  /** Constricts the left eye pupil. */
+  static readonly FT_EYE_CONSTRICT_LEFT: int;
+  /** Right eyebrow pinches in. */
+  static readonly FT_BROW_PINCH_RIGHT: int;
+  /** Left eyebrow pinches in. */
+  static readonly FT_BROW_PINCH_LEFT: int;
+  /** Outer right eyebrow pulls down. */
+  static readonly FT_BROW_LOWERER_RIGHT: int;
+  /** Outer left eyebrow pulls down. */
+  static readonly FT_BROW_LOWERER_LEFT: int;
+  /** Inner right eyebrow pulls up. */
+  static readonly FT_BROW_INNER_UP_RIGHT: int;
+  /** Inner left eyebrow pulls up. */
+  static readonly FT_BROW_INNER_UP_LEFT: int;
+  /** Outer right eyebrow pulls up. */
+  static readonly FT_BROW_OUTER_UP_RIGHT: int;
+  /** Outer left eyebrow pulls up. */
+  static readonly FT_BROW_OUTER_UP_LEFT: int;
+  /** Right side face sneers. */
+  static readonly FT_NOSE_SNEER_RIGHT: int;
+  /** Left side face sneers. */
+  static readonly FT_NOSE_SNEER_LEFT: int;
+  /** Right side nose canal dilates. */
+  static readonly FT_NASAL_DILATION_RIGHT: int;
+  /** Left side nose canal dilates. */
+  static readonly FT_NASAL_DILATION_LEFT: int;
+  /** Right side nose canal constricts. */
+  static readonly FT_NASAL_CONSTRICT_RIGHT: int;
+  /** Left side nose canal constricts. */
+  static readonly FT_NASAL_CONSTRICT_LEFT: int;
+  /** Raises the right side cheek. */
+  static readonly FT_CHEEK_SQUINT_RIGHT: int;
+  /** Raises the left side cheek. */
+  static readonly FT_CHEEK_SQUINT_LEFT: int;
+  /** Puffs the right side cheek. */
+  static readonly FT_CHEEK_PUFF_RIGHT: int;
+  /** Puffs the left side cheek. */
+  static readonly FT_CHEEK_PUFF_LEFT: int;
+  /** Sucks in the right side cheek. */
+  static readonly FT_CHEEK_SUCK_RIGHT: int;
+  /** Sucks in the left side cheek. */
+  static readonly FT_CHEEK_SUCK_LEFT: int;
+  /** Opens jawbone. */
+  static readonly FT_JAW_OPEN: int;
+  /** Closes the mouth. */
+  static readonly FT_MOUTH_CLOSED: int;
+  /** Pushes jawbone right. */
+  static readonly FT_JAW_RIGHT: int;
+  /** Pushes jawbone left. */
+  static readonly FT_JAW_LEFT: int;
+  /** Pushes jawbone forward. */
+  static readonly FT_JAW_FORWARD: int;
+  /** Pushes jawbone backward. */
+  static readonly FT_JAW_BACKWARD: int;
+  /** Flexes jaw muscles. */
+  static readonly FT_JAW_CLENCH: int;
+  /** Raises the jawbone. */
+  static readonly FT_JAW_MANDIBLE_RAISE: int;
+  /** Upper right lip part tucks in the mouth. */
+  static readonly FT_LIP_SUCK_UPPER_RIGHT: int;
+  /** Upper left lip part tucks in the mouth. */
+  static readonly FT_LIP_SUCK_UPPER_LEFT: int;
+  /** Lower right lip part tucks in the mouth. */
+  static readonly FT_LIP_SUCK_LOWER_RIGHT: int;
+  /** Lower left lip part tucks in the mouth. */
+  static readonly FT_LIP_SUCK_LOWER_LEFT: int;
+  /** Right lip corner folds into the mouth. */
+  static readonly FT_LIP_SUCK_CORNER_RIGHT: int;
+  /** Left lip corner folds into the mouth. */
+  static readonly FT_LIP_SUCK_CORNER_LEFT: int;
+  /** Upper right lip part pushes into a funnel. */
+  static readonly FT_LIP_FUNNEL_UPPER_RIGHT: int;
+  /** Upper left lip part pushes into a funnel. */
+  static readonly FT_LIP_FUNNEL_UPPER_LEFT: int;
+  /** Lower right lip part pushes into a funnel. */
+  static readonly FT_LIP_FUNNEL_LOWER_RIGHT: int;
+  /** Lower left lip part pushes into a funnel. */
+  static readonly FT_LIP_FUNNEL_LOWER_LEFT: int;
+  /** Upper right lip part pushes outwards. */
+  static readonly FT_LIP_PUCKER_UPPER_RIGHT: int;
+  /** Upper left lip part pushes outwards. */
+  static readonly FT_LIP_PUCKER_UPPER_LEFT: int;
+  /** Lower right lip part pushes outwards. */
+  static readonly FT_LIP_PUCKER_LOWER_RIGHT: int;
+  /** Lower left lip part pushes outwards. */
+  static readonly FT_LIP_PUCKER_LOWER_LEFT: int;
+  /** Upper right part of the lip pulls up. */
+  static readonly FT_MOUTH_UPPER_UP_RIGHT: int;
+  /** Upper left part of the lip pulls up. */
+  static readonly FT_MOUTH_UPPER_UP_LEFT: int;
+  /** Lower right part of the lip pulls up. */
+  static readonly FT_MOUTH_LOWER_DOWN_RIGHT: int;
+  /** Lower left part of the lip pulls up. */
+  static readonly FT_MOUTH_LOWER_DOWN_LEFT: int;
+  /** Upper right lip part pushes in the cheek. */
+  static readonly FT_MOUTH_UPPER_DEEPEN_RIGHT: int;
+  /** Upper left lip part pushes in the cheek. */
+  static readonly FT_MOUTH_UPPER_DEEPEN_LEFT: int;
+  /** Moves upper lip right. */
+  static readonly FT_MOUTH_UPPER_RIGHT: int;
+  /** Moves upper lip left. */
+  static readonly FT_MOUTH_UPPER_LEFT: int;
+  /** Moves lower lip right. */
+  static readonly FT_MOUTH_LOWER_RIGHT: int;
+  /** Moves lower lip left. */
+  static readonly FT_MOUTH_LOWER_LEFT: int;
+  /** Right lip corner pulls diagonally up and out. */
+  static readonly FT_MOUTH_CORNER_PULL_RIGHT: int;
+  /** Left lip corner pulls diagonally up and out. */
+  static readonly FT_MOUTH_CORNER_PULL_LEFT: int;
+  /** Right corner lip slants up. */
+  static readonly FT_MOUTH_CORNER_SLANT_RIGHT: int;
+  /** Left corner lip slants up. */
+  static readonly FT_MOUTH_CORNER_SLANT_LEFT: int;
+  /** Right corner lip pulls down. */
+  static readonly FT_MOUTH_FROWN_RIGHT: int;
+  /** Left corner lip pulls down. */
+  static readonly FT_MOUTH_FROWN_LEFT: int;
+  /** Mouth corner lip pulls out and down. */
+  static readonly FT_MOUTH_STRETCH_RIGHT: int;
+  /** Mouth corner lip pulls out and down. */
+  static readonly FT_MOUTH_STRETCH_LEFT: int;
+  /** Right lip corner is pushed backwards. */
+  static readonly FT_MOUTH_DIMPLE_RIGHT: int;
+  /** Left lip corner is pushed backwards. */
+  static readonly FT_MOUTH_DIMPLE_LEFT: int;
+  /** Raises and slightly pushes out the upper mouth. */
+  static readonly FT_MOUTH_RAISER_UPPER: int;
+  /** Raises and slightly pushes out the lower mouth. */
+  static readonly FT_MOUTH_RAISER_LOWER: int;
+  /** Right side lips press and flatten together vertically. */
+  static readonly FT_MOUTH_PRESS_RIGHT: int;
+  /** Left side lips press and flatten together vertically. */
+  static readonly FT_MOUTH_PRESS_LEFT: int;
+  /** Right side lips squeeze together horizontally. */
+  static readonly FT_MOUTH_TIGHTENER_RIGHT: int;
+  /** Left side lips squeeze together horizontally. */
+  static readonly FT_MOUTH_TIGHTENER_LEFT: int;
+  /** Tongue visibly sticks out of the mouth. */
+  static readonly FT_TONGUE_OUT: int;
+  /** Tongue points upwards. */
+  static readonly FT_TONGUE_UP: int;
+  /** Tongue points downwards. */
+  static readonly FT_TONGUE_DOWN: int;
+  /** Tongue points right. */
+  static readonly FT_TONGUE_RIGHT: int;
+  /** Tongue points left. */
+  static readonly FT_TONGUE_LEFT: int;
+  /** Sides of the tongue funnel, creating a roll. */
+  static readonly FT_TONGUE_ROLL: int;
+  /** Tongue arches up then down inside the mouth. */
+  static readonly FT_TONGUE_BLEND_DOWN: int;
+  /** Tongue arches down then up inside the mouth. */
+  static readonly FT_TONGUE_CURL_UP: int;
+  /** Tongue squishes together and thickens. */
+  static readonly FT_TONGUE_SQUISH: int;
+  /** Tongue flattens and thins out. */
+  static readonly FT_TONGUE_FLAT: int;
+  /** Tongue tip rotates clockwise, with the rest following gradually. */
+  static readonly FT_TONGUE_TWIST_RIGHT: int;
+  /** Tongue tip rotates counter-clockwise, with the rest following gradually. */
+  static readonly FT_TONGUE_TWIST_LEFT: int;
+  /** Inner mouth throat closes. */
+  static readonly FT_SOFT_PALATE_CLOSE: int;
+  /** The Adam's apple visibly swallows. */
+  static readonly FT_THROAT_SWALLOW: int;
+  /** Right side neck visibly flexes. */
+  static readonly FT_NECK_FLEX_RIGHT: int;
+  /** Left side neck visibly flexes. */
+  static readonly FT_NECK_FLEX_LEFT: int;
+  /** Closes both eye lids. */
+  static readonly FT_EYE_CLOSED: int;
+  /** Widens both eye lids. */
+  static readonly FT_EYE_WIDE: int;
+  /** Squints both eye lids. */
+  static readonly FT_EYE_SQUINT: int;
+  /** Dilates both pupils. */
+  static readonly FT_EYE_DILATION: int;
+  /** Constricts both pupils. */
+  static readonly FT_EYE_CONSTRICT: int;
+  /** Pulls the right eyebrow down and in. */
+  static readonly FT_BROW_DOWN_RIGHT: int;
+  /** Pulls the left eyebrow down and in. */
+  static readonly FT_BROW_DOWN_LEFT: int;
+  /** Pulls both eyebrows down and in. */
+  static readonly FT_BROW_DOWN: int;
+  /** Right brow appears worried. */
+  static readonly FT_BROW_UP_RIGHT: int;
+  /** Left brow appears worried. */
+  static readonly FT_BROW_UP_LEFT: int;
+  /** Both brows appear worried. */
+  static readonly FT_BROW_UP: int;
+  /** Entire face sneers. */
+  static readonly FT_NOSE_SNEER: int;
+  /** Both nose canals dilate. */
+  static readonly FT_NASAL_DILATION: int;
+  /** Both nose canals constrict. */
+  static readonly FT_NASAL_CONSTRICT: int;
+  /** Puffs both cheeks. */
+  static readonly FT_CHEEK_PUFF: int;
+  /** Sucks in both cheeks. */
+  static readonly FT_CHEEK_SUCK: int;
+  /** Raises both cheeks. */
+  static readonly FT_CHEEK_SQUINT: int;
+  /** Tucks in the upper lips. */
+  static readonly FT_LIP_SUCK_UPPER: int;
+  /** Tucks in the lower lips. */
+  static readonly FT_LIP_SUCK_LOWER: int;
+  /** Tucks in both lips. */
+  static readonly FT_LIP_SUCK: int;
+  /** Funnels in the upper lips. */
+  static readonly FT_LIP_FUNNEL_UPPER: int;
+  /** Funnels in the lower lips. */
+  static readonly FT_LIP_FUNNEL_LOWER: int;
+  /** Funnels in both lips. */
+  static readonly FT_LIP_FUNNEL: int;
+  /** Upper lip part pushes outwards. */
+  static readonly FT_LIP_PUCKER_UPPER: int;
+  /** Lower lip part pushes outwards. */
+  static readonly FT_LIP_PUCKER_LOWER: int;
+  /** Lips push outwards. */
+  static readonly FT_LIP_PUCKER: int;
+  /** Raises the upper lips. */
+  static readonly FT_MOUTH_UPPER_UP: int;
+  /** Lowers the lower lips. */
+  static readonly FT_MOUTH_LOWER_DOWN: int;
+  /** Mouth opens, revealing teeth. */
+  static readonly FT_MOUTH_OPEN: int;
+  /** Moves mouth right. */
+  static readonly FT_MOUTH_RIGHT: int;
+  /** Moves mouth left. */
+  static readonly FT_MOUTH_LEFT: int;
+  /** Right side of the mouth smiles. */
+  static readonly FT_MOUTH_SMILE_RIGHT: int;
+  /** Left side of the mouth smiles. */
+  static readonly FT_MOUTH_SMILE_LEFT: int;
+  /** Mouth expresses a smile. */
+  static readonly FT_MOUTH_SMILE: int;
+  /** Right side of the mouth expresses sadness. */
+  static readonly FT_MOUTH_SAD_RIGHT: int;
+  /** Left side of the mouth expresses sadness. */
+  static readonly FT_MOUTH_SAD_LEFT: int;
+  /** Mouth expresses sadness. */
+  static readonly FT_MOUTH_SAD: int;
+  /** Mouth stretches. */
+  static readonly FT_MOUTH_STRETCH: int;
+  /** Lip corners dimple. */
+  static readonly FT_MOUTH_DIMPLE: int;
+  /** Mouth tightens. */
+  static readonly FT_MOUTH_TIGHTENER: int;
+  /** Mouth presses together. */
+  static readonly FT_MOUTH_PRESS: int;
+  /** Represents the size of the {@link BlendShapeEntry} enum. */
+  static readonly FT_MAX: int;
+}

package/typings/classes/XRHandModifier3D.d.ts

@@ -0,0 +1,24 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node for driving hand meshes from {@link XRHandTracker} data. */
+declare class XRHandModifier3D extends SkeletonModifier3D {
+  /** Specifies the type of updates to perform on the bones. */
+  bone_update: int;
+  /**
+   * The name of the {@link XRHandTracker} registered with {@link XRServer} to obtain the hand tracking data from.
+   */
+  hand_tracker: string;
+  set_bone_update(value: int): void;
+  get_bone_update(): int;
+  set_hand_tracker(value: string): void;
+  get_hand_tracker(): string;
+
+  // enum BoneUpdate
+  /** The skeleton's bones are fully updated (both position and rotation) to match the tracked bones. */
+  static readonly BONE_UPDATE_FULL: int;
+  /** The skeleton's bones are only rotated to align with the tracked bones, preserving bone length. */
+  static readonly BONE_UPDATE_ROTATION_ONLY: int;
+  /** Represents the size of the {@link BoneUpdate} enum. */
+  static readonly BONE_UPDATE_MAX: int;
+}

package/typings/classes/XRHandTracker.d.ts

@@ -0,0 +1,127 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A tracked hand in XR. */
+declare class XRHandTracker extends XRPositionalTracker {
+  /**
+   * <member name="hand_tracking_source" type="int" setter="set_hand_tracking_source" getter="get_hand_tracking_source" enum="XRHandTracker.HandTrackingSource" default="0">
+   * The source of the hand tracking data.
+   */
+  hand: int;
+  /** If `true`, the hand tracking data is valid. */
+  has_tracking_data: boolean;
+  type: int;
+  set_has_tracking_data(value: boolean): void;
+  get_has_tracking_data(): boolean;
+
+  /** Returns the angular velocity for the given hand joint. */
+  get_hand_joint_angular_velocity(joint: int): Vector3;
+  /** Returns flags about the validity of the tracking data for the given hand joint. */
+  get_hand_joint_flags(joint: int): int;
+  /** Returns the linear velocity for the given hand joint. */
+  get_hand_joint_linear_velocity(joint: int): Vector3;
+  /** Returns the radius of the given hand joint. */
+  get_hand_joint_radius(joint: int): float;
+  /** Returns the transform for the given hand joint. */
+  get_hand_joint_transform(joint: int): Transform3D;
+  /** Sets the angular velocity for the given hand joint. */
+  set_hand_joint_angular_velocity(joint: int, angular_velocity: Vector3 | Vector3i): void;
+  /** Sets flags about the validity of the tracking data for the given hand joint. */
+  set_hand_joint_flags(joint: int, flags: int): void;
+  /** Sets the linear velocity for the given hand joint. */
+  set_hand_joint_linear_velocity(joint: int, linear_velocity: Vector3 | Vector3i): void;
+  /** Sets the radius of the given hand joint. */
+  set_hand_joint_radius(joint: int, radius: float): void;
+  /** Sets the transform for the given hand joint. */
+  set_hand_joint_transform(joint: int, transform: Transform3D | Projection): void;
+
+  // enum HandTrackingSource
+  /** The source of hand tracking data is unknown. */
+  static readonly HAND_TRACKING_SOURCE_UNKNOWN: int;
+  /**
+   * The source of hand tracking data is unobstructed, meaning that an accurate method of hand tracking is used. These include optical hand tracking, data gloves, etc.
+   */
+  static readonly HAND_TRACKING_SOURCE_UNOBSTRUCTED: int;
+  /**
+   * The source of hand tracking data is a controller, meaning that joint positions are inferred from controller inputs.
+   */
+  static readonly HAND_TRACKING_SOURCE_CONTROLLER: int;
+  /**
+   * No hand tracking data is tracked, this either means the hand is obscured, the controller is turned off, or tracking is not supported for the current input type.
+   */
+  static readonly HAND_TRACKING_SOURCE_NOT_TRACKED: int;
+  /** Represents the size of the {@link HandTrackingSource} enum. */
+  static readonly HAND_TRACKING_SOURCE_MAX: int;
+  // enum HandJoint
+  /** Palm joint. */
+  static readonly HAND_JOINT_PALM: int;
+  /** Wrist joint. */
+  static readonly HAND_JOINT_WRIST: int;
+  /** Thumb metacarpal joint. */
+  static readonly HAND_JOINT_THUMB_METACARPAL: int;
+  /** Thumb phalanx proximal joint. */
+  static readonly HAND_JOINT_THUMB_PHALANX_PROXIMAL: int;
+  /** Thumb phalanx distal joint. */
+  static readonly HAND_JOINT_THUMB_PHALANX_DISTAL: int;
+  /** Thumb tip joint. */
+  static readonly HAND_JOINT_THUMB_TIP: int;
+  /** Index finger metacarpal joint. */
+  static readonly HAND_JOINT_INDEX_FINGER_METACARPAL: int;
+  /** Index finger phalanx proximal joint. */
+  static readonly HAND_JOINT_INDEX_FINGER_PHALANX_PROXIMAL: int;
+  /** Index finger phalanx intermediate joint. */
+  static readonly HAND_JOINT_INDEX_FINGER_PHALANX_INTERMEDIATE: int;
+  /** Index finger phalanx distal joint. */
+  static readonly HAND_JOINT_INDEX_FINGER_PHALANX_DISTAL: int;
+  /** Index finger tip joint. */
+  static readonly HAND_JOINT_INDEX_FINGER_TIP: int;
+  /** Middle finger metacarpal joint. */
+  static readonly HAND_JOINT_MIDDLE_FINGER_METACARPAL: int;
+  /** Middle finger phalanx proximal joint. */
+  static readonly HAND_JOINT_MIDDLE_FINGER_PHALANX_PROXIMAL: int;
+  /** Middle finger phalanx intermediate joint. */
+  static readonly HAND_JOINT_MIDDLE_FINGER_PHALANX_INTERMEDIATE: int;
+  /** Middle finger phalanx distal joint. */
+  static readonly HAND_JOINT_MIDDLE_FINGER_PHALANX_DISTAL: int;
+  /** Middle finger tip joint. */
+  static readonly HAND_JOINT_MIDDLE_FINGER_TIP: int;
+  /** Ring finger metacarpal joint. */
+  static readonly HAND_JOINT_RING_FINGER_METACARPAL: int;
+  /** Ring finger phalanx proximal joint. */
+  static readonly HAND_JOINT_RING_FINGER_PHALANX_PROXIMAL: int;
+  /** Ring finger phalanx intermediate joint. */
+  static readonly HAND_JOINT_RING_FINGER_PHALANX_INTERMEDIATE: int;
+  /** Ring finger phalanx distal joint. */
+  static readonly HAND_JOINT_RING_FINGER_PHALANX_DISTAL: int;
+  /** Ring finger tip joint. */
+  static readonly HAND_JOINT_RING_FINGER_TIP: int;
+  /** Pinky finger metacarpal joint. */
+  static readonly HAND_JOINT_PINKY_FINGER_METACARPAL: int;
+  /** Pinky finger phalanx proximal joint. */
+  static readonly HAND_JOINT_PINKY_FINGER_PHALANX_PROXIMAL: int;
+  /** Pinky finger phalanx intermediate joint. */
+  static readonly HAND_JOINT_PINKY_FINGER_PHALANX_INTERMEDIATE: int;
+  /** Pinky finger phalanx distal joint. */
+  static readonly HAND_JOINT_PINKY_FINGER_PHALANX_DISTAL: int;
+  /** Pinky finger tip joint. */
+  static readonly HAND_JOINT_PINKY_FINGER_TIP: int;
+  /** Represents the size of the {@link HandJoint} enum. */
+  static readonly HAND_JOINT_MAX: int;
+  // enum HandJointFlags
+  /** The hand joint's orientation data is valid. */
+  static readonly HAND_JOINT_FLAG_ORIENTATION_VALID: int;
+  /**
+   * The hand joint's orientation is actively tracked. May not be set if tracking has been temporarily lost.
+   */
+  static readonly HAND_JOINT_FLAG_ORIENTATION_TRACKED: int;
+  /** The hand joint's position data is valid. */
+  static readonly HAND_JOINT_FLAG_POSITION_VALID: int;
+  /**
+   * The hand joint's position is actively tracked. May not be set if tracking has been temporarily lost.
+   */
+  static readonly HAND_JOINT_FLAG_POSITION_TRACKED: int;
+  /** The hand joint's linear velocity data is valid. */
+  static readonly HAND_JOINT_FLAG_LINEAR_VELOCITY_VALID: int;
+  /** The hand joint's angular velocity data is valid. */
+  static readonly HAND_JOINT_FLAG_ANGULAR_VELOCITY_VALID: int;
+}

package/typings/classes/XRInterface.d.ts

@@ -0,0 +1,181 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for an XR interface implementation. */
+declare class XRInterface extends RefCounted {
+  /** On an AR interface, `true` if anchor detection is enabled. */
+  ar_is_anchor_detection_enabled: boolean;
+  /**
+   * Specify how XR should blend in the environment. This is specific to certain AR and passthrough devices where camera images are blended in by the XR compositor.
+   */
+  environment_blend_mode: int;
+  /** `true` if this is the primary interface. */
+  interface_is_primary: boolean;
+  /** The play area mode for this interface. */
+  xr_play_area_mode: int;
+  set_anchor_detection_is_enabled(value: boolean): void;
+  get_anchor_detection_is_enabled(): boolean;
+  get_environment_blend_mode(): int;
+  set_primary(value: boolean): void;
+  is_primary(): boolean;
+  get_play_area_mode(): int;
+
+  /**
+   * If this is an AR interface that requires displaying a camera feed as the background, this method returns the feed ID in the {@link CameraServer} for this interface.
+   */
+  get_camera_feed_id(): int;
+  /**
+   * Returns a combination of {@link Capabilities} flags providing information about the capabilities of this interface.
+   */
+  get_capabilities(): int;
+  /** Returns the name of this interface (`"OpenXR"`, `"OpenVR"`, `"OpenHMD"`, `"ARKit"`, etc.). */
+  get_name(): string;
+  /**
+   * Returns an array of vectors that represent the physical play area mapped to the virtual space around the {@link XROrigin3D} point. The points form a convex polygon that can be used to react to or visualize the play area. This returns an empty array if this feature is not supported or if the information is not yet available.
+   */
+  get_play_area(): PackedVector3Array;
+  /** Returns the projection matrix for a view/eye. */
+  get_projection_for_view(view: int, aspect: float, near: float, far: float): Projection;
+  /**
+   * Returns the resolution at which we should render our intermediate results before things like lens distortion are applied by the VR platform.
+   */
+  get_render_target_size(): Vector2;
+  /**
+   * Returns the an array of supported environment blend modes, see {@link XRInterface.EnvironmentBlendMode}.
+   */
+  get_supported_environment_blend_modes(): Array<unknown>;
+  /**
+   * Returns a {@link Dictionary} with extra system info. Interfaces are expected to return `XRRuntimeName` and `XRRuntimeVersion` providing info about the used XR runtime. Additional entries may be provided specific to an interface.
+   * **Note:**This information may only be available after {@link initialize} was successfully called.
+   */
+  get_system_info(): Dictionary;
+  /**
+   * If supported, returns the status of our tracking. This will allow you to provide feedback to the user whether there are issues with positional tracking.
+   */
+  get_tracking_status(): int;
+  /**
+   * Returns the transform for a view/eye.
+   * `view` is the view/eye index.
+   * `cam_transform` is the transform that maps device coordinates to scene coordinates, typically the {@link Node3D.global_transform} of the current XROrigin3D.
+   */
+  get_transform_for_view(view: int, cam_transform: Transform3D | Projection): Transform3D;
+  /**
+   * Returns the number of views that need to be rendered for this device. 1 for Monoscopic, 2 for Stereoscopic.
+   */
+  get_view_count(): int;
+  /**
+   * Call this to initialize this interface. The first interface that is initialized is identified as the primary interface and it will be used for rendering output.
+   * After initializing the interface you want to use you then need to enable the AR/VR mode of a viewport and rendering should commence.
+   * **Note:** You must enable the XR mode on the main viewport for any device that uses the main output of Godot, such as for mobile VR.
+   * If you do this for a platform that handles its own output (such as OpenVR) Godot will show just one eye without distortion on screen. Alternatively, you can add a separate viewport node to your scene and enable AR/VR on that viewport. It will be used to output to the HMD, leaving you free to do anything you like in the main window, such as using a separate camera as a spectator camera or rendering something completely different.
+   * While currently not used, you can activate additional interfaces. You may wish to do this if you want to track controllers from other platforms. However, at this point in time only one interface can render to an HMD.
+   */
+  initialize(): boolean;
+  /** Returns `true` if this interface has been initialized. */
+  is_initialized(): boolean;
+  /** Returns `true` if passthrough is enabled. */
+  is_passthrough_enabled(): boolean;
+  /** Returns `true` if this interface supports passthrough. */
+  is_passthrough_supported(): boolean;
+  /**
+   * Sets the active environment blend mode.
+   * `mode` is the environment blend mode starting with the next frame.
+   * **Note:** Not all runtimes support all environment blend modes, so it is important to check this at startup. For example:
+   */
+  set_environment_blend_mode(mode: int): boolean;
+  /**
+   * Sets the active play area mode, will return `false` if the mode can't be used with this interface.
+   * **Note:** Changing this after the interface has already been initialized can be jarring for the player, so it's recommended to recenter on the HMD with {@link XRServer.center_on_hmd} (if switching to {@link XRInterface.XR_PLAY_AREA_STAGE}) or make the switch during a scene change.
+   */
+  set_play_area_mode(mode: int): boolean;
+  /**
+   * Starts passthrough, will return `false` if passthrough couldn't be started.
+   * **Note:** The viewport used for XR must have a transparent background, otherwise passthrough may not properly render.
+   */
+  start_passthrough(): boolean;
+  /** Stops passthrough. */
+  stop_passthrough(): void;
+  /** Call this to find out if a given play area mode is supported by this interface. */
+  supports_play_area_mode(mode: int): boolean;
+  /**
+   * Triggers a haptic pulse on a device associated with this interface.
+   * `action_name` is the name of the action for this pulse.
+   * `tracker_name` is optional and can be used to direct the pulse to a specific device provided that device is bound to this haptic.
+   * `frequency` is the frequency of the pulse, set to `0.0` to have the system use a default frequency.
+   * `amplitude` is the amplitude of the pulse between `0.0` and `1.0`.
+   * `duration_sec` is the duration of the pulse in seconds.
+   * `delay_sec` is a delay in seconds before the pulse is given.
+   */
+  trigger_haptic_pulse(action_name: string | NodePath, tracker_name: string, frequency: float, amplitude: float, duration_sec: float, delay_sec: float): void;
+  /** Turns the interface off. */
+  uninitialize(): void;
+
+  /**
+   * Emitted when the play area is changed. This can be a result of the player resetting the boundary or entering a new play area, the player changing the play area mode, the world scale changing or the player resetting their headset orientation.
+   */
+  play_area_changed: Signal<[int]>;
+
+  // enum Capabilities
+  /** No XR capabilities. */
+  static readonly XR_NONE: int;
+  /** This interface can work with normal rendering output (non-HMD based AR). */
+  static readonly XR_MONO: int;
+  /** This interface supports stereoscopic rendering. */
+  static readonly XR_STEREO: int;
+  /** This interface supports quad rendering (not yet supported by Godot). */
+  static readonly XR_QUAD: int;
+  /** This interface supports VR. */
+  static readonly XR_VR: int;
+  /** This interface supports AR (video background and real world tracking). */
+  static readonly XR_AR: int;
+  /**
+   * This interface outputs to an external device. If the main viewport is used, the on screen output is an unmodified buffer of either the left or right eye (stretched if the viewport size is not changed to the same aspect ratio of {@link get_render_target_size}). Using a separate viewport node frees up the main viewport for other purposes.
+   */
+  static readonly XR_EXTERNAL: int;
+  // enum TrackingStatus
+  /** Tracking is behaving as expected. */
+  static readonly XR_NORMAL_TRACKING: int;
+  /** Tracking is hindered by excessive motion (the player is moving faster than tracking can keep up). */
+  static readonly XR_EXCESSIVE_MOTION: int;
+  /**
+   * Tracking is hindered by insufficient features, it's too dark (for camera-based tracking), player is blocked, etc.
+   */
+  static readonly XR_INSUFFICIENT_FEATURES: int;
+  /** We don't know the status of the tracking or this interface does not provide feedback. */
+  static readonly XR_UNKNOWN_TRACKING: int;
+  /** Tracking is not functional (camera not plugged in or obscured, lighthouses turned off, etc.). */
+  static readonly XR_NOT_TRACKING: int;
+  // enum PlayAreaMode
+  /** Play area mode not set or not available. */
+  static readonly XR_PLAY_AREA_UNKNOWN: int;
+  /**
+   * Play area only supports orientation tracking, no positional tracking, area will center around player.
+   */
+  static readonly XR_PLAY_AREA_3DOF: int;
+  /** Player is in seated position, limited positional tracking, fixed guardian around player. */
+  static readonly XR_PLAY_AREA_SITTING: int;
+  /** Player is free to move around, full positional tracking. */
+  static readonly XR_PLAY_AREA_ROOMSCALE: int;
+  /**
+   * Same as {@link XR_PLAY_AREA_ROOMSCALE} but origin point is fixed to the center of the physical space. In this mode, system-level recentering may be disabled, requiring the use of {@link XRServer.center_on_hmd}.
+   */
+  static readonly XR_PLAY_AREA_STAGE: int;
+  /** Custom play area set by a GDExtension. */
+  static readonly XR_PLAY_AREA_CUSTOM: int;
+  // enum EnvironmentBlendMode
+  /** Opaque blend mode. This is typically used for VR devices. */
+  static readonly XR_ENV_BLEND_MODE_OPAQUE: int;
+  /** Additive blend mode. This is typically used for AR devices or VR devices with passthrough. */
+  static readonly XR_ENV_BLEND_MODE_ADDITIVE: int;
+  /**
+   * Alpha blend mode. This is typically used for AR or VR devices with passthrough capabilities. The alpha channel controls how much of the passthrough is visible. Alpha of 0.0 means the passthrough is visible and this pixel works in ADDITIVE mode. Alpha of 1.0 means that the passthrough is not visible and this pixel works in OPAQUE mode.
+   */
+  static readonly XR_ENV_BLEND_MODE_ALPHA_BLEND: int;
+  // enum VRSTextureFormat
+  /** The texture format is the same as returned by {@link XRVRS.make_vrs_texture}. */
+  static readonly XR_VRS_TEXTURE_FORMAT_UNIFIED: int;
+  /** The texture format is the same as expected by the Vulkan `VK_KHR_fragment_shading_rate` extension. */
+  static readonly XR_VRS_TEXTURE_FORMAT_FRAGMENT_SHADING_RATE: int;
+  /** The texture format is the same as expected by the Vulkan `VK_EXT_fragment_density_map` extension. */
+  static readonly XR_VRS_TEXTURE_FORMAT_FRAGMENT_DENSITY_MAP: int;
+}