typescript-to-gdscript 0.1.0

package/typings/classes/XRInterfaceExtension.d.ts

@@ -0,0 +1,94 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for XR interface extensions (plugins). */
+declare class XRInterfaceExtension extends XRInterface {
+  /** Called if interface is active and queues have been submitted. */
+  _end_frame(): void;
+  /** Return `true` if anchor detection is enabled for this interface. */
+  _get_anchor_detection_is_enabled(): boolean;
+  /**
+   * Returns the camera feed ID for the {@link CameraFeed} registered with the {@link CameraServer} that should be presented as the background on an AR capable device (if applicable).
+   */
+  _get_camera_feed_id(): int;
+  /** Returns the {@link Transform3D} that positions the {@link XRCamera3D} in the world. */
+  _get_camera_transform(): Transform3D;
+  /** Returns the capabilities of this interface. */
+  _get_capabilities(): int;
+  /** Return color texture into which to render (if applicable). */
+  _get_color_texture(): RID;
+  /** Return depth texture into which to render (if applicable). */
+  _get_depth_texture(): RID;
+  /** Returns the name of this interface. */
+  _get_name(): string;
+  /** Returns a {@link PackedVector3Array} that represents the play areas boundaries (if applicable). */
+  _get_play_area(): PackedVector3Array;
+  /** Returns the play area mode that sets up our play area. */
+  _get_play_area_mode(): int;
+  /** Returns the projection matrix for the given view as a {@link PackedFloat64Array}. */
+  _get_projection_for_view(view: int, aspect: float, z_near: float, z_far: float): PackedFloat64Array;
+  /**
+   * Returns the size of our render target for this interface, this overrides the size of the {@link Viewport} marked as the xr viewport.
+   */
+  _get_render_target_size(): Vector2;
+  /**
+   * Returns a {@link PackedStringArray} with pose names configured by this interface. Note that user configuration can override this list.
+   */
+  _get_suggested_pose_names(tracker_name: string): PackedStringArray;
+  /**
+   * Returns a {@link PackedStringArray} with tracker names configured by this interface. Note that user configuration can override this list.
+   */
+  _get_suggested_tracker_names(): PackedStringArray;
+  /** Returns a {@link Dictionary} with system information related to this interface. */
+  _get_system_info(): Dictionary;
+  /** Returns the current status of our tracking. */
+  _get_tracking_status(): int;
+  /** Returns a {@link Transform3D} for a given view. */
+  _get_transform_for_view(view: int, cam_transform: Transform3D | Projection): Transform3D;
+  /** Return velocity texture into which to render (if applicable). */
+  _get_velocity_texture(): RID;
+  /** Returns the number of views this interface requires, 1 for mono, 2 for stereoscopic. */
+  _get_view_count(): int;
+  _get_vrs_texture(): RID;
+  /** Returns the format of the texture returned by {@link _get_vrs_texture}. */
+  _get_vrs_texture_format(): int;
+  /** Initializes the interface, returns `true` on success. */
+  _initialize(): boolean;
+  /** Returns `true` if this interface has been initialized. */
+  _is_initialized(): boolean;
+  /** Called after the XR {@link Viewport} draw logic has completed. */
+  _post_draw_viewport(render_target: RID, screen_rect: Rect2 | Rect2i): void;
+  /**
+   * Called if this is our primary {@link XRInterfaceExtension} before we start processing a {@link Viewport} for every active XR {@link Viewport}, returns `true` if that viewport should be rendered. An XR interface may return `false` if the user has taken off their headset and we can pause rendering.
+   */
+  _pre_draw_viewport(render_target: RID): boolean;
+  /**
+   * Called if this {@link XRInterfaceExtension} is active before rendering starts. Most XR interfaces will sync tracking at this point in time.
+   */
+  _pre_render(): void;
+  /**
+   * Called if this {@link XRInterfaceExtension} is active before our physics and game process is called. Most XR interfaces will update its {@link XRPositionalTracker}s at this point in time.
+   */
+  _process(): void;
+  /** Enables anchor detection on this interface if supported. */
+  _set_anchor_detection_is_enabled(enabled: boolean): void;
+  /** Set the play area mode for this interface. */
+  _set_play_area_mode(mode: int): boolean;
+  /** Returns `true` if this interface supports this play area mode. */
+  _supports_play_area_mode(mode: int): boolean;
+  /** Triggers a haptic pulse to be emitted on the specified tracker. */
+  _trigger_haptic_pulse(action_name: string | NodePath, tracker_name: string, frequency: float, amplitude: float, duration_sec: float, delay_sec: float): void;
+  /** Uninitialize the interface. */
+  _uninitialize(): void;
+  /**
+   * Blits our render results to screen optionally applying lens distortion. This can only be called while processing `_commit_views`.
+   */
+  add_blit(render_target: RID, src_rect: Rect2 | Rect2i, dst_rect: Rect2i | Rect2, use_layer: boolean, layer: int, apply_lens_distortion: boolean, eye_center: Vector2 | Vector2i, k1: float, k2: float, upscale: float, aspect_ratio: float): void;
+  get_color_texture(): RID;
+  get_depth_texture(): RID;
+  /**
+   * Returns a valid {@link RID} for a texture to which we should render the current frame if supported by the interface.
+   */
+  get_render_target_texture(render_target: RID): RID;
+  get_velocity_texture(): RID;
+}

package/typings/classes/XRNode3D.d.ts

@@ -0,0 +1,46 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D node that has its position automatically updated by the {@link XRServer}. */
+declare class XRNode3D extends Node3D {
+  /**
+   * <member name="pose" type="StringName" setter="set_pose_name" getter="get_pose_name" default="&&quot;default&quot;">
+   * The name of the pose we're bound to. Which poses a tracker supports is not known during design time.
+   * Godot defines number of standard pose names such as `aim` and `grip` but other may be configured within a given {@link XRInterface}.
+   */
+  physics_interpolation_mode: int;
+  /** Enables showing the node when tracking starts, and hiding the node when tracking is lost. */
+  show_when_tracked: boolean;
+  /**
+   * The name of the tracker we're bound to. Which trackers are available is not known during design time.
+   * Godot defines a number of standard trackers such as `left_hand` and `right_hand` but others may be configured within a given {@link XRInterface}.
+   */
+  tracker: string;
+  set_show_when_tracked(value: boolean): void;
+  get_show_when_tracked(): boolean;
+  set_tracker(value: string): void;
+  get_tracker(): string;
+
+  /** Returns `true` if the {@link tracker} has current tracking data for the {@link pose} being tracked. */
+  get_has_tracking_data(): boolean;
+  /** Returns `true` if the {@link tracker} has been registered and the {@link pose} is being tracked. */
+  get_is_active(): boolean;
+  /**
+   * Returns the {@link XRPose} containing the current state of the pose being tracked. This gives access to additional properties of this pose.
+   */
+  get_pose(): XRPose | null;
+  /**
+   * Triggers a haptic pulse on a device associated with this interface.
+   * `action_name` is the name of the action for this pulse.
+   * `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, frequency: float, amplitude: float, duration_sec: float, delay_sec: float): void;
+
+  /**
+   * Emitted when the {@link tracker} starts or stops receiving updated tracking data for the {@link pose} being tracked. The `tracking` argument indicates whether the tracker is getting updated tracking data.
+   */
+  tracking_changed: Signal<[boolean]>;
+}

package/typings/classes/XROrigin3D.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** The origin point in AR/VR. */
+declare class XROrigin3D extends Node3D {
+  /**
+   * If `true`, this origin node is currently being used by the {@link XRServer}. Only one origin point can be used at a time.
+   */
+  current: boolean;
+  /**
+   * The scale of the game world compared to the real world. This is the same as {@link XRServer.world_scale}. By default, most AR/VR platforms assume that 1 game unit corresponds to 1 real world meter.
+   */
+  world_scale: float;
+  set_current(value: boolean): void;
+  is_current(): boolean;
+  set_world_scale(value: float): void;
+  get_world_scale(): float;
+}

package/typings/classes/XRPose.d.ts

@@ -0,0 +1,55 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** This object contains all data related to a pose on a tracked object. */
+declare class XRPose extends RefCounted {
+  /** The angular velocity for this pose. */
+  angular_velocity: Vector3;
+  /**
+   * If `true` our tracking data is up to date. If `false` we're no longer receiving new tracking data and our state is whatever that last valid state was.
+   */
+  has_tracking_data: boolean;
+  /** The linear velocity of this pose. */
+  linear_velocity: Vector3;
+  /**
+   * The name of this pose. Usually, this name is derived from an action map set up by the user. Godot also suggests some pose names that {@link XRInterface} objects are expected to implement:
+   * - `root` is the root location, often used for tracked objects that do not have further nodes.
+   * - `aim` is the tip of a controller with its orientation pointing outwards, often used for raycasts.
+   * - `grip` is the location where the user grips the controller.
+   * - `skeleton` is the root location for a hand mesh, when using hand tracking and an animated skeleton is supplied by the XR runtime.
+   */
+  name: string;
+  /**
+   * The tracking confidence for this pose, provides insight on how accurate the spatial positioning of this record is.
+   */
+  tracking_confidence: int;
+  /** The transform containing the original and transform as reported by the XR runtime. */
+  transform: Transform3D;
+  set_angular_velocity(value: Vector3 | Vector3i): void;
+  get_angular_velocity(): Vector3;
+  set_has_tracking_data(value: boolean): void;
+  get_has_tracking_data(): boolean;
+  set_linear_velocity(value: Vector3 | Vector3i): void;
+  get_linear_velocity(): Vector3;
+  set_name(value: string): void;
+  get_name(): string;
+  set_tracking_confidence(value: int): void;
+  get_tracking_confidence(): int;
+  set_transform(value: Transform3D | Projection): void;
+  get_transform(): Transform3D;
+
+  /**
+   * Returns the {@link transform} with world scale and our reference frame applied. This is the transform used to position {@link XRNode3D} objects.
+   */
+  get_adjusted_transform(): Transform3D;
+
+  // enum TrackingConfidence
+  /** No tracking information is available for this pose. */
+  static readonly XR_TRACKING_CONFIDENCE_NONE: int;
+  /**
+   * Tracking information may be inaccurate or estimated. For example, with inside out tracking this would indicate a controller may be (partially) obscured.
+   */
+  static readonly XR_TRACKING_CONFIDENCE_LOW: int;
+  /** Tracking information is considered accurate and up to date. */
+  static readonly XR_TRACKING_CONFIDENCE_HIGH: int;
+}

package/typings/classes/XRPositionalTracker.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A tracked object. */
+declare class XRPositionalTracker extends XRTracker {
+  /** Defines which hand this tracker relates to. */
+  hand: int;
+  /**
+   * The profile associated with this tracker, interface dependent but will indicate the type of controller being tracked.
+   */
+  profile: string;
+  set_tracker_hand(value: int): void;
+  get_tracker_hand(): int;
+  set_tracker_profile(value: string | NodePath): void;
+  get_tracker_profile(): string;
+
+  /**
+   * Returns an input for this tracker. It can return a boolean, float or {@link Vector2} value depending on whether the input is a button, trigger or thumbstick/thumbpad.
+   */
+  get_input(name: string): unknown;
+  /** Returns the current {@link XRPose} state object for the bound `name` pose. */
+  get_pose(name: string): XRPose | null;
+  /** Returns `true` if the tracker is available and is currently tracking the bound `name` pose. */
+  has_pose(name: string): boolean;
+  /**
+   * Marks this pose as invalid, we don't clear the last reported state but it allows users to decide if trackers need to be hidden if we lose tracking or just remain at their last known position.
+   */
+  invalidate_pose(name: string): void;
+  /**
+   * Changes the value for the given input. This method is called by an {@link XRInterface} implementation and should not be used directly.
+   */
+  set_input(name: string, value: unknown): void;
+  /**
+   * Sets the transform, linear velocity, angular velocity and tracking confidence for the given pose. This method is called by an {@link XRInterface} implementation and should not be used directly.
+   */
+  set_pose(name: string, transform: Transform3D | Projection, linear_velocity: Vector3 | Vector3i, angular_velocity: Vector3 | Vector3i, tracking_confidence: int): void;
+
+  /**
+   * Emitted when a button on this tracker is pressed. Note that many XR runtimes allow other inputs to be mapped to buttons.
+   */
+  button_pressed: Signal<[string]>;
+  /** Emitted when a button on this tracker is released. */
+  button_released: Signal<[string]>;
+  /** Emitted when a trigger or similar input on this tracker changes value. */
+  input_float_changed: Signal<[string, float]>;
+  /** Emitted when a thumbstick or thumbpad on this tracker moves. */
+  input_vector2_changed: Signal<[string, Vector2]>;
+  /** Emitted when the state of a pose tracked by this tracker changes. */
+  pose_changed: Signal<[XRPose]>;
+  /** Emitted when a pose tracked by this tracker stops getting updated tracking data. */
+  pose_lost_tracking: Signal<[XRPose]>;
+  /** Emitted when the profile of our tracker changes. */
+  profile_changed: Signal<[string]>;
+
+  // enum TrackerHand
+  /** The hand this tracker is held in is unknown or not applicable. */
+  static readonly TRACKER_HAND_UNKNOWN: int;
+  /** This tracker is the left hand controller. */
+  static readonly TRACKER_HAND_LEFT: int;
+  /** This tracker is the right hand controller. */
+  static readonly TRACKER_HAND_RIGHT: int;
+  /** Represents the size of the {@link TrackerHand} enum. */
+  static readonly TRACKER_HAND_MAX: int;
+}

package/typings/classes/XRServer.d.ts

@@ -0,0 +1,130 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Server for AR and VR features. */
+declare interface XRServer extends GodotObject {
+  /**
+   * If set to `true`, the scene will be rendered as if the camera is locked to the {@link XROrigin3D}.
+   * **Note:** This doesn't provide a very comfortable experience for users. This setting exists for doing benchmarking or automated testing, where you want to control what is rendered via code.
+   */
+  camera_locked_to_origin: boolean;
+  /** The primary {@link XRInterface} currently bound to the {@link XRServer}. */
+  primary_interface: XRInterface | null;
+  /**
+   * The current origin of our tracking space in the virtual world. This is used by the renderer to properly position the camera with new tracking data.
+   * **Note:** This property is managed by the current {@link XROrigin3D} node. It is exposed for access from GDExtensions.
+   */
+  world_origin: Transform3D;
+  /**
+   * The scale of the game world compared to the real world. By default, most AR/VR platforms assume that 1 game unit corresponds to 1 real world meter.
+   */
+  world_scale: float;
+  set_camera_locked_to_origin(value: boolean): void;
+  is_camera_locked_to_origin(): boolean;
+  set_primary_interface(value: XRInterface | null): void;
+  get_primary_interface(): XRInterface | null;
+  set_world_origin(value: Transform3D | Projection): void;
+  get_world_origin(): Transform3D;
+  set_world_scale(value: float): void;
+  get_world_scale(): float;
+
+  /** Registers an {@link XRInterface} object. */
+  add_interface(interface_: XRInterface): void;
+  /** Registers a new {@link XRTracker} that tracks a physical object. */
+  add_tracker(tracker: XRTracker): void;
+  /**
+   * This is an important function to understand correctly. AR and VR platforms all handle positioning slightly differently.
+   * For platforms that do not offer spatial tracking, our origin point `(0, 0, 0)` is the location of our HMD, but you have little control over the direction the player is facing in the real world.
+   * For platforms that do offer spatial tracking, our origin point depends very much on the system. For OpenVR, our origin point is usually the center of the tracking space, on the ground. For other platforms, it's often the location of the tracking camera.
+   * This method allows you to center your tracker on the location of the HMD. It will take the current location of the HMD and use that to adjust all your tracking data; in essence, realigning the real world to your player's current position in the game world.
+   * For this method to produce usable results, tracking information must be available. This often takes a few frames after starting your game.
+   * You should call this method after a few seconds have passed. For example, when the user requests a realignment of the display holding a designated button on a controller for a short period of time, or when implementing a teleport mechanism.
+   */
+  center_on_hmd(rotation_mode: int, keep_height: boolean): void;
+  /** Clears the reference frame that was set by previous calls to {@link center_on_hmd}. */
+  clear_reference_frame(): void;
+  /**
+   * Finds an interface by its `name`. For example, if your project uses capabilities of an AR/VR platform, you can find the interface for that platform by name and initialize it.
+   */
+  find_interface(name: string | NodePath): XRInterface | null;
+  /** Returns the primary interface's transformation. */
+  get_hmd_transform(): Transform3D;
+  /** Returns the interface registered at the given `idx` index in the list of interfaces. */
+  get_interface(idx: int): XRInterface | null;
+  /**
+   * Returns the number of interfaces currently registered with the AR/VR server. If your project supports multiple AR/VR platforms, you can look through the available interface, and either present the user with a selection or simply try to initialize each interface and use the first one that returns `true`.
+   */
+  get_interface_count(): int;
+  /** Returns a list of available interfaces the ID and name of each interface. */
+  get_interfaces(): Array<Dictionary>;
+  /**
+   * Returns the reference frame transform. Mostly used internally and exposed for GDExtension build interfaces.
+   */
+  get_reference_frame(): Transform3D;
+  /** Returns the positional tracker with the given `tracker_name`. */
+  get_tracker(tracker_name: string): XRTracker | null;
+  /** Returns a dictionary of trackers for `tracker_types`. */
+  get_trackers(tracker_types: int): Dictionary;
+  /** Removes this `interface`. */
+  remove_interface(interface_: XRInterface): void;
+  /** Removes this `tracker`. */
+  remove_tracker(tracker: XRTracker): void;
+
+  /** Emitted when a new interface has been added. */
+  interface_added: Signal<[string]>;
+  /** Emitted when an interface is removed. */
+  interface_removed: Signal<[string]>;
+  /** Emitted when the reference frame transform changes. */
+  reference_frame_changed: Signal<[]>;
+  /**
+   * Emitted when a new tracker has been added. If you don't use a fixed number of controllers or if you're using {@link XRAnchor3D}s for an AR solution, it is important to react to this signal to add the appropriate {@link XRController3D} or {@link XRAnchor3D} nodes related to this new tracker.
+   */
+  tracker_added: Signal<[string, int]>;
+  /**
+   * Emitted when a tracker is removed. You should remove any {@link XRController3D} or {@link XRAnchor3D} points if applicable. This is not mandatory, the nodes simply become inactive and will be made active again when a new tracker becomes available (i.e. a new controller is switched on that takes the place of the previous one).
+   */
+  tracker_removed: Signal<[string, int]>;
+  /**
+   * Emitted when an existing tracker has been updated. This can happen if the user switches controllers.
+   */
+  tracker_updated: Signal<[string, int]>;
+  /** Emitted when the world origin transform changes. */
+  world_origin_changed: Signal<[]>;
+
+  // enum TrackerType
+  /**
+   * The tracker tracks the location of the player's head. This is usually a location centered between the player's eyes. Note that for handheld AR devices this can be the current location of the device.
+   */
+  readonly TRACKER_HEAD: int;
+  /** The tracker tracks the location of a controller. */
+  readonly TRACKER_CONTROLLER: int;
+  /** The tracker tracks the location of a base station. */
+  readonly TRACKER_BASESTATION: int;
+  /** The tracker tracks the location and size of an AR anchor. */
+  readonly TRACKER_ANCHOR: int;
+  /** The tracker tracks the location and joints of a hand. */
+  readonly TRACKER_HAND: int;
+  /** The tracker tracks the location and joints of a body. */
+  readonly TRACKER_BODY: int;
+  /** The tracker tracks the expressions of a face. */
+  readonly TRACKER_FACE: int;
+  /** Used internally to filter trackers of any known type. */
+  readonly TRACKER_ANY_KNOWN: int;
+  /** Used internally if we haven't set the tracker type yet. */
+  readonly TRACKER_UNKNOWN: int;
+  /** Used internally to select all trackers. */
+  readonly TRACKER_ANY: int;
+  // enum RotationMode
+  /**
+   * Fully reset the orientation of the HMD. Regardless of what direction the user is looking to in the real world. The user will look dead ahead in the virtual world.
+   */
+  readonly RESET_FULL_ROTATION: int;
+  /**
+   * Resets the orientation but keeps the tilt of the device. So if we're looking down, we keep looking down but heading will be reset.
+   */
+  readonly RESET_BUT_KEEP_TILT: int;
+  /** Does not reset the orientation of the HMD, only the position of the player gets centered. */
+  readonly DONT_RESET_ROTATION: int;
+}
+declare const XRServer: XRServer;
+

package/typings/classes/XRTracker.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A tracked object. */
+declare class XRTracker extends RefCounted {
+  /** The description of this tracker. */
+  description: string;
+  /**
+   * The unique name of this tracker. The trackers that are available differ between various XR runtimes and can often be configured by the user. Godot maintains a number of reserved names that it expects the {@link XRInterface} to implement if applicable:
+   * - `"head"` identifies the {@link XRPositionalTracker} of the player's head
+   * - `"left_hand"` identifies the {@link XRControllerTracker} in the player's left hand
+   * - `"right_hand"` identifies the {@link XRControllerTracker} in the player's right hand
+   * - `"/user/hand_tracker/left"` identifies the {@link XRHandTracker} for the player's left hand
+   * - `"/user/hand_tracker/right"` identifies the {@link XRHandTracker} for the player's right hand
+   * - `"/user/body_tracker"` identifies the {@link XRBodyTracker} for the player's body
+   * - `"/user/face_tracker"` identifies the {@link XRFaceTracker} for the player's face
+   */
+  name: string;
+  /** The type of tracker. */
+  type: int;
+  set_tracker_desc(value: string | NodePath): void;
+  get_tracker_desc(): string;
+  set_tracker_name(value: string): void;
+  get_tracker_name(): string;
+  set_tracker_type(value: int): void;
+  get_tracker_type(): int;
+}

package/typings/classes/XRVRS.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Helper class for XR interfaces that generates VRS images. */
+declare class XRVRS extends GodotObject {
+  /**
+   * The minimum radius around the focal point where full quality is guaranteed if VRS is used as a percentage of screen size.
+   */
+  vrs_min_radius: float;
+  /** The render region that the VRS texture will be scaled to when generated. */
+  vrs_render_region: Rect2i;
+  /**
+   * The strength used to calculate the VRS density map. The greater this value, the more noticeable VRS is.
+   */
+  vrs_strength: float;
+  set_vrs_min_radius(value: float): void;
+  get_vrs_min_radius(): float;
+  set_vrs_render_region(value: Rect2i | Rect2): void;
+  get_vrs_render_region(): Rect2i;
+  set_vrs_strength(value: float): void;
+  get_vrs_strength(): float;
+
+  /**
+   * Generates the VRS texture based on a render `target_size` adjusted by our VRS tile size. For each eyes focal point passed in `eye_foci` a layer is created. Focal point should be in NDC.
+   * The result will be cached, requesting a VRS texture with unchanged parameters and settings will return the cached RID.
+   */
+  make_vrs_texture(target_size: Vector2 | Vector2i, eye_foci: PackedVector2Array | Array<unknown>): RID;
+}