Réalité Augmentée sur Smartphone — TP

TP pratique sur la réalité augmentée sur smartphone utilisant ARCore.

Objectif

Créer une application de réalité augmentée capable de :

  1. détecter une image utilisée comme marqueur,
  2. afficher un objet 3D attaché à ce marqueur,
  3. détecter un plan dans l’environnement,
  4. définir une zone de jeu,
  5. créer des interactions entre les marqueurs et la zone.

Partie 1 — Création du projet

  1. Créer un projet Unity.

  2. Basculer la plateforme vers Android dans les Build Settings.

Pour avoir accès aux logs sur le téléphone, installer Android Logcat depuis le Package Manager.

  1. Installer AR Foundation.

  2. Installer ARCore XR Plugin (Android) ou ARKit XR Plugin (iOS).

  3. Ouvrir Project Settings → XR Plug-in Management et activer :

    • ARCore dans l’onglet Android
    • ARKit dans l’onglet iOS (si nécessaire)

  4. Dans Project Settings → Player → Android :

    • définir Minimum API Level : Android 10 / API 29.
    • Dans Graphics APIs, désactiver Vulkan et conserver OpenGLES3 uniquement.

  5. Ajouter dans la scène :

    • AR Session
    • XR Origin (avec AR Camera)

  6. Configuration du rendu mobile

    • Dans le projet, ouvrir : Assets/Settings/Mobile_Renderer
    • Dans l’inspecteur : Add Renderer Feature → AR Background Renderer Feature

Vérifier que l’application se lance sur le téléphone et que le flux caméra est visible.

Lors du premier lancement sur le téléphone, autoriser l’accès à la caméra lorsque le système le demande.

Partie 2 — Détection d’image

  1. Créer un nouvel asset Reference Image Library.
  2. Ajouter une image marqueur.
  3. Ajouter un composant ARTrackedImageManager au XR Origin.
  4. Associer la bibliothèque d’images.
  5. Créer un prefab d’objet 3D à afficher sur le marqueur.
  6. Associer ce prefab au ARTrackedImageManager.

Vous pouvez utiliser les marqueurs prévus pour ce TP. L’asset ImageLibrary est disponible ici et les marqueurs sont ici.

Partie 3 — Détection de plans (sélection d’un plan + zone de jeu)

Objectif

  • détecter des plans horizontaux/verticaux via AR Foundation,
  • permettre à l’utilisateur de taper sur un plan détecté,
  • placer une zone de jeu (GameBoard) sur ce plan.

3.1 Ajouter les composants AR nécessaires

Sur l’objet XR Origin :

ARPlaneManager

  • Sert à détecter et maintenir les plans.
  • Associer un Plane Prefab pour visualiser les plans.

Créer un Plane Prefab simple

  1. Create → Empty GameObject

  2. Nommer l’objet : ARPlanePrefab

  3. Ajouter les composants :

    • AR Plane
    • AR Plane Mesh Visualizer
    • Mesh Renderer
    • Mesh Filter

  4. Créer un matériau simple (ex : Unlit / Color transparent).

  5. Assigner ce matériau au Mesh Renderer.

  6. Glisser l’objet dans le dossier Project pour créer un prefab.

  7. Assigner ce prefab dans ARPlaneManager → Plane Prefab.

ARRaycastManager

  • Sert à projeter un rayon depuis l’écran pour détecter les plans.

Réglage conseillé :

  • Detection Mode → Horizontal

3.2 Créer un prefab de zone de jeu (GameBoard)

Créer un prefab simple :

  • un Quad posé à plat
  • un matériau semi‑transparent
  • une échelle ~ 0.5 m
  • optionnel : BoxCollider

3.3 Implémenter le tap-to-place (New Input System)

Dans ce TP, on utilise le New Input System (Unity Input System Package) pour récupérer les taps.

Prérequis

  1. Ouvrir Project Settings → Player
  2. Mettre Active Input Handling → Input System Package (New)

Principe

Créer un script BoardPlacement.cs. Le script doit :

  1. activer EnhancedTouch (au démarrage)
  2. récupérer le premier touch actif
  3. filtrer sur la phase Began
  4. lancer un ARRaycast vers les plans (PlaneWithinPolygon)
  5. créer ou déplacer le GameBoard à la pose du hit

Fonctions / API utiles :

  • EnhancedTouchSupport.Enable() / Disable()
  • Touch.activeTouches
  • touch.phase (New Input System)
  • touch.screenPosition
  • ARRaycastManager.Raycast(...)
  • TrackableType.PlaneWithinPolygon
  • Pose
  • Instantiate(...)
  • transform.SetPositionAndRotation(...)

Checkpoint

Vous devez pouvoir :

  • voir les plans détectés
  • toucher un plan
  • placer la zone de jeu

Partie 4 — Interactions

4.1 Interaction basique

Implémenter une interaction entre :

  • les marqueurs détectés
  • la zone de jeu

Exemples possibles :

  • un objet apparaît lorsque le marqueur entre dans la zone
  • le marqueur déplace un objet dans la zone
  • l’orientation du marqueur modifie un paramètre

Cette partie est volontairement libre.

4.2 Ressources pour aller plus loin

Le package AR Foundation fournit plusieurs fonctionnalités utiles pour enrichir votre projet.

Suivi des images

  • ARTrackedImageManager
  • événements : trackedImagesChanged
  • accès à la position d’un marqueur

Détection de plans

  • ARPlaneManager
  • accès aux plans détectés

Raycast AR

  • ARRaycastManager.Raycast()
  • permet d’interagir avec l’environnement réel

Ancres AR

  • ARAnchorManager
  • permet de fixer durablement un objet dans l’espace

Estimation de la lumière

  • ARCameraManager
  • permet d’adapter la lumière des objets virtuels à la scène réelle

Tracking du visage / du corps (selon appareils)

  • Face Tracking
  • Body Tracking

Documentation officielle :

https://docs.unity3d.com/Packages/com.unity.xr.arfoundation

Partie 5 — Scénarisation

Vous avez maintenant tous les éléments techniques pour créer une expérience AR complète.

Inventez une petite application ou un mini‑jeu utilisant :

  • un marqueur ou plusieurs marqueurs
  • une zone
  • au moins une interaction.

Extensions possibles

  • plusieurs marqueurs
  • interactions entre marqueurs
  • effets visuels
  • interface utilisateur AR

Livrables

  1. Compte rendu (PDF) avec :

    • description de l’application
    • captures d’écran
    • explications techniques
    • lien Git vers le projet Unity

Barème

  • Mise en place du projet — 2 pts
  • Image tracking — 2 pts
  • Détection de plan et placement — 4 pts
  • Interactions — 4 pts
  • Scénarisation — 5 pts
  • Qualité technique — 2 pts
  • Rendu — 1 pt