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...

Mise en place de la XR

Présentation du système XR dans Godot

Godot fournit un système XR modulaire qui abstrait plusieurs des différentes plateformes XR spécifiques hors de l'utilisateur. Au cœur se trouve le XRServer qui agit comme une interface centrale au système XR qui permet aux utilisateurs de découvrir des interfaces et d'interagir avec les composants du système XR.

Each supported XR platform is implemented as an XRInterface. A list of supported platforms can be found on the list of features page here. Supported interfaces register themselves with the XRServer and can be queried with the find_interface method on the XRServer. When the desired interface is found it can be initialized by calling initialize on the interface.

Avertissement

Une interface enregistrée ne signifie rien de plus que l'interface est disponible, si l'interface n'est pas supportée par le système hôte, l'initialisation peut échouer et retourner false. Cela peut avoir de nombreuses raisons et malheureusement les raisons diffèrent de plate-forme à plate-forme. Cela peut être parce que l'utilisateur n'a pas installé le logiciel requis, ou que l'utilisateur n'a tout simplement pas branché son casque. En tant que développeur, vous devez donc réagir correctement lorsqu'une interface ne démarre pas.

En raison des exigences particulières pour la sortie en XR, en particulier pour les dispositifs montés sur la tête qui fournissent une image différente à chaque oeil, le XRServer de Godot remplacera diverses caractéristiques dans le système de rendu. Pour les appareils autonomes, cela signifie que la sortie finale est gérée par le XRInterface et le système de sortie habituel de Godot est désactivé. Pour les appareils XR de bureau qui fonctionnent comme un second écran, il est possible de dédier un Viewport séparé pour manipuler la sortie XR, laissant la fenêtre principale Godot disponible pour afficher du contenu alternatif.

Note

Notez que seule une interface peut être responsable de la manipulation de la sortie vers un périphérique XR, celle-ci est connue comme l'interface primaire et par défaut sera la première interface qui est initialisée. Godot ne supporte actuellement que les implémentations avec un seul casque. Il est possible, mais de plus en plus rare, d'avoir une interface secondaire, par exemple pour ajouter le suivi à un autre périphérique uniquement 3DOF (3 degrés de liberté de mouvement).

Il existe trois types de nœuds spécifiques XR que vous trouverez dans presque toutes les applications XR :

XROrigin3D représente, à toutes fins et intentions, le point central de votre espace de jeu. C'est une déclaration sursimplifiée, mais nous irons plus en détail plus tard. Tous les objets suivis dans l'espace physique par la plateforme XR sont positionnés par rapport à ce point.
XRCamera3D représente la caméra (stereo) utilisée lors du rendu de la sortie du périphérique XR. Le positionnement de ce nœud est contrôlé par le système XR et mis à jour automatiquement en utilisant les informations de suivi fournies par la plateforme XR.
XRController3D représente un contrôleur utilisé par le joueur, généralement il y en a deux, un dans chaque main. Ces nœuds donnent accès à divers états sur ces contrôleurs et envoient des signaux lorsque le joueur appuie des boutons sur eux. Le positionnement de ce nœud est contrôlé par le système XR et mis à jour automatiquement en utilisant les informations de suivi fournies par la plateforme XR.

Il y a d'autres nœuds liés à la XR et il y a beaucoup plus à dire à propos de ces trois nœuds, mais nous y arriverons plus tard.

Quel Renderer utiliser

Godot a 3 options de moteur de rendu pour les projets : Compatibilité, Mobile et Forward+. La recommandation actuelle est d'utiliser le moteur de rendu Mobile pour tout projet VR de bureau, et d'utiliser le moteur de rendu Compatibilité pour tout projet fonctionnant sur un casque autonome comme le Meta Quest 3. Les projets XR fonctionneront avec le moteur de rendu Forward+, mais il n'est pas bien optimisé pour la XR pour le moment par rapport aux deux autres.

OpenXR

OpenXR is a new industry standard that allows different XR platforms to present themselves through a standardized API to XR applications. This standard is an open standard maintained by the Khronos Group and thus aligns very well with Godot's interests.

L'implémentation Vulkan d'OpenXR est étroitement intégrée avec Vulkan, prenant en charge une partie du système Vulkan. Cela nécessite une intégration étroite de certaines fonctionnalités graphiques de base dans le rendu Vulkan qui sont nécessaires avant la configuration du système XR. C'était l'un des principaux facteurs déterminants pour inclure OpenXR comme interface de base.

Cela signifie également que OpenXR doit être activé lorsque Godot démarre pour régler les choses correctement. Vérifiez le paramètre Enabled dans les paramètres de votre projet sous XR > OpenXR.

Vous pouvez trouver plusieurs autres paramètres liés à OpenXR ici aussi. Ils ne peuvent pas être changés pendant que votre application fonctionne. Les paramètres par défaut nous feront débuter, mais pour plus d'informations sur ce qui se trouve ici voir Paramètres OpenXR.

Vous devrez aussi aller dans XR > Shaders dans les paramètres du projet et vérifier la case Activé pour les activer. Une fois que vous avez fait cela cliquez sur le bouton Sauvegarder & Redémarrer.

Avertissement

De nombreux effets de post-traitement n'ont pas encore été mis à jour pour soutenir le rendu stéréoscopique. L'utilisation de ces effets aura des effets négatifs.

Mise en place de la scène XR

Chaque application XR a besoin d'au moins d'un nœud XROrigin3D et d'un nœud XRCamera3D. La plupart auront deux XRController3D, un pour la main gauche et un pour la droite. Gardez à l'esprit que les nœuds de la caméra et du contrôleur devraient être des enfants du nœud d'origine. Ajoutez ces nœuds à une nouvelle scène et renommez les nœuds du contrôleur à LeftHand et RightHand, votre scène devrait ressembler à ceci :

Les icônes d'avertissement sont attendues et devraient partir après que vous ayez configuré les contrôleurs. Sélectionnez la main gauche et configurez-la comme suit :

Et la main droite :

En ce moment, tous ces nœuds sont sur le sol, ils seront positionnés correctement lors de l'exécution. Pour aider au développement, il peut être utile de déplacer la caméra vers le haut de sorte que son y soit défini à 1.7, et de déplacer les nœuds de contrôleur à -0.5, 1.0, -0.5 et 0.5, 1.0, -0.5 pour respectivement la main gauche et droite.

Ensuite, nous devons ajouter un script à notre nœud racine. Ajoutez le code suivant dans ce script :

extends Node3D

var xr_interface: XRInterface

func _ready():
    xr_interface = XRServer.find_interface("OpenXR")
    if xr_interface and xr_interface.is_initialized():
        print("OpenXR initialized successfully")

        # Turn off v-sync!
        DisplayServer.window_set_vsync_mode(DisplayServer.VSYNC_DISABLED)

        # Change our main viewport to output to the HMD
        get_viewport().use_xr = true
    else:
        print("OpenXR not initialized, please check if your headset is connected")

using Godot;

public partial class MyNode3D : Node3D
{
    private XRInterface _xrInterface;

    public override void _Ready()
    {
        _xrInterface = XRServer.FindInterface("OpenXR");
        if(_xrInterface != null && _xrInterface.IsInitialized())
        {
            GD.Print("OpenXR initialized successfully");

            // Turn off v-sync!
            DisplayServer.WindowSetVsyncMode(DisplayServer.VSyncMode.Disabled);

            // Change our main viewport to output to the HMD
            GetViewport().UseXR = true;
        }
        else
        {
            GD.Print("OpenXR not initialized, please check if your headset is connected");
        }
    }
}

Ce fragment de code suppose que nous utilisons OpenXR, si vous souhaitez utiliser l'une des autres interfaces, vous pouvez modifier l'appel find_interface.

Avertissement

Comme vous pouvez le voir dans le bout de code ci-dessus, nous éteignons la v-sync (synchronisation verticale). Lors de l'utilisation d'OpenXR, vous produisez les résultats de rendu vers un casque qui nous oblige souvent à être à 90Hz ou plus. Si votre moniteur est un moniteur de 60hz et la v-sync est activée, vous limiterez la sortie à 60 images par seconde.

Les interfaces XR comme OpenXR effectuent leur propre synchronisation.

Notez également que par défaut le moteur de physique fonctionne aussi à 60Hz et cela peut entraîner de la physique hachée. Vous devriez définir Engine.physics_ticks_per_second à une valeur supérieure.

Si vous exécutez votre projet à ce moment, tout fonctionnera, mais vous serez dans un monde sombre. Pour terminer notre point de départ, ajoutez un nœud DirectionalLight3D et un nœud WorldEnvironment à votre scène. Vous pouvez également ajouter une instance de maillage en tant qu'enfant de chaque nœud de contrôleur juste pour les visualiser temporairement. Assurez-vous de configurer un ciel dans votre environnement du monde.

Maintenant exécutez votre projet, vous devriez flotter quelque part dans l'espace et être en mesure de regarder autour.

Note

Alors que le changement de niveau traditionnel peut certainement être utilisé avec des applications XR, où cette configuration de scène est répétée dans chaque niveau, la plupart trouvent plus facile de configurer tout une seule fois et charger les niveaux comme sous-scène. Si vous changez les scènes et répliquez la configuration XR dans chacune, assurez-vous de ne pas exécuter initialize plusieurs fois. L'effet peut être imprévisible en fonction de l'interface XR utilisée.

Pour le reste de cette série de tutoriels de base, nous allons créer un jeu qui utilise une seule scène.