guide du développeur (exemples et solution complète … · de considérer unity comme un...

Ce livre s’adresse à un public de développeurs désireux d’apprendre à développer leurs propressolutions de réalité augmentée à l’aide du moteur 3D temps réel Unity. Grâce à une approche pra-

tique et didactique, l’auteur permet aux lecteurs d’entrer rapidement dans le vif du sujet : aprèsavoir analysé les modalités nécessaires à l’élaboration d’un projet de réalité augmentée, vousapprendrez à déployer des applications de réalité augmentée sur des terminaux mobiles

(Android, iOS, Windows Phone,…) mais aussi sur PC, Mac ou Linux. Une connaissance généralede la programmation est requise afin d’exploiter au mieux le contenu de cet ouvrage.

Les premiers chapitres présentent les différentes caractéristiques de la réalité augmentée ainsique son utilisation, et un apprentissage du moteur temps réel Unity qui servira de support d’im-plémentation pour la suite du livre. Ensuite, les différentes interactions entre les entités virtuelleset réelles sont étudiées à l’aide du langage de programmation C# sous l’environnement Mono.L’ajout du composant de réalité augmentée et l’étude de marqueurs sont décrits à l’aide de nom-breux exemples pratiques.

Enfin, le développement complet d’une application de réalité augmentée pour smartphone estétudié à travers un chapitre entier, qui expose la réflexion sur l’architecture, les contraintes tech-

niques et le déploiement, en apportant à chaque problème une solution concrète et fonctionnelle.

Tous les codes sources du livre ainsi que les versions compilées sont disponibles en télécharge-

ment sur le site www.editions-eni.fr.

La réalité augmentée avec Unity Guide du développeur (exemples et solution complète avec C#)

Stéphane DORLAC est Chef de Projet, Architecte endéveloppement, spécialisé en environnement .NET. Sesdomaines d’intervention sont variés : téléphonie, paie-ment en ligne, mobilité, serious games… Autour de laréalité augmentée, et en s’appuyant sur Unity pour laréalisation technique, il fournit au lecteur les connais-sances nécessaires pour réaliser des applications fiableset productives qui répondent aux attentes généréesdans le monde de l’entreprise par ce nouveau concept.

Sur www.editions-eni.fr :b Code source des exemples.b Code source

d’une application mobile.

ISBN 978-2-7460-9062-0

54 €9 782746 090620

ISSN 1960-3444

Avant-propos • Appréhender la réalitéaugmentée • Comprendre et utiliserUnity • Étude d’un framework de réa-lité augmentée • Exemple d’un projet deréalité augmentée • Aller plus loin

Les chapitres du livre

La

réal

ité

aug

men

tée

avec

Un

ity

G

uid

e d

u d

ével

op

peu

r C

#

Plusd’informations :

La réalité augmentée

avec UnityGuide du développeur

(exemples et solution

complète avec C#)

Stéphane DORLAC

Téléchargementwww.editions-eni.fr.fr

1Table des matières

Avant-propos

Chapitre 1

Appréhender la réalité augmentée

1. Les concepts généraux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.1 La réalité augmentée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.2 Les différents types d’implémentation . . . . . . . . . . . . . . . . . . . . . 91.3 Les applications du marché . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2. L’environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.1 Le choix d’Unity 3D comme moteur temps réel . . . . . . . . . . . . 142.2 Le choix de l’environnement de développement . . . . . . . . . . . . 172.3 Les différentes plateformes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3. Les pré-requis et rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.1 Informations sur la programmation objet pour Unity . . . . . . . 223.2 Un environnement 3D temps réel . . . . . . . . . . . . . . . . . . . . . . . . 253.3 Les outils de développement conseillés . . . . . . . . . . . . . . . . . . . . 29

4. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Chapitre 2

Comprendre et utiliser Unity

1. L’interface utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311.1 L’organisation des fenêtres de travail . . . . . . . . . . . . . . . . . . . . . 32

1.1.1 L’onglet Scene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341.1.2 L’onglet Game. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361.1.3 L’onglet Project . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence ENI du livre EPREAUC dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

2Guide du développeur C#

La réalité augmentée avec Unity

1.1.4 L’onglet Inspector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401.1.5 L’onglet Hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441.1.6 L’onglet Console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

1.2 Les menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481.2.1 La gestion du projet avec les menus File et Edit . . . . . . . . 481.2.2 La gestion des scènes avec les menus File et Edit . . . . . . . 531.2.3 La gestion des Assets avec les menus GameObject,

Assets et Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551.3 Paramétrer son espace de travail . . . . . . . . . . . . . . . . . . . . . . . . . 57

1.3.1 Les différents Layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581.3.2 Modifier un environnement de travail . . . . . . . . . . . . . . . 59

2. Les différentes entités conceptuelles . . . . . . . . . . . . . . . . . . . . . . . . . . 622.1 Présentation des entités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

2.1.1 Les scènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632.1.2 Les GameObjects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652.1.3 Les Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

2.2 Combinaison de contenus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 712.2.1 Les Prefabs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 722.2.2 Les Assets et les Packages. . . . . . . . . . . . . . . . . . . . . . . . . . 74

2.3 La gestion de la caméra. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 762.3.1 Le GameObject Camera . . . . . . . . . . . . . . . . . . . . . . . . . . . 762.3.2 Gérer plusieurs caméras dans une scène . . . . . . . . . . . . . . 81

3. Les interactions entre les différentes entités. . . . . . . . . . . . . . . . . . . . 853.1 Programmer les scripts et comprendre MonoBehaviour . . . . . . 85

3.1.1 Création des scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 863.1.2 Rôle de MonoBehaviour. . . . . . . . . . . . . . . . . . . . . . . . . . . 923.1.3 Scripts de conception . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963.1.4 Communication entre les entités . . . . . . . . . . . . . . . . . . . 983.1.5 La gestion des préférences utilisateur . . . . . . . . . . . . . . . 105

3.2 Les outils pour déboguer son code. . . . . . . . . . . . . . . . . . . . . . . 1093.2.1 L’objet Debug et le Log. . . . . . . . . . . . . . . . . . . . . . . . . . . 1093.2.2 Les points d’arrêt avec MonoDevelop . . . . . . . . . . . . . . . 116


3.3 La gestion différée des actions sous Unity . . . . . . . . . . . . . . . . 1213.3.1 L’invocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213.3.2 Les Coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

3.4 Définir une interface utilisateur . . . . . . . . . . . . . . . . . . . . . . . . 1303.4.1 Les outils de création d’interfaces utilisateur . . . . . . . . . 1313.4.2 La gestion d’une interface avec NGUI. . . . . . . . . . . . . . . 141

4. Les différentes plateformes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1554.1 Connaître les principaux formats de sortie. . . . . . . . . . . . . . . . 156

4.1.1 Les applications Standalone. . . . . . . . . . . . . . . . . . . . . . . 1564.1.2 Les applications iOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1614.1.3 Les applications Android . . . . . . . . . . . . . . . . . . . . . . . . . 1624.1.4 Les applications Windows Store . . . . . . . . . . . . . . . . . . . 1654.1.5 Les applications Windows Phone 8 . . . . . . . . . . . . . . . . . 1674.1.6 Les applications WebPlayer . . . . . . . . . . . . . . . . . . . . . . . 168

4.2 Gestion des contraintes liées aux plateformes . . . . . . . . . . . . . 1704.2.1 Les applications pour mobile . . . . . . . . . . . . . . . . . . . . . . 1714.2.2 Le WebPlayer et sa Sandbox . . . . . . . . . . . . . . . . . . . . . . 176

5. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

Chapitre 3

Étude d’un framework de réalité augmentée

1. Le plug-in de réalité augmentée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1831.1 Vue d’ensemble. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184

1.1.1 L’architecture proposée . . . . . . . . . . . . . . . . . . . . . . . . . . 1841.1.2 Utilisation du Target Manager . . . . . . . . . . . . . . . . . . . . 187

1.2 Gérer le contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1941.2.1 Gestion du contenu par des marqueurs . . . . . . . . . . . . . 1941.2.2 Conseils et bonnes pratiques . . . . . . . . . . . . . . . . . . . . . . 198

2. L’intégration dans Unity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2002.1 Présentation et installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

2.1.1 Récupération du plug-in et installation . . . . . . . . . . . . . 2002.1.2 Les Prefabs du plug-in. . . . . . . . . . . . . . . . . . . . . . . . . . . . 204



2.2 Marqueurs et fonctionnalités avancées. . . . . . . . . . . . . . . . . . . 2112.2.1 Exemple d’un marqueur de type Image . . . . . . . . . . . . . 2112.2.2 Les boutons virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2272.2.3 L’utilisation du cloud . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

3. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

Chapitre 4

Exemple d’un projet de réalité augmentée

1. Définition et préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2551.1 Structurer le projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

1.1.1 Définition du périmètre fonctionnel. . . . . . . . . . . . . . . . 2561.1.2 Choix de la plateforme de sortie . . . . . . . . . . . . . . . . . . . 258

1.2 Définition du contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

2. Développer l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2612.1 Le projet Unity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

2.1.1 Mise en place et configuration. . . . . . . . . . . . . . . . . . . . . 2622.1.2 Import des Assets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2652.1.3 Le Manager d’application. . . . . . . . . . . . . . . . . . . . . . . . . 2662.1.4 La localisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268

2.2 Intégration de la réalité augmentée. . . . . . . . . . . . . . . . . . . . . . 2742.2.1 Création des marqueurs . . . . . . . . . . . . . . . . . . . . . . . . . . 2742.2.2 Création de la base de données de marqueurs . . . . . . . . 277

2.3 Gestion des scènes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2812.3.1 Les scènes satellites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2812.3.2 La scène principale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

2.4 Déploiement et améliorations . . . . . . . . . . . . . . . . . . . . . . . . . . 3112.4.1 Compiler et déployer sur Android . . . . . . . . . . . . . . . . . 3112.4.2 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314


Chapitre 5

Aller plus loin

1. L’Asset Store . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3171.1 Des composants et plug-ins conseillés . . . . . . . . . . . . . . . . . . . 3181.2 Créer et monétiser avec l’Asset Store . . . . . . . . . . . . . . . . . . . . 320

2. L’aspect social et les communautés . . . . . . . . . . . . . . . . . . . . . . . . . . 3292.1 Les réseaux sociaux dans les applications . . . . . . . . . . . . . . . . . 3292.2 Ressources web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

3. En conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335

Chapitre 2

Comprendre et utiliser Unity

Comprendre et utiliser Unity1. L’interface utilisateur

Unity propose une interface riche et intuitive. Facilement personnalisable, ellepermet à l’utilisateur de configurer rapidement un environnement de travailqui lui est propre, ceci afin de gagner en productivité.

Le but de cette section n’est pas d'expliquer un à un tous les éléments quecomportent les menus et les barres d’outils (la documentation du produit rem-plit bien son office), mais plutôt d’en expliquer les éléments les plus utiles etles plus utilisés, en fournissant les informations nécessaires au lecteur tout enrestant dans le cadre du projet de l’ouvrage.

L’objectif annoncé est de fournir au lecteur les moyens de naviguer dans lesdifférentes vues et menus en toute connaissance des tenants et aboutissantsde chacun et enfin de lui permettre de configurer au mieux l’interface qu’iljugera la plus pertinente pour son projet d’application.

© E

dit

ions

EN

I -

All r

ights

rese

rved



1.1 L’organisation des fenêtres de travail

Pour appréhender l’interface proposée par Unity, il convient de définir préala-blement les modalités de fonctionnement du système. En effet, il est possiblede considérer Unity comme un agrégateur de contenu qui intègre une séried’outils pour faciliter leur interaction. Il est possible de modifier des compor-tements de ces éléments soit par du code, soit dans l’éditeur intégré, et pourgérer ces modifications l’utilisateur aura besoin de repères graphiques et nu-mériques dans un espace de travail, d’outils de saisie de valeurs, de fenêtres devisualisation d’état, d’un plan de travail, d’outils de contrôle et d’optimisationet enfin d’un référentiel de contenu.

Pour répondre à ces attentes, Unity propose différentes vues et outils que nousallons présenter.

– L’espace de travail : Unity expose deux vues à travers l’onglet Scene etl’onglet Game. Ces vues représentent respectivement l’espace de travaildans lequel la manipulation des différents objets est possible, et le rendufinal lors de l’exécution.

– La gestion du contenu disponible : à l’aide de l’onglet Project, Unityréférence dans ce dernier la liste des éléments que va contenir l’application.Cela concerne aussi bien les scripts que les objets 3D ou la musique. Il s’agitd’un référentiel de tous les éléments qui vont constituer le projet.

– Les manipulateurs visuels : une barre d’outils est proposée par Unity.Cette dernière donne la possibilité à l’utilisateur de modifier la position, larotation et la taille des éléments présents dans l’onglet Scene. Une autresection de cette barre d’outils propose une gestion de calques (que nous étu-dierons plus loin dans la section) et enfin une partie dédiée à la configura-tion de l’interface.

– Les modifications de valeurs : Unity propose deux onglets intiment liés.Il s’agit de l’onglet Hierarchy et de l’onglet Inspector. L’onglet Hierarchycomporte les éléments présents dans la scène (représentés graphiquementdans l’onglet Scene) et l’onglet Inspector expose les différentes modifica-tions possibles sur l’élément sélectionné dans Hierarchy.

33Comprendre et utiliser UnityChapitre 2

– Le suivi : avec l’aide de l’onglet Console, Unity expose à l'utilisateur unoutil de contrôle. Cet outil fournit des informations lors de l’exécution duprojet mais aussi lors de l’ajout ou la modification de code dans les différentsscripts, afin de donner un état de validation. L’utilisateur pourra ajouter sespropres informations lors de l’exécution du projet afin d’assurer un suivid’exécution, comme nous le présenterons plus loin dans ce chapitre.

La capture ci-dessous illustre l’organisation proposée par Unity lors du lance-ment d’un projet sur une plateforme PC. Nous pouvons noter la présence dedifférentes vues gérées à l’aide d’onglets et la présence d’un élément nomméMain Camera ajouté par défaut à l’onglet Hierarchy. Les informationscontenues dans l’onglet Project sont celles importées lors de la création duprojet.

Une fois cette vue générale établie, il convient de se pencher sur chaque ongletafin d’en expliquer les subtilités.

© E

dit

ions

EN

I -

All r

ights

rese

rved



1.1.1 L’onglet Scene

Cet onglet va prendre une place prépondérante dans l’interface générale. L’uti-lisateur va manipuler une multitude d’objets dans cette dernière.

Plusieurs sous-menus occupent le haut de cette fenêtre.

– Le mode d’affichage : il s’agit du type d’affichage, qui propose entre autresla possibilité d’afficher les objets 3D de façon texturée ou non par exemple.

– Le mode de rendu : il permet quant à lui de modifier le rendu de cettefenêtre (et non le rendu final de la scène une fois l’exécution lancée), ce quipeut s’avérer pratique pour positionner des objets à l’aide de la transparence.

– Le mode 2D/3D : alterne entre une vue 2D ou 3D de la scène.

– L’affichage des lumières : ce menu permet le rendu des lumières de lascène sur les objets (et uniquement sur l’onglet Scene et non pas lors del’exécution de l’application).

– L’affichage des effets sonores : permet d’afficher sur l’onglet Scene leseffets sonores, afin de les positionner par exemple.

– L’affichage des effets visuels : permet l’affichage sur l’onglet Scene deseffets visuels à l’aide de sélecteurs à cocher.

– L’affichage des Gizmos : avec ce menu, il est possible de gérer finementles Gizmos, qui sont des repères scéniques visuels. Si nous prenons parexemple une entité de type Camera, qui n’a d’autre but que de permettre àl’utilisateur final de voir la scène en cours, cette entité fournit un servicemais n’a pas de consistance 3D visuelle. Afin de la manipuler (déplacement,rotation du point de vue, etc.), l’utilisateur a besoin de la voir dans l’ongletScene. Le Gizmo est utilisé pour cela. D’autres Gizmos sont disponibles etaffichables ou pas depuis ce menu.

– La recherche : ce menu est très utile lorsque les scènes sont complexes etcomportent de nombreux objets. Lorsque l’utilisateur entre le nom de l’ob-jet, ce dernier se met en surbrillance dans la scène, ce qui est fort utile pourle repérer.

35Comprendre et utiliser UnityChapitre 2

La capture d’écran ci-dessous illustre la représentation du menu de l’ongletScene.

Pour naviguer dans une scène, les actions suivantes sont disponibles :

– Déplacement : un clic droit plus un mouvement de la souris. Le pointeurse change en main et la vue change en suivant le mouvement de la souris.

– Zoom : le zoom s’effectue à l’aide de la molette de la souris. Il est aussi pos-sible d’effectuer cette opération en utilisant la touche [Alt] avec un clic droittout en effectuant un mouvement avec la souris.

– Rotation : la touche [Alt] plus un déplacement de la souris permet d’effec-tuer une rotation de la vue actuelle autour d’un point de pivot. Un clic droitplus un mouvement de la souris fait pivoter la caméra de la vue.

Enfin, l’onglet Scene propose un manipulateur de vue. Ce dernier (illustrédans la capture d’écran ci-dessous) permet d’afficher rapidement la vue selonles axes désirés (X, Y ou Z) dans une vue de type perspective ou isométrique.

Ce manipulateur est à mettre en relation avec les boutons de la barre d’outilsqui permettent des manipulations de l’objet sélectionné selon les axes choisis.Les manipulations peuvent être liées au déplacement, à la rotation ou à lataille. Ces actions sont possibles à l’aide des boutons que l’on aperçoit dans lacapture ci-dessous.

© E

dit

ions

EN

I -

All r

ights

rese

rved



1.1.2 L’onglet Game

Cet onglet représente le rendu final de l’application. Contrairement à l’ongletprécédent, cette vue est liée à la caméra présente dans la scène. Lorsque plusloin dans ce chapitre le GameObject Camera sera traité, les modifications deces propriétés auront un impact direct sur cette vue.

L’onglet Game possède des outils intrinsèques qui vont permettre les actionssuivantes :

– La modification du ratio de rendu : lorsqu’un projet est en coursd’exécution, le rendu final s’effectue dans l’onglet Game. Il est possible dedéfinir à l’aide d’une liste déroulante le ratio d’affichage désiré pour ce rendu.Cela s’avère très pratique si l’on souhaite par exemple tester le rendu sur desrésolutions spécifiques. Cette liste déroulante propose des choix prédéfinis,mais permet aussi la saisie de nouvelles résolutions. Il est ainsi facile de testerle rendu sur une résolution de 800x600 pixels ou de 1920x1200 pixels. Avecl’option Free Aspect, il est tout aussi facile de laisser le rendu s’adapter à lataille de l’onglet actuel (il s’agit d’ailleurs du choix par défaut).

– La gestion du plein écran : lorsque l’on exécute un projet depuis Unity, ilpeut s’avérer pratique de tester le rendu en plein écran (sans l’interfaceUnity) ou alors de laisser l’exécution s’effectuer dans l’onglet. Le boutonMaximize on Play permet de commuter entre les deux possibilités. Il peutêtre intéressant de ne pas passer en mode plein écran afin de se laisser lapossibilité de modifier des valeurs ou des comportements en utilisant lesautres onglets.

– L’affichage des Gizmos : nous l’avons abordé dans l’onglet précédent, lesGizmos sont des repères visuels qui correspondent à des entités existantesjouant un rôle dans la scène mais non représentées graphiquement danscelle-ci (comme une source lumineuse par exemple). Le bouton Gizmos per-met de les afficher ou non dans le rendu final sur Unity (et non dans l’appli-cation finale compilée).

– L’affichage des statistiques : il est possible d’afficher en surimpressionune fenêtre des statistiques de la scène en cours dans l’onglet Game, à l’aidedu bouton Stats.

guide du développeur (exemples et solution complète … · de considérer unity comme un...

Documents