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

1. Présentation

ARCore est le framework de Google qui permet de créer des expériences de réalité augmentée sur smartphone. Vous pouvez utiliser l'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 Foundations. Le but du jeu est de collecter des colis à l'aide d'une voiture que vous contrôlez à l'aide de votre appareil portable.

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 pour les joueurs en créant un jeu qui comprend l'environnement qui entoure le joueur.

À la fin de cet atelier de programmation, votre jeu sera en mesure d'effectuer les opérations suivantes:

• Détectez les avions réels et tracez un terrain de jeu par-dessus.
• Projetez un rayon à partir du champ de vision de la caméra et détectez les intersections avec des 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 les fondations AR d'Unity
• Utiliser ARPlaneManager pour vous abonner à de nouveaux plans
• Utiliser Raycast pour trouver des intersections à l'aide de la géométrie virtuelle
• Comment 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 1.23 ou version 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 l'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énérées par ARCore, disponible sur les appareils compatibles ARCore. Assurez-vous que votre appareil de développement est compatible avec la RA. Vous pouvez également utiliser une instance Android Emulator compatible avec la RA correctement configurée.

Configurer le débogage USB sur votre appareil

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

Installer Unity (2020.3 LTS)

Sur votre station de travail, installez Unity 2020 LTS. Dans cet atelier de programmation, des captures d'écran de l'interface utilisateur d'Unity sont présentées dans la version 2020.3 (LTS). D'autres versions d'Unity peuvent fonctionner, mais des étapes supplémentaires peuvent être nécessaires. Elle peut être différente de celle présentée ici.

Créer un projet

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

Installer les frameworks requis

Vous trouverez les éléments de base AR d'Unity dans le gestionnaire de packages Unity.

1. Ouvrez-la en cliquant sur Fenêtre > Gestionnaire de packages.

2. Dans cette fenêtre, installez les packages que vous utiliserez dans cet atelier de programmation. Affichez les dernières versions de ces frameworks en développant leur entrée à l'aide de l'icône ►. Installez la dernière version pour chacun de ces frameworks:
   • Éléments de base de la RA
   • Plug-in ARCore XR

Lorsque vous avez terminé, votre gestionnaire de paquets doit ressembler à ceci:

Installer le package de démarrage

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

1. Télécharger le package de démarrage
2. Installez le package de démarrage en accédant à Assets > Importer un package > Package personnalisé... et ouverture de starter-package.unitypackage.
3. Dans la fenêtre qui s'affiche, vérifiez que tous les éléments sont sélectionnés.
4. Cliquez sur Importer.

Modifier les paramètres de compilation

Étant donné que l'application s'exécutera sous Android, définissez la plate-forme de compilation sur Android:

1. Ouvrez Fichier > Paramètres de compilation.
2. Dans le volet Plate-forme, sélectionnez Android.
3. Si vous le souhaitez, vous pouvez activer Development Build (Build de développement) et Script Debugging (Débogage de script) afin de conserver les informations de débogage pendant l'exécution de votre application.
4. Cliquez sur Switch Platform (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 Modifier > Project Settings... (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 Player (Lecteur).
4. Dans l'onglet Android, sous Other Settings (Autres paramètres), supprimez Vulkan des API graphiques.

5. Les applications requises pour la RA qui utilisent ARCore nécessitent un niveau d'API minimal de 24. Faites défiler la page vers le bas et recherchez Minimum API Level (Niveau d'API minimal). Définissez le niveau d'API minimal sur 24.

Ajouter les éléments de scène requis

Le modèle de pipeline de rendu universel comprend des objets de jeu que vous n'utiliserez pas dans ce tutoriel.

1. Supprimez tous les objets du jeu dans SampleScene.

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

• XR > Session de RA: cet objet contrôle le cycle de vie d'une expérience de RA.
• XR > Origine de la session RA: cet objet transforme les coordonnées RA en coordonnées mondiales Unity.
• Clair > Lumière directionnelle: source lumineuse permettant d'éclairer les objets du jeu.

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

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

Configurer l'affichage

Le pipeline de rendu universel d'Unity nécessite une modification pour être compatible avec l'AR Foundation.

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

2. Sélectionnez ForwardRenderer.
3. Dans le volet de l'outil d'inspection, utilisez l'option Ajouter un moteur de rendu pour ajouter un moteur de rendu d'arrière-plan en réalité augmentée. Ce composant affiche 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 Fichier > Compiler et exécuter... L'application est alors transférée sur votre appareil et démarrée une fois installée.
3. Le flux de la caméra doit s'afficher sur l'écran de votre appareil.

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

3. Détecter des avions dans le monde réel

Maintenant que vous avez configuré une scène de base, vous pouvez commencer à développer le jeu. Au cours de cette étape, vous allez détecter des plans et les dessiner sur la scène.

Ajouter un composant ARPlaneManager

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

1. À l'aide du volet "Hiérarchie", créez un GameObject vide.
2. Renommez-le Driving Surface Manager. Ce composant affiche des plans jusqu'à ce que le lecteur en sélectionne une.
3. Sélectionnez le nouvel objet de jeu. Dans le volet "Inspecteur", cliquez sur Ajouter un composant pour ajouter un Gestionnaire de plan de RA.

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 objet GameObject).
   2. Sélectionnez l'onglet Assets (Composants) et recherchez Pilote avion de surface.

Ce prefab du pack de démarrage fournit une texture de sol granuleuse qui sera utilisée comme décoration de l'avion.

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

Ajouter un composant ARRaycastManager

Un ARRaycastManager expose la fonctionnalité 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 "Hiérarchie".
2. Dans l'inspecteur, cliquez sur Add Component (Ajouter un composant) pour ajouter un composant ARRaycastManager à votre objet de jeu.

Aucune configuration supplémentaire n'est requise pour ce composant.

Ajouter un composant DrivingSurfaceManager

Un DrivingSurfaceManager est un script d'aide du package de démarrage qui permet de sélectionner un ARPlane. Une fois que vous aurez sélectionné ARPlane, tous les autres plans seront masqués et les nouveaux plans seront désactivés.

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

Aucune configuration supplémentaire n'est requise pour ce composant.

Exécuter l'application

1. Cliquez sur Fichier > Build and Run... (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. Lorsqu'ARCore a détecté une surface plane, une texture de saleté devrait apparaître sur des surfaces réelles. Le ARPlaneManager instancie la Plane Prefab donnée 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 allez utiliser une avion détectée 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 avions se reflètent dans la scène de votre jeu. À présent, vous allez ajouter de l'interactivité à ces plans en créant un réticule de visée et une voiture qui roulera à la surface de l'avion détecté.

Créer un réticule de visée

Le schéma de contrôle de cette application implique que le joueur pointe son téléphone vers une surface. Pour obtenir un retour visuel clair sur le lieu désigné, vous utiliserez un réticule de visée.

Pour « retenir » ce réticule à un plan en RA, utilisez un test de positionnement. Un test de positionnement 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 > Package Starter
2. Placez le Prefab Reticle dans la scène en le faisant glisser dans le volet de 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 à partir du package de démarrage. Ce script contient du code récurrent permettant de contrôler le réticule.
5. Le script ReticleBehaviour dépend du Driving Surface Manager que vous avez créé précédemment. Vous devez donc ajouter la dépendance en cliquant sur le sélecteur Driving Surface Manager. Sélectionnez l'onglet Scene (Scène) et choisissez Driving Surface Manager.

Modifier 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 du 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 réaliser une diffusion raycast. Ajoutez les éléments suivants :

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

Si vous rencontrez une NullReferenceException lorsque vous utilisez Camera.main, assurez-vous que l'AR Camera de votre scène se trouve dans Hierarchy > L'origine de la session de RA est associée au tag MainCamera.

La variable hits contient des ARRaycastHit qui décrivent les points des éléments suivis qui sont croisés par ray.

TrackableType.PlaneWithinBounds est une valeur de TrackableType. Permet de spécifier les types de Trackable pouvant être détectés avec cette dominante de rayon. Pour en savoir plus, consultez la documentation Unity sur TrackableType.

4. Déterminez le point d'intérêt d'intersection en interrogeant la liste hits. Privilégiez le plan verrouillé contenu dans DrivingSurfaceManager. S'il n'existe pas, utilisez le premier contact d'avion. Ajoutez le code suivant à 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 ce GameObject vers la position de l'appel.

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 Fichier > Build and Run... (Compiler et exécuter) pour tester vos modifications
2. Lorsque vous pointez votre appareil vers un avion, vous devriez voir le réticule suivre les mouvements de la caméra.

Créer une voiture

Le joueur commande une petite voiture qui se dirigera vers l'emplacement du réticule. Le modèle et le comportement de cette voiture sont fournis dans le pack de démarrage.

Ajouter un CarManager à votre scène

1. Dans Hierarchy (Hiérarchie), créez un élément 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 pour chaque champ:
   • Car Prefab: dans Assets (Composants), sélectionnez Car Prefab.
   • Reticle: dans Scene (Scène), sélectionnez Reticle Prefab.
   • Driving Surface Manager: dans Scene (Scène), sélectionnez Driving Surface Manager.

Ce comportement CarManager génère une petite voiture dans l'avion sur lequel se trouve le réticule. Si vous le souhaitez, consultez le script CarBehaviour pour apprendre comment la voiture est programmée.

Essai de véhicules

1. Cliquez sur Fichier > Build and Run (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 jeu

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

1. Créez un élément 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 pour chaque champ:
   • Package Prefab: dans Assets, sélectionnez Package Prefab.
   • Driving Surface Manager (Gestionnaire de surface de conduite) Dans Scene (Scène), sélectionnez Driving Surface Manager.

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

Tester le jeu

1. Cliquez sur Fichier > Build and Run (Compiler et exécuter) pour tester vos modifications. 2. Une fois la voiture créée, un package devrait apparaître.
2. Conduisez votre voiture jusqu'au colis.
3. Un nouveau code s'affichera à un emplacement aléatoire.

5. Configurer l'estimation de l'éclairage

Maintenant que vous avez terminé le jeu de base, ajoutez une touche de réalisme à votre scène en RA. Au cours de cette étape, vous allez utiliser l'API Lighting Estimation d'ARCore pour détecter l'éclairage du monde réel en fonction des images entrantes de la caméra. 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 la section AR Session Origin (Origine de la session de RA) et sélectionnez l'objet AR Camera (Caméra AR).
2. Dans l'outil d'inspection, développez le script Gestionnaire de l'appareil photo RA.
3. Définissez le champ Lighting Estimation (Estimation de l'éclairage) sur Everything (Tout).

Modifier l'éclairage directionnel

1. Dans Hierarchy (Hiérarchie), sélectionnez l'objet Directional Light (Lumière directionnelle).
2. Ajoutez-y le composant LightEstimation. Ce composant du pack Starter fournit du code récurrent pour l'abonnement 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 Fichier > Build and Run (Compiler et exécuter) pour tester vos modifications.
2. En observant les objets de la scène, vous remarquerez peut-être qu'ils sont colorés en fonction de la luminosité de l'environnement.
3. Essayez de modifier l'éclairage, si possible. Par exemple, essayez d'éteindre les lumières de la pièce dans laquelle vous vous trouvez. Vous devez voir que l'éclairage des objets s'adapte à l'évolution de l'éclairage du monde réel.

6. Synthèse

Félicitations ! Vous êtes arrivé à la fin de cet atelier de programmation sur Unity AR Foundation.

Points abordés

• Configurer un projet de base à l'aide de la base de données AR d'Unity et du pipeline de rendu universel
• Utiliser ARPlaneManager pour vous abonner à de nouveaux plans
• Comment utiliser Raycast pour trouver des intersections avec la géométrie virtuelle
• Comment utiliser ARLightEstimationData pour éclairer votre scène.

Étapes suivantes

• Consultez les exemples de base de RA d'Unity.
• Parcourez la documentation sur les éléments de base de la RA.
• Consultez la documentation Google sur les extensions ARCore pour l'AR Foundation d'Unity.

Devoirs bonus

Si vous souhaitez développer le jeu que vous avez créé ici, voici quelques idées qui peuvent vous aider:

• Ajoutez un compteur de points à votre jeu en modifiant un TextMeshPro lorsqu'un PackageManager génère un nouveau package.
• Pour consulter des informations sur les performances lorsque votre jeu est en cours d'exécution, activez la superposition des performances.
• Utilisez des Raycasts persistants pour commencer par placer les nouveaux objets dans votre scène. Lorsqu'une surface plane est détectée dans cette zone, l'objet est mis à jour pour s'aligner sur cette surface.