Créez un jeu en RA à l'aide de l'API Unity AR Foundation

1. Présentation

ARCore est le framework Google pour créer des expériences de réalité augmentée sur smartphone. Vous pouvez utiliser AR Foundation d'Unity pour créer des applications de RA multiplates-formes.

Ce que vous allez faire

Dans cet atelier de programmation, vous allez créer un jeu simple à l'aide d'AR Foundation. L'objectif du jeu est de collecter des colis à l'aide d'une voiture que vous contrôlez avec votre appareil mobile.

Cependant, cela ne se produira pas dans un monde entièrement virtuel. Vous allez mélanger des atomes physiques et des bits numériques pour créer un nouveau type d'expérience de jeu en créant un jeu qui comprend l'environnement qui entoure le joueur.

À la fin de cet atelier de programmation, votre jeu sera capable de :

• Détectez les avions dans le monde réel et dessinez un terrain de jeu par-dessus.
• Projetez des rayons depuis la vue de la caméra et détectez les intersections avec les plans.
• Réagissez aux conditions d'éclairage réelles pour donner plus de réalisme à votre jeu.

Points abordés

• Configurer un projet qui utilise AR Foundation d'Unity
• Comment utiliser ARPlaneManager pour s'abonner à de nouveaux forfaits ?
• Utiliser Raycast pour trouver des intersections avec la géométrie virtuelle
• Utiliser ARLightEstimationData pour éclairer votre scène.

Prérequis

• Un appareil compatible ARCore, connecté à votre ordinateur de développement à l'aide d'un câble USB.
• Services Google Play pour la RA version 1.23 ou ultérieure.
• Une installation de Unity Hub ou Unity 2020 LTS.

2. Configurer l'environnement de développement

Au cours de cette étape, vous allez préparer votre environnement pour le développement avec AR Foundation d'Unity.

Vérifier que votre appareil est compatible avec la RA

Les expériences de RA sur les appareils Android sont gérées par ARCore, qui est disponible sur les appareils compatibles avec ARCore. Assurez-vous que votre appareil de développement est compatible avec la RA. Vous pouvez également utiliser une instance d'Android Emulator compatible avec la RA correctement configurée.

Configurer le débogage USB sur votre appareil

Pour exécuter des applications de débogage, vous devez activer les options pour les développeurs sur votre appareil. Si vous ne l'avez pas encore fait, consultez la documentation Android sur l'activation des options pour les développeurs et du débogage USB.

Installer Unity (2020.3 LTS)

Sur votre poste de travail, installez Unity 2020 LTS. Dans cet atelier de programmation, des captures d'écran de l'UI d'Unity sont présentées dans la version 2020.3 (LTS). D'autres versions d'Unity peuvent fonctionner, mais peuvent nécessiter des étapes supplémentaires. Il peut être différent des captures d'écran présentées ici.

Créer un projet

Créez un projet à l'aide du modèle Universal Render Pipeline (Pipeline de rendu universel). Donnez-lui un nom descriptif et un emplacement approprié, puis cliquez sur CRÉER.

Installer les frameworks requis

AR Foundation d'Unity se trouve dans le gestionnaire de packages Unity.

1. Pour l'ouvrir, cliquez sur Window > Package Manager (Fenêtre > Gestionnaire de paquets).

2. Dans cette fenêtre, installez les packages que vous utiliserez dans cet atelier de programmation. Pour afficher les dernières versions de ces frameworks, développez leur entrée à l'aide de l'icône ►. Installez les dernières versions de chacun de ces frameworks :
   • AR Foundation
   • Plug-in ARCore XR

Une fois que vous avez terminé, votre gestionnaire de packages doit se présenter comme suit :

Installer le package de démarrage

Pour cet atelier de programmation, nous vous avons fourni un package de démarrage contenant des préfabriqués et des scripts qui accéléreront certaines parties de l'atelier afin que vous puissiez vous concentrer sur l'utilisation d'AR Foundation.

1. Télécharger le package de démarrage
2. Installez le package de démarrage en ouvrant Assets > Import Package > Custom Package… (Éléments > Importer un package > Package personnalisé…) et en ouvrant starter-package.unitypackage.
3. Dans la fenêtre pop-up, assurez-vous que tout est sélectionné.
4. Cliquez sur Importer.

Modifier les paramètres de compilation

Comme l'application s'exécutera sur Android, définissez la plate-forme de compilation sur Android :

1. Ouvrez File > Build Settings (Fichier > Paramètres de compilation).
2. Dans le volet Plate-forme, sélectionnez Android.
3. Si vous le souhaitez, activez Development Build (Compilation de développement) et Script Debugging (Débogage de script) pour conserver les informations de débogage pendant l'exécution de votre application.
4. Cliquez sur Changer de plate-forme.

Modifier les paramètres du projet

AR Foundation doit être configuré pour initialiser les systèmes XR au démarrage.

1. Ouvrez Edit > Project Settings... (Modifier > Paramètres du projet…), puis cliquez sur la section XR Plug-in Management (Gestion des plug-ins XR).
2. Dans l'onglet Android, activez ARCore.

3. Dans le volet de gauche, cliquez sur la section Lecteur.
4. Dans l'onglet Android, sous Other Settings (Autres paramètres), supprimez Vulkan de Graphics APIs (API graphiques).

5. Les applications de RA utilisant ARCore nécessitent un niveau d'API minimal de 24. Faites défiler la page vers le bas et recherchez Niveau d'API minimal. Définissez le niveau d'API minimal sur 24.

Ajouter les éléments de scène requis

Le modèle Universal Render Pipeline est fourni avec des objets de jeu que vous n'utiliserez pas dans ce tutoriel.

1. Supprimez tous les objets de jeu dans SampleScene.

2. Ajoutez des objets AR Foundation. Effectuez un clic droit dans le volet Hiérarchie. Utilisez ce menu pour ajouter :

• XR > Session AR : cet objet contrôle le cycle de vie d'une expérience de RA.
• XR > AR Session Origin : cet objet transforme les coordonnées de RA en coordonnées du monde Unity.
• Lumière > Lumière directionnelle : fournit une source de lumière pour éclairer les objets du jeu.

Votre hiérarchie doit se présenter comme suit :

3. Développez l'origine de la session AR que vous avez créée dans la hiérarchie, puis sélectionnez l'objet Caméra AR. Dans l'inspecteur, remplacez son tag par MainCamera.

Configurer le rendu

Le pipeline de rendu universel d'Unity doit être modifié pour être compatible avec AR Foundation.

1. Dans le volet Project (Projet), accédez à Assets > Settings (Éléments > Paramètres) pour trouver l'élément ForwardRenderer.

2. Sélectionnez ForwardRenderer.
3. Dans le volet "Inspector" (Inspecteur), utilisez Add Renderer Feature (Ajouter une fonctionnalité de rendu) pour ajouter une AR Background Renderer Feature (Fonctionnalité de rendu de l'arrière-plan de la RA). Ce composant affichera le flux de la caméra dans votre scène.

Valider la configuration

1. Assurez-vous que votre appareil est branché et que le débogage ADB est activé.
2. Cliquez sur File > Build And Run… (Fichier > Générer et exécuter…). L'application sera alors importée sur votre appareil et démarrée une fois installée.
3. Le flux vidéo de la caméra devrait s'afficher sur l'écran de votre appareil.

À l'étape suivante, vous commencerez à ajouter des fonctionnalités à votre application.

3. Détecter des surfaces planes dans le monde réel

Maintenant qu'une scène de base a été configurée, vous pouvez commencer à développer le jeu. Dans cette étape, vous allez détecter des plans et les dessiner dans la scène.

Ajouter un composant ARPlaneManager

Un ARPlaneManager détecte les ARPlanes et crée, met à jour et supprime les objets de jeu lorsque la compréhension de l'environnement par l'appareil change.

1. Dans le panneau "Hiérarchie", créez un GameObject vide.
2. Renommez-le Driving Surface Manager. Ce composant affichera des avions jusqu'à ce que le joueur en sélectionne un.
3. Sélectionnez le nouvel objet de jeu. Dans le volet "Inspector" (Inspecteur), cliquez sur Add Component (Ajouter un composant) pour ajouter un AR Plane Manager (Gestionnaire de plans AR).

4. Configurez ARPlaneManager en définissant le champ Plane Prefab :
   1. Cliquez sur le bouton à côté de None pour afficher la fenêtre Select GameObject (Sélectionner un GameObject).
   2. Sélectionnez l'onglet Éléments et recherchez Driving Surface Plane (Plan de surface de conduite).

Ce prefab du package de démarrage fournit une texture de sol rugueuse qui sera utilisée comme décoration de plan.

5. Remplacez Detection Mode par Horizontal. Cela configure ARPlaneManager pour ne fournir que des plans horizontaux, idéaux pour la conduite.

Ajouter un composant ARRaycastManager

Un ARRaycastManager expose la fonctionnalité de raycast. À l'étape suivante, nous utiliserons cet objet pour fournir les commandes à l'utilisateur.

1. Assurez-vous que l'objet appelé Driving Surface Manager est sélectionné dans le volet "Hierarchy" (Hiérarchie).
2. Dans l'inspecteur, cliquez sur Add Component (Ajouter un composant) pour ajouter un composant ARRaycastManager à votre objet de jeu.

Aucune autre configuration n'est requise pour ce composant.

Ajouter un composant DrivingSurfaceManager

Un DrivingSurfaceManager est un script d'assistance du package de démarrage qui permet de sélectionner un ARPlane. Une fois qu'un ARPlane est sélectionné, tous les autres plans sont masqués et les nouveaux plans sont désactivés.

1. Assurez-vous que l'objet appelé Driving Surface Manager est sélectionné dans le volet "Hierarchy" (Hiérarchie).
2. Dans l'inspecteur, cliquez sur Add Component (Ajouter un composant) pour ajouter un composant DrivingSurfaceManager à votre objet de jeu.

Aucune autre configuration n'est requise pour ce composant.

Exécuter l'application

1. Cliquez sur File > Build And Run... (Fichier > Compiler et exécuter…) pour tester vos modifications.
2. Pointez votre appareil vers une surface horizontale du monde réel et déplacez-le pour aider ARCore à mieux comprendre le monde.

3. Lorsque ARCore a détecté un plan, une texture de terre devrait recouvrir les surfaces réelles. ARPlaneManager instancie le Plane Prefab donné pour chaque plan détecté. Le prefab Driving Surface Plane comporte un composant ARPlaneMeshVisualizer qui crée un maillage pour un ARPlane donné.

À l'étape suivante, vous utiliserez un plan détecté comme terrain de jeu.

4. Effectuer un test de positionnement sur les plans détectés

À l'étape précédente, vous avez programmé une application capable de détecter les plans. Ces plans sont reflétés dans la scène de votre jeu. Vous allez maintenant ajouter de l'interactivité avec ces plans en créant un réticule de visée et une voiture qui roulera sur la surface du plan détecté.

Créer un réticule de visée

Le système de contrôle de cette application consiste à ce que le joueur pointe son téléphone vers une surface. Pour fournir un retour visuel clair sur l'emplacement désigné, vous allez utiliser un réticule de visée.

Pour "coller" ce réticule à un plan de RA, utilisez un test de positionnement. Un test de sélection est une technique qui calcule les intersections lors de la projection d'un rayon dans une direction donnée. Vous allez utiliser un test de positionnement pour détecter une intersection dans la direction de la vue de la caméra.

Ajouter le réticule

1. Dans le volet Project (Projet) en bas de l'écran, accédez à Assets > Starter Package (Éléments > Package de démarrage).
2. Placez le prefab du réticule dans la scène en le faisant glisser dans le volet Hiérarchie du projet.
3. Sélectionnez le réticule dans la hiérarchie.
4. Dans l'inspecteur, cliquez sur Add Component (Ajouter un composant). Ajoutez le script ReticleBehaviour du package de démarrage. Ce script contient du code récurrent pour contrôler le réticule.
5. Le script ReticleBehaviour dépend du Driving Surface Manager que vous avez créé précédemment. Ajoutez donc la dépendance en cliquant sur le sélecteur Driving Surface Manager. Sélectionnez l'onglet Scène, puis choisissez Driving Surface Manager.

Modifier le ReticleBehaviour

Le script ReticleBehavior positionne le réticule sur le plan situé au centre de la fenêtre d'affichage de l'appareil.

1. Ouvrez le script ReticleBehaviour.cs en double-cliquant sur le champ Script.
2. Déterminez le centre de l'écran à l'aide de ViewToScreenPoint de l'appareil photo. Modifiez la méthode Update() pour ajouter les éléments suivants :

var screenCenter = Camera.main.ViewportToScreenPoint(new Vector3(0.5f, 0.5f));

3. Utilisez ce point pour effectuer un raycast. Ajoutez les éléments suivants :

var hits = new List<ARRaycastHit>();
DrivingSurfaceManager.RaycastManager.Raycast(screenCenter, hits, TrackableType.PlaneWithinBounds);

Si vous rencontrez un NullReferenceException lorsque vous utilisez Camera.main, assurez-vous que le AR Camera de votre scène dans Hierarchy > AR Session Origin est tagué MainCamera.

La variable hits contiendra des ARRaycastHit décrivant les points des éléments trackables qui sont croisés par ray.

TrackableType.PlaneWithinBounds est une valeur dans TrackableType. Cela spécifie les types de Trackable pouvant être détectés avec ce raycast. Pour en savoir plus, consultez la documentation Unity sur TrackableType.

4. Déterminez le point d'intersection qui vous intéresse en interrogeant la liste hits. Priorisez le plan verrouillé contenu dans DrivingSurfaceManager et, s'il n'existe pas, utilisez le premier plan touché. Ajoutez les éléments suivants à la fin de Update() :

CurrentPlane = null;
ARRaycastHit? hit = null;
if (hits.Length > 0)
{
    // If you don't have a locked plane already...
    var lockedPlane = DrivingSurfaceManager.LockedPlane;
    hit = lockedPlane == null
        // ... use the first hit in `hits`.
        ? hits[0]
        // Otherwise use the locked plane, if it's there.
        : hits.SingleOrDefault(x => x.trackableId == lockedPlane.trackableId);
}

5. Si hit contient un résultat, déplacez la transformation de GameObject vers la position du hit.

if (hit.HasValue)
{
    CurrentPlane = DrivingSurfaceManager.PlaneManager.GetPlane(hit.Value.trackableId);
    // Move this reticle to the location of the hit.
    transform.position = hit.Value.pose.position;
}
Child.SetActive(CurrentPlane != null);

Tester le réticule

1. Cliquez sur File > Build And Run... (Fichier > Compiler et exécuter…) pour tester vos modifications.
2. Lorsque vous pointez votre appareil vers un avion, le réticule doit suivre les mouvements de votre caméra.

Créer une voiture

Le joueur contrôle une voiture miniature qui se dirige vers l'emplacement du réticule. Un modèle et un comportement pour cette voiture sont fournis dans le package de démarrage.

Ajouter un CarManager à votre scène

1. Dans la hiérarchie, créez un GameObject vide.
2. Renommez-le Car Spawner.
3. Sélectionnez l'objet que vous avez créé. Dans le volet Hierarchy (Hiérarchie), cliquez sur Add Component (Ajouter un composant) pour ajouter le composant CarManager.
4. Configurez les dépendances de CarManager en cliquant sur le sélecteur de chaque champ :
   • Prefab de voiture : dans Assets, sélectionnez Car Prefab.
   • Réticule : dans Scène, sélectionnez Prefab du réticule.
   • Driving Surface Manager : dans Scene, sélectionnez Driving Surface Manager.

Ce comportement CarManager génère une voiture miniature sur le plan sur lequel se trouve le réticule. Si vous le souhaitez, consultez le script CarBehaviour pour découvrir comment la voiture est programmée.

Essai de véhicules

1. Cliquez sur File > Build And Run (Fichier > Compiler et exécuter) pour tester vos modifications.
2. Lorsque vous appuyez sur un avion, une petite voiture devrait apparaître à cet endroit. Cette voiture suivra le réticule.

Ajouter l'élément de jeu

Maintenant que le joueur peut contrôler une entité dans la scène, donnez-lui une destination à atteindre.

1. Créez un GameObject vide dans la hiérarchie.
2. Renommez-le Package Spawner.
3. Sélectionnez l'objet que vous avez créé. Dans le volet Hierarchy (Hiérarchie), cliquez sur Add Component (Ajouter un composant) pour y ajouter le composant PackageSpawner.
4. Configurez les dépendances de PackageSpawner en cliquant sur le sélecteur de chaque champ :
   • Package Prefab : dans Assets, sélectionnez Package Prefab.
   • Gestionnaire de surface de conduite : dans Scène, sélectionnez Gestionnaire de surface de conduite.

Ce comportement PackageSpawner génère un nouveau package à un emplacement aléatoire sur un ARPlane verrouillé s'il n'y en a pas déjà un.

Tester le jeu

1. Cliquez sur File > Build And Run (Fichier > Compiler et exécuter) pour tester vos modifications. 2) Après avoir créé une voiture, un colis devrait apparaître.
2. Conduisez jusqu'au colis.
3. Un nouveau s'affiche à un emplacement aléatoire.

5. Configurer l'estimation de l'éclairage

Maintenant que le jeu de base est terminé, ajoutez une touche de réalisme à votre scène de RA. Dans cette étape, vous allez utiliser l'API Lighting Estimation d'ARCore pour détecter la luminosité présente dans le monde réel en fonction des images de l'appareil photo. Ces informations seront utilisées pour adapter l'éclairage de votre scène à l'éclairage du monde réel.

Activer l'estimation de l'éclairage

1. Dans Hierarchy (Hiérarchie), développez AR Session Origin (Origine de la session AR), puis sélectionnez l'objet AR Camera (Caméra AR).
2. Dans l'Inspecteur, développez le script AR Camera Manager.
3. Définissez le champ Estimation de l'éclairage sur Tout.

Modifier la lumière directionnelle

1. Dans Hierarchy (Hiérarchie), sélectionnez l'objet Directional Light (Lumière directionnelle).
2. Ajoutez-y le composant LightEstimation. Ce composant du package de démarrage fournit un code passe-partout pour s'abonner aux changements d'éclairage.
3. Dans la fonction FrameReceived(), ajoutez :

ARLightEstimationData lightEstimation = args.lightEstimation;

if (lightEstimation.averageBrightness.HasValue)
    Light.intensity = lightEstimation.averageBrightness.Value;

if (lightEstimation.averageColorTemperature.HasValue)
    Light.colorTemperature = lightEstimation.averageColorTemperature.Value;

if (lightEstimation.colorCorrection.HasValue)
    Light.color = lightEstimation.colorCorrection.Value;

if (lightEstimation.mainLightDirection.HasValue)
    Light.transform.rotation = Quaternion.LookRotation(lightEstimation.mainLightDirection.Value);

if (lightEstimation.mainLightColor.HasValue)
    Light.color = lightEstimation.mainLightColor.Value;

if (lightEstimation.mainLightIntensityLumens.HasValue)
    Light.intensity = lightEstimation.averageMainLightBrightness.Value;

if (lightEstimation.ambientSphericalHarmonics.HasValue)
{
    RenderSettings.ambientMode = AmbientMode.Skybox;
    RenderSettings.ambientProbe = lightEstimation.ambientSphericalHarmonics.Value;
}

Pour en savoir plus sur chaque paramètre, consultez la documentation AR Foundation sur ARLightEstimationData.

Tester les modifications effectuées

1. Cliquez sur File > Build And Run (Fichier > Compiler et exécuter) pour tester vos modifications.
2. Lorsque vous regardez les objets de la scène, vous remarquerez peut-être qu'ils sont colorés en fonction de l'éclairage de l'environnement.
3. Si possible, essayez de modifier l'éclairage. Par exemple, essayez d'éteindre les lumières de la pièce dans laquelle vous vous trouvez. Vous devriez voir l'éclairage des objets s'adapter à la modification de l'éclairage du monde réel.

6. Synthèse

Félicitations ! Vous avez terminé cet atelier de programmation sur Unity AR Foundation.

Points abordés

• Découvrez comment configurer un projet de base à l'aide d'AR Foundation d'Unity et du Universal Rendering Pipeline.
• Utiliser ARPlaneManager pour s'abonner à de nouveaux forfaits
• Utiliser Raycast pour trouver des intersections avec la géométrie virtuelle.
• Utiliser ARLightEstimationData pour éclairer votre scène.

Étapes suivantes

• Consultez les exemples AR Foundation d'Unity.
• Parcourez la documentation AR Foundation.
• Consultez la documentation Google sur les extensions ARCore pour AR Foundation d'Unity.

Devoirs bonus

Si vous souhaitez développer le jeu que vous avez créé ici, voici quelques idées à explorer :

• Ajoutez un compteur de score à votre jeu en modifiant un TextMeshPro lorsqu'un PackageManager génère un nouveau colis.
• Consultez les informations sur les performances de votre jeu en activant l'overlay de performances.
• Utilisez Persistent Raycasts pour placer d'abord de nouveaux objets dans votre scène. Lorsqu'une surface plane est détectée dans cette zone, l'objet se met à jour pour s'y aligner.