Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

XRInterface

Hérite de : RefCounted < Object

Hérité par : MobileVRInterface, OpenXRInterface, WebXRInterface, XRInterfaceExtension

Classe de base pour une implémentation d’interface XR.

Description

This class needs to be implemented to make an AR or VR platform available to Godot and these should be implemented as C++ modules or GDExtension modules. Part of the interface is exposed to GDScript so you can detect, enable and configure an AR or VR platform.

Interfaces should be written in such a way that simply enabling them will give us a working setup. You can query the available interfaces through XRServer.

Tutoriels

Index de la documentation sur la XR

Propriétés

bool	ar_is_anchor_detection_enabled	`false`
EnvironmentBlendMode	environment_blend_mode	`0`
bool	interface_is_primary	`false`
PlayAreaMode	xr_play_area_mode	`0`

Méthodes

int	get_camera_feed_id()
int	get_capabilities() const
StringName	get_name() const
PackedVector3Array	get_play_area() const
Projection	get_projection_for_view(view: int, aspect: float, near: float, far: float)
Vector2	get_render_target_size()
Array	get_supported_environment_blend_modes()
Dictionary	get_system_info()
TrackingStatus	get_tracking_status() const
Transform3D	get_transform_for_view(view: int, cam_transform: Transform3D)
int	get_view_count()
bool	initialize()
bool	is_initialized() const
bool	is_passthrough_enabled()
bool	is_passthrough_supported()
bool	set_environment_blend_mode(mode: EnvironmentBlendMode)
bool	set_play_area_mode(mode: PlayAreaMode)
bool	start_passthrough()
void	stop_passthrough()
bool	supports_play_area_mode(mode: PlayAreaMode)
void	trigger_haptic_pulse(action_name: String, tracker_name: StringName, frequency: float, amplitude: float, duration_sec: float, delay_sec: float)
void	uninitialize()

Signaux

play_area_changed(mode: int) 🔗

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.

Énumérations

enum Capabilities: 🔗

Capabilities XR_NONE = 0

Pas de capacité XR.

Capabilities XR_MONO = 1

Cette interface peut fonctionner avec la sortie de rendu normale (AR non basée sur HMD).

Capabilities XR_STEREO = 2

Cette interface est compatible avec le rendu stéréoscopique.

Capabilities XR_QUAD = 4

Cette interface supporte le quad rendering (pas encore supporté par Godot).

Capabilities XR_VR = 8

Cette interface supporte la VR.

Capabilities XR_AR = 16

Cette interface supporte la AR (arrière-plan vidéo et suivi du monde réel).

Capabilities XR_EXTERNAL = 32

Cette interface envoie sa sortie vers un périphérique externe. Si le viewport principal est utilisé, la sortie à l'écran est un buffer non modifié de l'œil gauche ou droit (étiré si la taille du viewport n'est pas changée au même rapport d'aspect que get_render_target_size()). L'utilisation d'un nœud Viewport séparé libère le viewport principal pour être utilisé pour autre chose.

enum TrackingStatus: 🔗

TrackingStatus XR_NORMAL_TRACKING = 0

Le suivi se comporte comme prévu.

TrackingStatus XR_EXCESSIVE_MOTION = 1

Le suivi est gêné par un mouvement excessif (le joueur se déplace trop vite par rapport à ce que le suivi peut suivre).

TrackingStatus XR_INSUFFICIENT_FEATURES = 2

Le suivi est gêné par des caractéristiques insuffisantes, il fait trop sombre (pour du suivi par caméra), le joueur est bloqué, etc...

TrackingStatus XR_UNKNOWN_TRACKING = 3

Nous ne connaissons pas l'état du suivi, ou alors cette interface ne fournit aucune indication.

TrackingStatus XR_NOT_TRACKING = 4

Le suivi n'est pas fonctionnel (la caméra n'est pas branchée ou cachée, les lumières sont éteintes, etc.).

enum PlayAreaMode: 🔗

PlayAreaMode XR_PLAY_AREA_UNKNOWN = 0

Mode de zone de jeu non défini ou non disponible.

PlayAreaMode XR_PLAY_AREA_3DOF = 1

La zone de jeu ne supporte que le suivi de l'orientation, pas le suivi positionnel, la zone se centrera autour du joueur.

PlayAreaMode XR_PLAY_AREA_SITTING = 2

Le joueur est en position assise, avec suivi positionnel limité, avec des limites ("Guardian") fixes autour du joueur.

PlayAreaMode XR_PLAY_AREA_ROOMSCALE = 3

Le joueur est libre de se déplacer, suivi positionnel complet.

PlayAreaMode XR_PLAY_AREA_STAGE = 4

Comme XR_PLAY_AREA_ROOMSCALE mais le point d'origine est fixé au centre de l'espace physique. Dans ce mode, le recentrage au niveau du système peut être désactivé, nécessitant l'utilisation de XRServer.center_on_hmd().

PlayAreaMode XR_PLAY_AREA_CUSTOM = 2147483647

Aire de jeu personnalisée définie par une GDExtension.

enum EnvironmentBlendMode: 🔗

EnvironmentBlendMode XR_ENV_BLEND_MODE_OPAQUE = 0

Mode de mélange opaque. Ceci est généralement utilisé pour les appareils VR.

EnvironmentBlendMode XR_ENV_BLEND_MODE_ADDITIVE = 1

Mode de mélange additif. Ceci est généralement utilisé pour les appareils AR ou les appareils VR avec passthrough.

EnvironmentBlendMode XR_ENV_BLEND_MODE_ALPHA_BLEND = 2

Mode de mélange alpha. Ceci est généralement utilisé pour les appareils AR ou VR avec des capacités de passthrough. Le canal alpha contrôle à quel point le passthrough est visible. Un alpha de 0.0 signifie que le passthrough est visible et ce pixel fonctionne en mode ADDITIVE. Un alpha de 1.0 signifie que le passthrough n'est pas visible et que ce pixel fonctionne en mode OPAQUE.

enum VRSTextureFormat: 🔗

VRSTextureFormat XR_VRS_TEXTURE_FORMAT_UNIFIED = 0

Le format de texture est le même que celle renvoyée par XRVRS.make_vrs_texture().

VRSTextureFormat XR_VRS_TEXTURE_FORMAT_FRAGMENT_SHADING_RATE = 1

Le format de texture est le même qu'attendu par l'extension Vulkan VK_KHR_fragment_shading_rate.

VRSTextureFormat XR_VRS_TEXTURE_FORMAT_FRAGMENT_DENSITY_MAP = 2

Le format de texture est le même qu'attendu par l'extension Vulkan VK_EXT_fragment_density_map.

Descriptions des propriétés

bool ar_is_anchor_detection_enabled = false 🔗

void set_anchor_detection_is_enabled(value: bool)
bool get_anchor_detection_is_enabled()

Sur une interface AR, true si la détection d’ancrage est activée.

EnvironmentBlendMode environment_blend_mode = 0 🔗

bool set_environment_blend_mode(mode: EnvironmentBlendMode)
EnvironmentBlendMode get_environment_blend_mode()

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.

bool interface_is_primary = false 🔗

void set_primary(value: bool)
bool is_primary()

true (vrai) si c'est l'interface principale.

PlayAreaMode xr_play_area_mode = 0 🔗

bool set_play_area_mode(mode: PlayAreaMode)
PlayAreaMode get_play_area_mode()

Le mode de zone de jeu pour cette interface.

Descriptions des méthodes

int get_camera_feed_id() 🔗

S’il s’agit d’une interface AR qui nécessite l’affichage d’un flux de caméra en arrière-plan, cette méthode renvoie l’ID de flux dans le CameraServer pour cette interface.

int get_capabilities() const 🔗

Renvoie une combinaison d’indicateurs Capabilities fournissant des informations sur les capacités de cette interface.

StringName get_name() const 🔗

Renvoie le nom de cette interface ("OpenXR", "OpenVR", "OpenHMD", "ARKit", etc.).

PackedVector3Array get_play_area() const 🔗

Returns an array of vectors that represent the physical play area mapped to the virtual space around the 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.

Projection get_projection_for_view(view: int, aspect: float, near: float, far: float) 🔗

Renvoie la matrice de projection pour un(e) vue/œil.

Vector2 get_render_target_size() 🔗

Renvoie la résolution à laquelle nous devrions rendre nos résultats intermédiaires avant que des choses comme la distorsion des lentilles ne soient appliquées par la plate-forme VR.

Array get_supported_environment_blend_modes() 🔗

Returns the an array of supported environment blend modes, see EnvironmentBlendMode.

Dictionary get_system_info() 🔗

Renvoie un Dictionary avec des informations supplémentaires sur le système. Les interfaces sont censées renvoyer XRRuntimeName et XRRuntimeVersion fournissant des informations sur le runtime XR utilisé. Des entrées supplémentaires peuvent être fournies spécifiquement pour une interface.

Note :Cette information peut n'être disponible qu'après que initialize() ait été appelé avec succès.

TrackingStatus get_tracking_status() const 🔗

Si supporté, renvoie l'état de notre suivi. Cela vous permettra de fournir un retour à l'utilisateur s'il y a des problèmes avec le suivi de position.

Transform3D get_transform_for_view(view: int, cam_transform: Transform3D) 🔗

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 Node3D.global_transform of the current XROrigin3D.

int get_view_count() 🔗

Renvoie le nombre de vues qui doivent être rendues pour cet appareil. 1 en Monoscopique, 2 en Stéréoscopique.

bool initialize() 🔗

Appelez ceci pour initialiser cette interface. La première interface qui est initialisée est identifiée comme l'interface primaire et elle sera utilisée pour faire le rendu de la sortie.

Après l'initialisation de l'interface que vous souhaitez utiliser, vous devez activer le mode AR/VR d'un viewport et le rendu devrait commencer.

Note : Vous devez activer le mode XR sur le viewport principal pour tout appareil qui utilise la sortie principale de Godot, comme pour la VR mobile.

Si vous faites cela pour une plate-forme qui gère sa propre sortie (comme OpenVR), Godot affichera juste un des yeux sans distorsion à l'écran. Alternativement, vous pouvez ajouter un nœud viewport séparé à votre scène et activer AR/VR sur ce viewport. Il sera utilisée pour la sortie du HMD, vous permettant d'utiliser la fenêtre principale pour tout autre utilisation, comme l'utilisation d'une caméra séparée comme pour un spectateur ou faire un rendu complètement différent.

Bien que non utilisé pour l'instant, vous pouvez activer des interfaces supplémentaires. Vous pouvez le faire si vous voulez suivre les contrôleurs d'autres plateformes. Cependant, actuellement, une seule interface peut rendre vers un HMD.

bool is_initialized() const 🔗

Renvoie true si cette interface a été initialisée.

bool is_passthrough_enabled() 🔗

Obsolète : Check if environment_blend_mode is XR_ENV_BLEND_MODE_ALPHA_BLEND, instead.

Renvoie true si le passthrough est activé.

bool is_passthrough_supported() 🔗

Obsolète : Check that XR_ENV_BLEND_MODE_ALPHA_BLEND is supported using get_supported_environment_blend_modes(), instead.

Renvoie true si cette interface supporte le passthrough.

bool set_environment_blend_mode(mode: EnvironmentBlendMode) 🔗

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:

func _ready():
    var xr_interface = XRServer.find_interface("OpenXR")
    if xr_interface and xr_interface.is_initialized():
        var vp = get_viewport()
        vp.use_xr = true
        var acceptable_modes = [XRInterface.XR_ENV_BLEND_MODE_OPAQUE, XRInterface.XR_ENV_BLEND_MODE_ADDITIVE]
        var modes = xr_interface.get_supported_environment_blend_modes()
        for mode in acceptable_modes:
            if mode in modes:
                xr_interface.set_environment_blend_mode(mode)
                break

bool set_play_area_mode(mode: PlayAreaMode) 🔗

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 XRServer.center_on_hmd() (if switching to XR_PLAY_AREA_STAGE) or make the switch during a scene change.

bool start_passthrough() 🔗

Obsolète : Set the environment_blend_mode to XR_ENV_BLEND_MODE_ALPHA_BLEND, instead.

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.

void stop_passthrough() 🔗

Obsolète : Set the environment_blend_mode to XR_ENV_BLEND_MODE_OPAQUE, instead.

Arrête de passer à travers.

bool supports_play_area_mode(mode: PlayAreaMode) 🔗

Call this to find out if a given play area mode is supported by this interface.

void trigger_haptic_pulse(action_name: String, tracker_name: StringName, frequency: float, amplitude: float, duration_sec: float, delay_sec: float) 🔗

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.

void uninitialize() 🔗

Désactive l'interface.