Manuel technique de Unity pour la configuration de

mouvements d’avatar 3D de robotique

Maïsha N. Ahmed, Maxime Raison, Ing., Ph D., Elizabeth Clark, Erg.

To cite this version:

Maïsha N. Ahmed, Maxime Raison, Ing., Ph D., Elizabeth Clark, Erg.. Manuel technique de Unity
pour la configuration de mouvements d’avatar 3D de robotique. 2023. �hal-04248763�

HAL Id: hal-04248763

[Link]
Submitted on 21 Oct 2023

HAL is a multi-disciplinary open access L’archive ouverte pluridisciplinaire HAL, est

archive for the deposit and dissemination of sci- destinée au dépôt et à la diffusion de documents
entific research documents, whether they are pub- scientifiques de niveau recherche, publiés ou non,
lished or not. The documents may come from émanant des établissements d’enseignement et de
teaching and research institutions in France or recherche français ou étrangers, des laboratoires
abroad, or from public or private research centers. publics ou privés.

Distributed under a Creative Commons Attribution - NonCommercial - NoDerivatives 4.0

International License
 MANUEL TECHNIQUE DE UNITY POUR LA
CONFIGURATION DE MOUVEMENTS D’AVATAR 3D
DE ROBOTIQUE

Maïsha N. AHMED, Maxime

RAISON, ing., PhD, et
Elizabeth Clark, erg.

Version 2023. 1

Date : 18 octobre 2023

CC BY-NC-ND : Cette licence permet aux utilisateurs de

copier et de distribuer le matériel sur n'importe quel support
ou format, sous une forme non modifiée uniquement, à des
fins non commerciales et à condition que le créateur soit cité.

CC BY-NC-ND: This license allows users to copy and distribute the material in any
medium or format in non modified form only, for non-commercial purposes only, and
only so long as attribution is given to the creator.
TABLE DES MATIÈRES

Légendes ........................................................................................................................ 4
Résumé ........................................................................................................................... 5
Introduction .................................................................................................................... 6
1. Unity .................................................................................................................... 6
1.0. Raccourcis sur Unity........................................................................................ 10
1.1. Aperçu général de Unity ................................................................................. 11
1.2. Composants .................................................................................................... 19
1.2.1. Audio Source ........................................................................................... 20
1.2.2. Mesh Renderer ........................................................................................ 20
1.2.3. Particle System ........................................................................................ 23
1.2.4. Composants physiques ............................................................................ 25
1.2.5. Script ....................................................................................................... 33
1.3. Éléments UI .................................................................................................... 33
1.3.1. Canvas ..................................................................................................... 34
1.3.2. Composant Rect Transform ..................................................................... 36
1.3.3. Image UI et Panel..................................................................................... 42
1.3.4. Texte ....................................................................................................... 43
1.3.5. Toggle ..................................................................................................... 43
1.3.6. Button ..................................................................................................... 45
1.3.7. Slider ....................................................................................................... 45
1.3.8. Dropdown ................................................................................................ 46
1.4. Animation ....................................................................................................... 48
1.4.1. Timeline ................................................................................................... 48
2. Application d’une cinématique inverse à un avatar de tige de préhension ......... 53
3. Visual Studio et codes en C# .............................................................................. 56
3.1. Variables ......................................................................................................... 57
3.1.1. Variables simples ..................................................................................... 58

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 2
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 3.1.2. Types de variables référant à Unity .......................................................... 63
3.2. Opérations ...................................................................................................... 68
3.2.1. Opérations des variables simples ............................................................. 68
3.2.2. Opérateurs d’incrémentation .................................................................. 70
3.2.3. Opérateurs d’affectation ......................................................................... 70
3.2.4. Modulo .................................................................................................... 71
3.3. Structures sélectives ....................................................................................... 71
3.4. [Link] .............................................................................................. 74
3.5. Input Manager ................................................................................................ 74
3.5.1. Commande clavier à retour unique .......................................................... 75
3.5.2. Commande clavier à retour continu ......................................................... 75
3.5.3. Commande clavier et souris à retour continu ........................................... 76
3.6. Fonctions ........................................................................................................ 76
3.6.1. Initialization Events ................................................................................. 76
3.6.2. Regular Update Events ............................................................................ 77
3.6.3. Physics Events ......................................................................................... 77
3.6.4. Fonctions Personnalisées......................................................................... 78
4. Mouvements de l’avatar de la tige...................................................................... 79
5. Limites des mouvements de l’avatar .................................................................. 79
6. Exportation d’un projet ...................................................................................... 80
Conclusion .................................................................................................................... 82
Références .................................................................................................................... 83

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 3
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
LÉGENDES

ASTUCES

REMARQUES

GUIDES D’INSTALLATION

Liens (DATE À LAQUELLE LE LIEN A ÉTÉ INSÉRÉ)

APPLICATION D’UN CONCEPT

ATTENTION !

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 4
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
RÉSUMÉ

Les évidences appuyant l’utilisation d’environnement virtuel dans le domaine de la

réadaptation s’accumulent depuis plusieurs années. Outre le potentiel à motiver
l’utilisateur dans sa réadaptation, l’activité en milieu virtuel peut aider les thérapeutes à
cibler la rééducation de mouvements et tâches précises. Ainsi, un environnement virtuel
avec avatars pour l’entraînement à l’utilisation de robot collaborateur pourra permettre
à son éventuel utilisateur de s’entraîner de façon optimale. De plus, pour bien répondre
aux besoins des utilisateurs, il est important que le concepteur technique sache
manipuler les outils les plus fréquents et importants dans l’élaboration de ce type
d’environnement virtuel. Unity, un logiciel de création fréquemment utilisé en ce sens,
s’avère complexe à maitriser pour un débutant. Le présent manuel a pour objectif de
rendre les notions à connaître plus faciles à comprendre et de les regrouper sous un
même document. L’interface Unity et quelques éléments de base, dont les objets 3D, les
éléments UI et la Timeline, y ont été abordés ainsi que la programmation à l’aide du
logiciel Visual Studio. Ces connaissances peuvent être utilisées pour concevoir des
environnements simples et les mouvements d’un avatar comme démontré dans ce
manuel.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 5
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
INTRODUCTION

L’utilisation de la réalité virtuelle (RV) en réadaptation s’est montré efficace comme

modalité d’intervention [1-3]. La RV procure des possibilités pour une stimulation
sensorielle accrue, de l’entraînement moteur intensif et des apprentissages ciblés qui
s’ajoutent aux modalités du plan d’intervention conventionnel, en plus de permettre la
mesure des progrès de l’utilisateur en temps réel [2, 4-9]. En entraînement, des effets
bénéfiques sont documentés en lien avec la répétition, des mises en situations variées
ciblées par un expert suivant les principes du défi adéquat, la mise en confiance, la
sécurité ainsi qu’avec les effets d’obstacles et feedback sur la performance [2, 3, 6, 8-10].
Ces effets ont été rapportés sur le contrôle moteur, l’apprentissage moteur et la
neuroplasticité motrice [3, 6, 10].

Unity est un logiciel de programmation de jeux qui a déjà été utilisé pour créer des jeux
en réadaptation [11]. Bien qu’il soit plus facile à manipuler que le logiciel Unreal Engine
pour un débutant, les ressources en ligne peuvent s’avérer plus complexes que nécessaire
[12, 13]. L’objectif de ce document est de regrouper les notions de base pour pouvoir
créer des jeux ainsi qu’un exemple d’application de certaines fonctions pour pouvoir
contrôler un avatar importé de Blender. Pour plus de détails sur le modèle importé,
veuillez vous référer au manuel technique de Blender rédigé par les mêmes auteurs [14].

1. UNITY

Unity est un logiciel utilisé pour la conception de jeux. Il peut être installé par le lien
suivant : [Link] (septembre 2023).

Une application nommée Unity Hub sera installée en premier, mais il reste encore
plusieurs étapes avant la conception de jeux. D’abord, il faut se créer un compte
personnel Unity ID, autant pour avoir accès aux contenus de l’Asset Store que pour être
éligible à la licence gratuite. En fait, si les jeux produits sur Unity amènent un revenu
moindre que 100,000 $, il est possible de l’utiliser gratuitement. Sinon, il va falloir payer.
Il y a également d’autres types de comptes avec diverses conditions et prix d’utilisation,
mais pour ce document, un compte personnel a été utilisé. Ainsi, à l’ouverture du Hub, il
sera demandé de soit s’inscrire à un compte existant soit d’en créer un. À remarquer qu’il
est possible d’en créer un en tout temps en allant sur l’icône de profil qui se trouve à
gauche de la fenêtre du Hub (figure 1).

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 6
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 1 : Options pour ouverture d’un compte Unity ID

Par la suite, il y aura l’installation de l’éditeur. Pour ce faire, dans la section Installs du Hub
(figure 2), il faut cliquer sur Install Editor et installer la version qui nous intéresse. Dans ce
manuel, les versions 2021.3 d’Unity ont été utilisées.

ATTENTION !

Il y aura toujours une version recommandée d’éditeur dans l’installation, mais il y aura
également des versions en développement qui se trouveront dans la section Pre-release.
Celles-ci sont à éviter, car elles peuvent nuire à certaines fonctions d’Unity ! Pour ce
document, les versions utilisées étaient les versions recommandées de la section Official
releases.

Une fois l’éditeur installé, il faut se rendre encore une fois dans la section Installs du Hub
comme indiqué dans la figure ci-dessous. Dans la section représentant la version
installée, il faut cliquer sur l’icône de rouage et Add modules pour pouvoir ajouter des
composants clés à la création et l’utilisation d’Unity.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 7
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 2 : Ajout de modules nécessaires pour la conception de jeux sur Unity et leur
exportation

Un composant majeur à installer est le logiciel pour le codage : Microsoft Visual Studio
Community 2019. Dans les explications de ce manuel, les versions 16.11 ont été utilisées
et le langage informatique s’agit du C#. Bien sûr, il est toujours possible d’utiliser d’autres
logiciels avec un langage de codes différent. Dans ce cas, il n’y aura pas besoin d’ajouter
ce module ; il faudra seulement ajuster ce paramètre sur Unity (mentionné dans l’astuce
de synchronisation Unity-Visual Studio). Comme pour Unity, 2 applications seront
installées : Visual Studio Installer et Visual Studio. Pareillement, ce logiciel de codes
nécessite l’installation de modules additionnels. Une nouvelle fenêtre apparaitra dans
laquelle il faut au moins installer le module Game development with Unity sans toutefois
cocher Unity Hub puisqu’il est déjà installé comme démontré dans la figure suivante.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 8
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 3 : Fenêtre d’installation de modules pour Visual Studio, dont celui du
développement de jeux avec Unity.

Il est possible en tout temps d’ajouter d’autres composants à Visual Studio en ouvrant
l’Installer et en cliquant sur Modify, ce qui permettra de modifier la version courante
(figure 4).

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 9
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 4 : Page d’accueil du Visual Studio Installer

Enfin, il faut activer la licence personnelle. Pour ce faire, il faut cliquer sur Manage licenses
comme indiqué sur la figure 1. Sur la fenêtre qui s’affiche, il faut cliquer sur Add, puis sur
Get a free personal license pour l’accès gratuit d’Unity.

1.0. RACCOURCIS SUR UNITY

Pour afficher, dans la hiérarchie, les objets enfants associés à des parents qui sont eux-
mêmes des enfants d’un autre objet : Tenir Alt et cliquer sur la flèche vers le bas (un
exemple visible sur la figure 5, dans le cercle rouge) qui se trouve à côté de l’objet parent

Pour accéder aux outils de la fenêtre Scene : QWERTY

Q : View Tool

W : Move Tool

E : Rotate Tool

R : Scale Tool

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 10
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 T : Rect Tool

Y : Transform Tool

Pour zoomer dans la fenêtre Timeline et Scene : molette de la souris

Pour faire l’accent sur un Clip dans la Timeline : sélectionner le Clip au choix + touche F

Pour afficher/rendre visibles tous les Clips dans la Timeline : touche A

1.1. APERÇU GÉNÉRAL DE UNITY

Une fois les installations complétées, un projet 3D a été ouvert pour créer un jeu 3D.
L’écran suivant apparait :

Figure 5 : Affichage de base à l’ouverture d’un dossier 3D CORE Unity

Soulignons les fenêtres de base indiquées dans la figure 5.

La fenêtre la plus importante s’agit de la fenêtre Project (figure 5, section bleue) en bas
de l’écran. Elle représente le dossier Unity qui a été ouvert à la création d’un projet Unity.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 11
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Si l’on regardait le dossier de projet créé sur l’ordinateur, il serait possible de remarquer
que les dossiers retrouvés dans cette fenêtre sont identiques aux dossiers retrouvés sur
le disque. Tous les matériaux importés devront être sauvegardés dans le dossier Assets.

REMARQUE ! IMPORTATION DE MÉDIAS

Lorsqu’on regarde les options pour importation, que ce soit par l’intermédiaire
de l’onglet Asset en haut de l’écran ou juste en cliquant sur le bouton droit de la
souris dans la fenêtre Project, 2 choix se présenteront : Import New Asset… et
Import Package — Custom Package.

Le choix va dépendre du type de fichier à importer. Dans le cas de médias de type

Unity, c’est-à-dire des fichiers qui ont été créés sur Unity, il faut utiliser la
fonction Import Package. On en retrouve souvent dans les forums en ligne où
d’autres créateurs partagent leur travail.

Dans le cas de médias de forme native (ex. JPEG, MP3, PNG, SOUNDWAVE, etc.),
il est possible d’utiliser l’option Import New Asset…, mais une façon plus simple
est de glisser et de déposer dans la fenêtre Project le fichier en question.

ATTENTION !

Il est très important de ne jamais modifier les dossiers Unity trouvés sur le disque. S’il y
a besoin de faire des changements dans le dossier de projet, il faut le faire directement
sur Unity. Sinon, il risque d’avoir des erreurs à la prochaine ouverture du projet et ainsi
tout le travail sera perdu.

Il y a également la hiérarchie (section rouge) à droite de l’écran, telle que visible sur la
figure 5 ci-dessus. Elle représente les objets sur la scène sous forme de liste. L’ordre
importe peu dans le cas des objets 3D sauf dans le cas d’objet UI dont le texte, les
boutons, les images, etc. Dans ce cas, un objet UI en haut sera plus loin de la caméra alors

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 12
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
qu’en bas de la hiérarchie, l’objet UI sera plus proche de la caméra. Pour plus de détails
sur les éléments UI, référez-vous à la section 1.3.

ATTENTION !

Il est possible d’avoir plusieurs scènes dans un même dossier Unity. La hiérarchie contient
donc les objets présents dans la scène sélectionnée. Il est possible de savoir dans quelle
scène on travaille en regardant le nom indiqué dans la hiérarchie. Dans la figure 5, il s’agit
de la scène de défaut nommée SampleScene.

Il est aussi à noter qu’une scène n’équivaut pas à un niveau de jeu. Il est possible qu’un
niveau englobe plusieurs scènes tout comme il peut en englober rien qu’une. Tout
dépend du programmeur.

Ensuite, il y a les fenêtres Scene et Game. La fenêtre Scene (figure 5, section jaune) est
« l’arrière-plan » des jeux créés. Il permet d’organiser physiquement les objets dans
l’espace alloué à la fabrication de jeu. À gauche de la fenêtre, les outils pour bouger la
vue et pour bouger , tourner et mettre à l’échelle les objets se trouvent. Il
y a également l’outil de transformation qui regroupe le tout ainsi qu’une autre
variante du même outil, le Rect Transform (plus d’informations sur cet outil dans la
section 1.3.2.). La fenêtre Game (figure 5, section verte), quant à elle, est un aperçu du
jeu. Il est possible de démarrer et de jouer son jeu tel que le ferait un joueur en pesant sur
le bouton Play tout en haut de l’écran.

Dans le cas où il y a des messages envoyés issus du code lors de l’exécution du jeu ou dans
le cas d’erreurs dans le codage, des messages s’afficheront dans la fenêtre Console
(figure 5, onglet orange), qui se trouve dans le même emplacement que la fenêtre
Project. Dans le cas d’erreurs, il sera possible de double-cliquer sur le message et cela
nous amènera directement à l’emplacement de l’erreur sur Visual Studio. Cette fenêtre
est l’intermédiaire entre Unity et l’éditeur de codes.

ASTUCE ! SYNCHRONISER UNITY ET VISUAL STUDIO

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 13
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Bien qu’il soit possible d’écrire du code sur Visual Studio pour créer un jeu soi -
disant jouable, il est très difficile de se retrouver dans le cas d’erreurs à partir d e
la Console s’il n’y a pas de connexion avec Unity. Il est donc important, après
l’installation des 2 logiciels, de les synchroniser pour que Unity puisse faire le lien
avec Visual Studio pour trouver l’erreur exacte et pour que Visual Studio puisse
donner des suggestions selon les fonctions de Unity.

Pour ce faire, il faut d’abord spécifier l’éditeur de codes à Unity. C’est à cette
étape qu’il sera possible de choisir le logiciel de codes dans le cas où il diffère de
Visual Studio. Pour y arriver, il faut d’abord accéder à la fenêtre Preferences
(figure 6) par l’intermédiaire de l’onglet Edit. Ensuite, il faut se rendre dans la
section External Tools où son 1 er paramètre, External Script Editor, permet de
choisir l’éditeur de codes parmi ceux installés sur l’ordinateur.

Figure 6 : Paramètre External Script Editor dans Unity qui permet le choix de
l’éditeur de codes

Il se peut toutefois qu’il y ait des problèmes de connexions entre Unity et Visual
Studio, malgré avoir choisi le bon éditeur de codes. La façon la plus sûre de voir
s’il y a des problèmes de ce type est de regarder dans la barre d’outils de Visual
Studio la section nommée Debug. Si elle contient des mots génériques comme
Default → Default, il est certain qu’il y a des problèmes de connexions. Il faut

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 14
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
qu’elle ait Attach to Unity (figure 7) pour montrer qu’il y a une bonne connexion
entre les 2 logiciels.

Figure 7 : Il est nécessaire que le Debug dans Visual Studio affiche Attach to
Unity pour permettre une exécution optimale entre les 2 logiciels

Un autre moyen qui peut sembler moins évident est la quantité de couleurs dans
les codes telle qu’observable sur la figure 8 suivante. En fait, une fois attaché à
Unity, Visual Studio sépare les différents codes selon le groupe dans lequel ils
appartiennent. Ainsi, si les lettres sont en majorité blanches ou noires, il se
pourrait que ce soit une indication de problèmes de connexion. Bien sûr, il se
peut également que des termes qui sont normalement blancs ou noirs aient été
utilisés. Dans ce cas, ce ne serait pas une bonne indication.

Il y a également des petites écritures qui apparaissent en haut des classes et des
fonctions qui mentionnent les références de celles-ci dans les codes, dans Unity
lors de l’exécution, etc. Un exemple est d’ailleurs visible tout en haut de la
figure 8 B.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 15
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 A B

Figure 8 : (A) Affichage des codes lors d’une déconnexion entre Visual Studio
et Unity. (B) Affichage des codes en réponse à la connexion entre Visual
Studio et Unity, ainsi que l’apparition de textes de référence

Maintenant qu’on sait à quoi ressemble une bonne connexion, comment faire
pour l’établir si ce n’est pas fait automatiquement ? Plusieurs solutions s’offrent.

D’abord, banal qu’il soit, il faut retourner sur Unity Hub et bien s’assurer que le
module Microsoft Visual Studio Community 2019 est bien installé tel que démontré dans
la section 1.

S’il l’est et qu’il y a encore des problèmes, il est avisé de revoir si l’éditeur de codes
sélectionné dans les Preferences est bien Visual Studio et non Open file by extension. Une
fois choisi, il faut cliquer sur Regenerate project files (figure 6).

Si malgré tout, il reste encore des problèmes, il se pourrait que Visual Studio ne soit pas
à jour. Pour la mise à jour, 2 solutions sont possibles. À partir de Unity, il faut se rendre à
la fenêtre Package Manager sous l’onglet Windows et chercher l’extension Visual Studio
Editor en étant dans Packages : Unity Registry (figure 9). Dans l’endroit où se trouve
Remove, dans le cas où le logiciel ne soit pas à jour, il y aurait un choix de type Install ou
Update.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 16
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 9 : Exemple de recherche sur Package Manager à travers tout le registre de
Unity pour trouver Visual Studio Editor

Sinon, il est évidemment possible de faire la mise à jour à partir de Visual Studio (et non
Visual Studio Installer !). Il faut se rendre à l’onglet Help et cliquer sur Check for updates.
Une fois la mise à jour installée, il faut quitter Visual Studio.

Peu importe la solution utilisée, il faut toujours redémarrer Unity après l’application de
chaque solution pour mettre en place les changements. Ainsi, les problèmes de
connexion devraient être résolus.

ATTENTION !

Bien qu’il soit recommandé de choisir un logiciel de codes avec lequel on est à l’aise, il
faut toutefois tenir compte du fait que les tutoriels, les exemples et les explications en

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 17
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ligne de Unity sont, soit en majeure partie en C# avec Visual Studio, soit, un peu moins
souvent, en C++ avec Java. Le choix de l’éditeur de codes est donc à vos risques !

Finalement, il y a la fenêtre Inspector (figure 5, section mauve). Elle contient les

informations et les diverses propriétés de l’objet, affichées sous forme de composants.
Par défaut, l’Inspector affichera le composant Transform en tout temps, même pour un
qui est vide.

Dans l’en-tête de cette fenêtre (figure 10), il y a d’abord une icône de cube qui permet
de représenter l’objet sous la forme d’une icône dans la fenêtre Scene, surtout utile dans
le cas d’objet vide ou transparent.

Juste à côté, il y a une boîte avec un crochet et la barre pour taper le nom de l’objet. Il est
possible de remarquer que les composants ont aussi des boîtes avec ou sans crochet. Ces
boîtes permettent d’activer (avec crochet) ou de désactiver (sans crochet) soit l’objet
entier, par la boîte dans l’en-tête, ou soit un composant en question. Dans ce cas, la boîte
se trouvera sur l’en-tête du composant. Certains exemples de composants seront
mentionnés dans la section 1.2. ci-dessous.

Un autre point à souligner dans cette fenêtre serait le menu défilant Tag où il est possible
d’étiqueter les objets. Cette fonction est grandement utile lorsqu’il y a besoin d’appeler
un objet par du code.

Figure 10 : En-tête de la fenêtre Inspector

ASTUCE ! REDIMENSIONNEMENT ET RÉORGANISATION DES FENÊTRES

Il est possible de redimensionner la taille des fenêtres de Unity ; il suffit de survoler le
curseur sur leurs bordures pour qu’il change en une flèche à double sens.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 18
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Il est également possible de glisser les onglets pour réorganiser l’espace de travail de
Unity. Une fois satisfait de l’emplacement des fenêtres, il est possible de verrouiller la
disposition par l’entremise du menu déroulant Layout en haut à droite de l’écran —
Default—Save Layout. Ceci affichera à son tour une fenêtre contextuelle qui demandera
de nommer la disposition pour compléter son enregistrement.

Figure 11 : Options d’affichage des fenêtres de Unity, dont le Save Layout… qui
permet la sauvegarde d’une disposition personnalisée

Par défaut, ce menu déroulant aura la disposition de base (Default) tel que démontré
dans la figure 5. Il contient également des dispositions prédéfinies que l’utilisateur peut
choisir.

1.2. COMPOSANTS

Lorsqu’un objet est sélectionné, la fenêtre Inspector affiche non seulement ses propriétés
physiques, soit sa position, sa rotation et sa mise en échelle, dans le composant
Transform, mais elle affiche également toute autre propriété que l’objet puisse avoir.

Les objets de base contiennent par défaut des composants qui leur sont propres. Il y a,
par exemple, la caméra qui contient les composants Camera et Audio Listener, la lumière

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 19
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
qui contient le composant Light, les objets 3D qui ont tous un Mesh Renderer, ainsi de
suite.

Il est également possible d’ajouter des composants aux objets, par exemple, lorsque le
point de départ est un objet vide. Pour ce faire, dans la fenêtre Inspector, il y aura tout en
bas un bouton Add Component qui affichera toute une liste de catégories de composants.
En voici quelques-uns en détail :

1.2.1. AUDIO SOURCE

Il est possible de retrouver le composant Audio Source (figure 12), que ce soit en tant que
composant à partir du Add Component de l’Inspector ou en tant qu’objet à partir du
bouton droit de la souris dans la hiérarchie. Comme son nom l’indique, elle transforme
l’objet en un émetteur de son. Sa propriété AudioClip permet de choisir un son ou une
musique au choix et de l’appliquer à l’objet. Mute évidemment rend le son silencieux. Play
on Awake démarre l’audio dès l’exécution du jeu alors que le Loop recommence le média
sonore à sa fin. La propriété Pitch permet de jouer avec la vitesse de l’audio alors que
Stereo régit la stéréophonie du son. Le volume s’explique de lui-même.

Figure 12 : Composant Audio Source et quelques-unes de ses propriétés

1.2.2. MESH RENDERER

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 20
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Avant d’aborder ce composant, il faut d’abord savoir ce qu’est un Mesh. Un Mesh est un
ensemble de surfaces triangulaires ou rectangulaires qui forment l’ensemble graphique
de Unity. Par exemple, le Mesh d’un cube de base consiste à 6 carrés.

Le composant Mesh Renderer, lui, permet de gérer l’apparence de l’objet. Pour ce faire,
le composant Mesh Filter prend le Mesh des Assets du projet (par exemple, le Mesh d’un
modèle fait sur Blender) et le transfert au Mesh Renderer pour que celui-ci puisse l’afficher
sur la scène.

Figure 13 : Composants régissant le Mesh d’un objet — le Mesh Filter et le Mesh Renderer

Ce composant contient plusieurs propriétés, mais seulement celle des Materials a été
soulignée dans ce manuel. Unity utilise le terme Material pour les couleurs et fausses
textures qui peuvent être ajoutées aux objets. On parle de fausses textures, car les
surfaces seront recouvertes par une image, mais ne changeront pas de forme pour
donner une surface texturée. Les Materials de Blender, un logiciel de modélisation 3D,
sont d’ailleurs exportés sous forme de Materials de Unity. La propriété Materials contient
une liste d’Elements qui regroupe les matériaux utilisés sur l’objet. Il est possible d’en
ajouter ou d’en supprimer à l’aide des en dessous de la liste.

Pour les autres propriétés, veuillez-vous référer à la page Unity sur le Mesh Renderer.

CRÉATION D’UN MATÉRIEL

Pour créer un matériel, il faut cliquer sur le bouton droit de la souris — Create—
Material (et non Physic Material !) sur la fenêtre Project. Ceci ajoutera un média
Material sur le dossier du projet.

Sur la fenêtre Inspector, l’affichage suivant apparaitra :

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 21
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Figure 14 : Nouveau matériel créé avec propriétés de base, soit une couleur
blanche

La propriété Albedo permet de choisir la couleur du matériel. Puis, Metallic

permet de donner une allure métallique à l’objet et, en fonction du Smoothness,
le métal sera réfléchissant ou mat. En cochant sur Emission, le matériel devient
une source lumineuse et émettra une lumière d’une couleur au choix.
Finalement, le petit carré à côté des propriétés permet d’ajouter une image qui
s’appliquera à chaque surface. Ainsi, il est possible de donner une impress ion de
texture à l’objet sans vraiment modifier sa forme.

Pour appliquer un matériel à un objet, il suffit de soit glisser le matériel à un objet

ou le choisir dans la liste d’Elements du Mesh Renderer.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 22
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
1.2.3. PARTICLE SYSTEM
Le Particule System sert souvent à simuler du liquide ou du gaz. Il utilise des formes 2D et
les génère à répétition pour animer, par exemple, de l’eau ou du feu (exemple dans la
figure ci-dessous).

Figure 15 : Exemple d’application du système de particules pour former du feu

Ce composant peut être directement ajouté comme un objet à part dans la hiérarchie
tout comme l’Audio Source. Pour ce faire, il suffit de cliquer sur le bouton droit de la souris
dans la hiérarchie et choisir le Particle System de la section Effects. À l’ajout, des formes
flottantes vont apparaitre et disparaitre de la Scene tel que démontré dans la figure ci-
dessous et une fenêtre contextuelle Particles s’affichera sur le coin en bas à droite de la
Scene.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 23
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 16 : Particle System de base tel que vu sur la Scene

Cette dernière sert à donner un aperçu des changements sur les particules et non à
changer leurs apparences réelles. La Playback Speed permet de changer la vitesse de
l’exécution. Elle est souvent augmentée pour visionner les effets à long terme de ce
système. Selon la Playback Speed, le Playback Time affichera le temps passé depuis que
le système a été activé. Il peut donc être plus vite ou plus lent que le temps réel à cause
de cette vitesse. La propriété Simulate Layers, qui est à Nothing par défaut, permet
d’exécuter plusieurs Particle System en même temps. Effectivement, si un objet avec un
Particle System est sélectionné, l’autre objet avec un Particle System ne jouera pas dans
la Scene. Pour jouer les 2 en même temps, toujours dans la Scene et non dans le Game
lors de l’exécution du jeu, il faut mettre Simulate Layers à Everything. Resimulate fait que
les changements effectués sur le composant dans l’Inspector s’appliquent sur toutes les
particules. Par défaut, lorsque cette propriété n’est pas cochée, les changements
s’appliqueront seulement sur les nouvelles particules générées alors que les anciennes
qui demeurent auront l’apparence précédente. Show Bounds fera apparaitre un cube qui
délimite la zone où l’effet des particules aura lieu alors que Show Only Selected cache tout
système de particules non sélectionné.

Pour réellement changer les particules produites, il faut jouer avec les multiples
propriétés séparées en modules qui se trouvent dans le composant Particle System de
l’Inspector. En raison de la complexité de cette composante, seulement certaines

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 24
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
propriétés seront mentionnées dans ce document. Pour le reste, veuillez-vous référer au
manuel Unity.

Il y a d’abord le Main Module qui contient les propriétés de base du système de particules.
Il y a la Duration qui est la durée de temps que le système s’exécute. Tout comme le
composant Audio Source, il y a l’option de Looping qui redémarre l’exécution du système
de particules une fois que ces dernières disparaissent. Bien sûr, si le Loop est activé, la
Duration représente la durée d’un cycle d’exécution. Il est possible de mettre un délai à
l’exécution du système avec la propriété Start Delay. Il est également possible de jouer
avec la durée de vie (Start Lifetime), la vitesse (Start Speed), la taille (Start Size), la
rotation (Start Rotation) et la couleur (Start Color) des particules. Aussi, comme
mentionné plus haut, le système de particules utilise des formes 2D pour simuler des
effets spéciaux. Pour les donner une apparence 3D, il est possible de jouer avec l’attribut
3D Start Size pour leur donner des dimensions selon les axes cartésiens. Puis, encore
comme l’Audio Source, la propriété Play on Awake démarre le système de particules dès
l’exécution du jeu. Enfin, il est possible de choisir le nombre de particules qui se
présentent par cycle à l’aide de la propriété Max Particles.

Par défaut, les modules Emission, Shape et Renderer sont activés. Emission contient des
attributs qui peuvent déterminer le taux de production de particules par unité de temps
(Rate over Time) ou de distance (Rate over Distance). Shape permet de choisir un volume
duquel émergent les particules. De base, il s’agit d’un cône, mais d’autres formes peuvent
être choisies par la propriété Shape, même des formes personnalisées. Finalement, le
module Renderer regroupe des propriétés liées à l’apparence des particules. Il y est
possible d’associer un Material aux particules, entre autres, ainsi que de permettre la
création de particules de taille entre un certain intervalle.

1.2.4. COMPOSANTS PHYSIQUES

Deux types de composants ont été privilégiés à ce jour pour introduire les lois de la
physique aux jeux développés : les Colliders et le Rigidbody. Ces composants physiques
sont décrits davantage ci-dessous. Aux meilleurs de notre connaissance à ce jour, Unity
semble répliquer les lois de la physique et de la mécanique (par exemple, la cinématique).
Il n’a pas été possible d’identifier des équations physiques qui régissaient le mouvement
des systèmes multicorps dans ce logiciel.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 25
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
COLLIDERS
Les Colliders sont une catégorie de composants utilisés pour détecter les collisions dans
un jeu. Plusieurs formes prédéfinies de Colliders existent sur Unity, les Colliders primitifs
(Box, Sphere, Capsule), et il est également possible d’avoir un Mesh Collider qui forme un
Collider basé sur la forme d’un objet irrégulier.

Il est d’ailleurs possible de changer la taille des Colliders primitifs par le bouton Edit
Collider . La modification est active lorsque le Collider apparait en vert sur la Scene et
les changements seront reflétés dans les propriétés Center et Size du Collider. Ce même
outil s’affiche automatiquement en bas des autres outils de la fenêtre Scene lorsque
l’objet sélectionné contient un Collider prédéfini.

Il est également possible de remarquer une propriété intitulée Is Trigger. En cochant

celle-ci, l’objet devient sensible à des collisions spécifiques définies par des codes. Sinon,
aucune collision n’est détectée par l’objet. Cette action peut être appelée à l’aide de la
fonction OnTrigger qui sera décrite plus loin dans la section 3.6.3.

ATTENTION !

Il existe 2 types de Colliders primitifs dans Unity : les Colliders 2D et les Colliders 3D.
Malheureusement, seulement les Colliders 2D sont nommés correctement (ex. Box
Collider 2D, Capsule Collider 2D, etc.). Il n’y a pas de « 3D » ajouté aux noms des
Colliders 3D. Il faut donc faire attention qu’il s’agit bien du composant 3D qui est ajouté
dans un projet 3D. Sinon, les effets désirés n’auront pas lieu !

Enfin, il est possible d’ajouter un matériel physique aux Colliders par la propriété
Material.

CRÉATION D’UN MATÉRIEL PHYSIQUE

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 26
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Un matériel physique ne contient que 2 propriétés : la friction et le
rebondissement. Il peut être ajouté à un Collider pour donner ces caractéristiques
à l’objet.

Pour en créer un, il suffit de cliquer sur le bouton droit de la souris dans la fenêtre
Project, puis d’aller sur Create — Physic Material, à bien distinguer contre Material
qui créerait un matériel de couleur à associé à un Mesh Renderer d’un objet.

Figure 17 : Création d’un matériel physique

L’Inspector affichera alors la fenêtre suivante :

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 27
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 18 : Propriétés de friction et de rebondissement d’un matériel
physique

Les propriétés de frictions et de rebondissement peuvent être définies à une

valeur entre 0 et 1. La Dynamic Friction est la friction de l’objet en mouvement.
Une valeur proche de 0 rend l’objet très glissant alors qu’une valeur à proximité
de 1 le rend difficile à bouger à moins qu’une force excessive lui soit appliquée.
Les mêmes valeurs ont ces mêmes effets sur un objet immobile si elles sont
appliquées sur la Static Friction. Le Bouciness, lui, rend la surface de l’objet
élastique. Une valeur avoisinante de 0 ne confère aucun rebondissement alors
que, proche de 1, l’objet rebondit sans perte d’énergie. Les propriétés Combine
permettent de déterminer la friction ou le rebondissement de 2 objets en
collision.

Contrairement aux Colliders primitifs, les Mesh Colliders ont quelques

caractéristiques qui diffèrent. D’abord, il n’est pas possible de modifier la taille
du Collider. À la place, il est possible de choisir s’il reste de forme concave par
défaut ou s’il devient convexe en cochant la propriété Convex. Dans ce cas, le
Collider ne serait pas nécessairement conforme à la forme de l’objet. Il y a
également une particularité Cooking Options qui médie la façon dont les
systèmes de physique de Unity vont évaluer les Mesh de l’objet pour les
collisions. Pour plus d’informations, vous pouvez consulter la page du manuel à ce
propos. Enfin, la propriété Mesh contient le Mesh de l’objet en question pour
pouvoir former le Collider. Sinon, tout comme un Collider primitif, il y a les
options Is Trigger et Material. Cependant, le Is Trigger n’est possible que sur un
Mesh Convex.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 28
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
RIGIDBODY
Un Rigidbody, quant à lui, permet le contrôle des mouvements et des positions de l’objet
selon les forces physiques simulées sur Unity. Il est possible de remarquer qu’un objet
avec ou sans Collider restera dans les airs lors du démarrage du jeu. Cependant, avec un
Rigidbody, il tombera par effet de la gravité et continuera de tomber jusqu’à que le jeu
soit arrêté ou jusqu’à qu’il rentre en collision avec un autre objet.

Mentionnons certaines propriétés du Rigidbody (figure 19). Il y a d’abord la Mass de

l’objet qui peut être ajustée. Par défaut, elle est à 1 kg. Selon Unity, la masse n’affecte
pas les effets de la gravité ; l’objet tombera peu importe sa masse. En fait, ceci peut être
démontré par 2 objets avec des Rigidbodies. Si l’on a une masse de 1 kg et l’autre a une
masse de 10 kg, il est possible de voir que les 2 tomberont à la même vitesse. Ceci appuie
davantage sur le fait que Unity simule approximativement les aspects physiques sans
vraiment se baser sur des équations. Notre supposition actuelle est que les équations de
mouvements sur Unity ne considèrent pas l’accélération.

Figure 19 : Composant Rigidbody et ses propriétés

Si l’on désire que l’effet de la gravité soit moindre, que l’objet tombe plus lentement, la
propriété Drag est à considérer. Elle définit le taux de décélération de la vitesse linéaire
et permet la simulation de friction ou de résistance de l’air. Une grande valeur de
décélération fait que l’objet ralentit rapidement, ce qui est idéal pour simuler des choses
légères, tandis qu’une petite valeur fait que l’objet est rapide dans sa chute, tout comme
un objet de haut poids dans la vraie vie.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 29
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Ces mêmes caractéristiques s’appliquent au Angular Drag qui médit la décélération de la
vitesse de rotation. Un Angular Drag d’une valeur infinie empêcherait l’objet de tourner.

Par défaut, la case Use Gravity est active, ce qui applique une force sur l’objet vers le sens
de la gravité (par défaut, vers le négatif de l’axe des y). Cependant, comme décrit plus
haut, si elle ne l’était pas, l’objet ne tomberait pas et resterait figé à la même place.

ASTUCE ! COMMENT CHANGER LE SENS DE LA GRAVITÉ ?

Puisque les lois de la mécanique et de la physique sont simulées sur Unity, il est
possible de changer la constante de gravité ainsi que son sens.
Pour la modifier, il faut aller sur l’onglet Edit — Project Settings. Dans la section
Physics, la 1 re propriété est la gravité avec une valeur de -9.81 sur l’axe des y, tel
que démontré sur la figure ci-dessous.

Figure 20 : Quelques propriétés physiques qui peuvent être changées pour le

projet au complet, dont la gravité
Ainsi, pour changer d’axe, il suffit de mettre la constante de gravité sur un autre
axe. On peut également modifier la valeur, peu importe la raison (par exemple,
l’objet est trop lent dans sa chute).

ATTENTION !

Altérer la valeur ou le sens de la gravité affectera le projet au complet ! C’est pour cette
raison que cette propriété se trouve dans les Project Settings. Ainsi, changer de scènes de
travail ne remettra pas à 0 cette valeur.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 30
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Is Kinematic est une propriété du Rigidbody qui permet de changer le contrôle de l’objet
entre les mouvements basés sur les forces physiques (décoché) et les mouvements basés
sur les propriétés Transform de l’objet (coché). Un personnage pourrait par exemple être
contrôlé à marcher sur l’axe des x. Puis, à la collision d’une explosion, Is Kinematic
pourrait être décoché par du code, ce qui appliquerait les forces physiques au
personnage, lui conférant un effet « ragdoll ».

Dans le cas de mouvements fébriles d’un objet avec un Rigidbody, il est possible de les
atténuer par la propriété Interpolate. Par défaut, elle est à None. Pour régler les
mouvements brusques, il est possible de changer son mode à soit Interpolate ou
Extrapolate. Ceux-ci utilisent la position et la vitesse détectées dans les 2 dernières
Updates pour prédire et appliquer des meilleures position et vitesse à l’objet dans
l’Update actuelle. Le concept d’Update sera davantage abordé dans la section 3.6.2. Le
choix va par contre dépendre de l’effet visuel désiré. Interpolate est plus précis
qu’Extrapolate. En fait, ce dernier donne l’impression que l’objet bouge avant même qu’il
doive bouger. Dans le cas d’un objet où sa vélocité varie en fonction de forces physiques
ou par des codes, Interpolate serait un meilleur choix pour pouvoir maintenir ces
changements de façon précise et sans mouvements brusques. Sinon, pour un objet qui
maintient une vélocité constante, Extrapolate serait le meilleur choix.

REMARQUE ! CONDITIONS POUR AVOIR DES COLLISIONS

Pour qu’une collision ait lieu, c’est-à-dire que 2 objets avec un Collider rentrent en contact
et interagissent entre eux physiquement, il faut qu’au moins 1 d’entre eux ait un
Rigidbody. Cependant, juste avoir ces 2 composantes n’est pas suffisant à cause des
différentes propriétés modifiables, surtout Is Kinematic et Is Trigger. Pour savoir quels
objets subiront une collision et lesquels n’en subiront pas, il faut suivre le tableau suivant
procuré par le manuel de Unity :

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 31
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Figure 21 : Les combinaisons de Collider et de Rigidbody possibles pour détecter des
collisions et des Trigger. Un Static Collider est un objet avec un Collider, mais sans
Rigidbody. Les Y définissent les collisions selon les types d’objets, que ce soit avec ou
sans Rigidbody, avec ou sans Is Kinematic ou Is Trigger.

ATTENTION !

Contrairement aux Colliders primitifs, les Mesh Colliders ont plus de limitations quant aux
collisions. Bien qu’un Mesh Collider offre plus de surface de contact pour les collisions,
dans les versions actuelles de Unity (ver 2021.3), les objets qui ont un Rigidbody peuvent
seulement supporter un Mesh Collider convexe pour les collisions de type Trigger.

La propriété Collision Detection du Rigidbody définit la façon dont le système de physique

de Unity va détecter les collisions subies par l’objet contenant le Rigidbody et un Collider.
De base, elle est à Discrete. Ce choix est optimal pour un Rigidbody qui ne subit pas de
collisions rapides. Sinon, les 3 autres options sont des meilleurs choix pour des collisions
rapides. Continuous est meilleur pour les collisions avec des Colliders sans Rigidbody.
Continuous Dynamic peut être utilisé pour les collisions avec tout objet ayant un Collider,

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 32
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
peu importe la présence de Rigidbody, sauf avec les objets avec un Rigidbody de type
Discrete. Enfin, Continuous Speculative permet de détecter toutes collisions et il est
privilégié dans le cas de collisions où la précision n’est pas importante.

La dernière propriété du Rigidbody est les Constraints qui permettent de figer la position
ou la rotation de l’objet selon les axes x, y ou z.

1.2.5. SCRIPT
Pour qu’un code soit exécutable, il faut toujours qu’il soit associé à un objet. Il est possible
de l’ajouter soit à partir du Add Component dans l’Inspector dans la section New Script ou
en créant un Script dans la fenêtre Project (bouton droit de la souris — Create — C# Script).
Une fois ce fichier de type .cs créé, il faut tout simplement le glisser à l’objet de notre
choix ou le chercher dans la barre de recherche du Add Component.

1.3. ÉLÉMENTS UI

Lors de la création d’objets dans la hiérarchie, il est possible de voir une section UI. Elle
regroupe les éléments nécessaires pour créer une interface usager, d’où UI (User
Interface). Des exemples d’interfaces usagers pour des jeux seraient le Menu, l’affichage
de l’écran Pause, les boutons pour démarrer le jeu, pour sortir de l’écran, les glissières
pour changer le volume, etc.

Dans le cas d’un élément UI créé, deux objets apparaitront automatiquement avec l’objet
ajouté. Ils s’agissent du Canvas, qui devient l’objet parent de l’élément UI ajouté, et de
l’Event System.

L’Event System est un composant de gestions internes qui est invisible sur la Scene. En
fait, le Canvas utilise l’Event System pour gérer les inputs reçus de l’interface usager et ce
dernier gère également les outputs résultant des différents évènements. Autrement dit,
sans Event System, il ne sera pas possible d’interagir avec les boutons de la page d’accueil
du jeu par exemple.

D’ailleurs, tous éléments UI interactifs de Unity possèdent une section On Value Changed
qui regroupe les évènements invoqués lors de l’interaction avec ces derniers. Elle peut
regrouper l’appel de fonctions publiques issues d’un Script, l’activation/désactivation
d’un objet sur Unity, etc.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 33
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
1.3.1. CANVAS
Un canevas est l’objet dans lequel doivent se trouver tous les éléments UI ajoutés. En
d’autres mots, pour que ces éléments soient fonctionnels et visibles, ils doivent être
parentés à un canevas.

ASTUCES ! NOMBRE DE CANVAS ET D’EVENT SYSTEMS

Il est possible d’avoir plusieurs Canvas qui regroupe différents éléments UI. Par
exemple, un canevas regroupant les boutons Play, Options et Exit, un autre
regroupant des éléments UI régissant les paramètres audios, un autre, pour des
paramètres visuels, etc. Cependant, seulement un Event System est nécessaire
pour gérer tous les inputs UI.

Il est même conseillé de ne pas y toucher une fois qu’il apparait dans la hiérarchie
au risque d’affecter tous les UI !

Tel que mentionné dans l’aperçu général, un objet parenté à un canevas qui se trouve le
plus bas dans la hiérarchie apparaitra plus en avant-plan alors qu’un objet en haut de la
hiérarchie se trouvera proche de l’arrière-plan.

RENDER MODE
Le 1er composant nommé Canvas de l’objet Canvas contient une propriété, Render Mode,
qui médie le rendu du canevas.

Il y a d’abord l’option Screen Space—Overlay qui le place en avant de tout, ce qui lui
réserve un espace gigantesque dans la scène. S’il y a redimensionnement de l’écran de
jeu, il est possible de remarquer que le canevas change également de dimensions. Il est
en fait physiquement devant les objets 3D de la scène.

Il y a ensuite l’option Screen Space—Camera qui, une fois une caméra de la scène associée
au Render Camera, donne l’impression que les éléments UI sont collés à la caméra. Ainsi,
modifier la caméra (par exemple, la déplacer) modifierait également le canevas. Tout
comme l’Overlay, un redimensionnement de l’écran va également restructurer le
canevas.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 34
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Enfin, il y a l’option World Space qui considère le Canvas comme tout autre objet de la
Scene. C’est le seul mode de rendu qui permet le redimensionnement du canevas par la
composante Rect Transform sans lui attribuer des dimensions propres à la taille de
l’écran. Les éléments UI suivront donc un ordre d’affichage selon leur emplacement 3D
parmi les autres objets 3D. Ce choix est grandement recommandé si l’on désire un UI qui
fait partie de l’environnement virtuel. Il s’agit alors d’une interface diégétique.

CANVAS SCALER
Le composant Canvas Scaler permet de gérer la mise à l’échelle et la résolution en pixels
des éléments de l’interface usage, soit le canevas, face aux redimensionnements de
l’écran. Pour le mode Word Space de rendu, ce composant permet de gérer la quantité
de pixels des UI seulement.

La propriété qui nous intéresse le plus est le UI Scale Mode.

Par défaut, elle est à Constant Pixel Size. Ceci fait que les éléments de l’interface
maintiennent une taille constante en pixels, peu importe la taille du moniteur, selon un
Scale Factor qui peut être ajusté au besoin. Ainsi, si un jeu est conçu pour un moniteur à
1920 x 1080, mais que l’écran d’affichage est à 3840 x 2160, les UI seront difficilement
visibles. Il en a de même pour le contraire ; des UI conçus pour un grand écran, mais
affichés sur un petit écran, seront beaucoup trop grands. Ce mode est donc préférable
lorsqu’il n’y a rien qu’une résolution d’écran d’affichage. Sinon, il va falloir manuellement
manipuler le Scale Factor par du code, ce qui serait inutilement long pour rien.

En fait, il y a le mode Scale With Screen Size qui, comme son nom l’indique, fait subir une
mise à l’échelle automatique aux UI selon la taille de l’écran. Il utilise une résolution de
référence (par défaut, 800 x 600) comme point de départ pour le redimensionnement des
éléments UI. Cette Reference Resolution consiste normalement en la résolution pour
laquelle la présentation de l’interface est conçue. Selon la définition de l’écran où le jeu
sera joué, l’interface usager s’adaptera en fonction de la résolution de référence, si elle
est plus grande ou plus petite. C’est là où entre en jeu la propriété Screen Match Mode. Il
y a d’abord le mode Match Width or Height qui met à l’échelle le canevas tout en gardant
le même nombre de pixels sur un côté de la Reference Resolution, soit la largeur, la
hauteur ou un entre-deux choisi par la glissière. Il y a ensuite le mode Expand qui fait en
sorte que peu importe le redimensionnement de l’écran, la résolution ne sera jamais
inférieure à celle de référence. Inversement, le mode Shrink assure que le Canvas est soit
d’égale ou inférieure résolution à la Reference Resolution.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 35
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Finalement, le UI Scale Mode peut être en mode Constant Physical Size, mais ceci ne sera
pas abordé puisque c’est un concept un peu plus complexe que les 2 autres.

Tous les modes de mise à l’échelle ont la propriété Reference Pixels Per Unit en commun.
Une valeur élevée rend les UI de plus en plus pixellisés. Normalement, la valeur 100 de
base est suffisante.

1.3.2. COMPOSANT RECT TRANSFORM

Contrairement aux autres objets sur Unity, les éléments d’interface possèdent un
composant Transform qui diffère : le Rect Transform. En plus des propriétés de position,
de rotation et de mise à l’échelle, il contient d’autres propriétés de redimensionnement
(Width et Height), de pivot et d’ancrage (figure 22).

Figure 22 : Composant Rect Transform et ses propriétés

Effectivement, si l’outil Rect Tool est utilisé, un rectangle avec des sommets bleus
apparait dans la fenêtre Scene autour de l’objet sélectionné. Pour des objets 3D ou 2D
normaux, il permet de les redimensionner, repositionner et tourner, soient les propriétés
de base de Transform (position, rotation et mise à l’échelle). Il a donc la même fonction
que l’outil Transform pour ces objets. Par contre, pour des objets UI, le Rect Tool
affectera peu ou pas les propriétés Transform. En fait, si l’on redimensionnait le
rectangle, seulement le Width et le Height seraient affectés alors que le Scale
demeurerait constant. Dans le cas d’un texte, par exemple, redimensionner le rectangle
ne change aucunement la taille de la police, juste l’espace qu’il peut occuper.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 36
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Le cercle bleu au milieu du rectangle est le pivot. Il s’agit du point de référence utilisé
pour redimensionner, mettre à l’échelle et tourner l’objet. Il est possible de changer son
emplacement en maintenant l’appui sur le cercle dans la Scene. Sinon, il est également
possible d’appliquer manuellement ses coordonnées dans la section Pivot du Rect
Transform.

Les Anchors sont les petits triangles qui apparaissent sur le Canvas à la sélection d’un
objet UI. Leur position peut être déterminée par les propriétés Min et Max, qui médient
respectivement l’ancrage en bas à gauche et en haut à droite, ou directement sur la Scene
en les glissant à l’endroit désiré. Ils sont très utiles pour maintenir des éléments UI sur un
endroit spécifique de l’écran.

Par exemple, dans un jeu qui contient des cœurs pour tenir compte des vies du
personnage, les ancrages sont utiles pour délimiter l’emplacement sur le moniteur où ils
devront être, surtout si le jeu créé supporte diverses résolutions d’écrans.

Pour ce faire, en cliquant sur le carré en haut à gauche du Rect Transform, une nouvelle
fenêtre apparaitra (figure 23). Elle contient des emplacements prédéfinis d’ancrages.
Selon la position prédéfinie choisie, lors d’un changement de taille d’écran, l’objet UI
maintiendra une distance proportionnelle avec les ancrages.

Figure 23 : Anchors Presets qui permet de choisir parmi des dispositions d’ancrages, de
pivots et de positions prédéterminés

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 37
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
REMARQUE ! ACCÈS RAPIDE DES POSITIONS ET PIVOTS PAR LA FENÊTRE DES
ANCRAGES PRÉDÉFINIS

Il est à remarquer que, dans la fenêtre des Anchors Presets ci-dessus, il est
indiqué Shift: Also set pivot et Alt : Also set position. En effet, en appuyant sur
une de ces touches clavier, il est possible de simultanément changer
l’emplacement du pivot de l’objet ainsi que sa position au même endroit que les
ancrages prédéfinis.

Ainsi, si un emplacement en haut à gauche est choisi, cliquer tout seul déplacera
les 4 ancrages en haut à gauche du canevas. Cliquer en gardant appuyé Shift va,
en plus de bouger les ancrages, bouger le pivot de l’élément au coin en haut à
gauche du rectangle qui l’entoure. Cliquer en gardant Alt appuyé e va déplacer
l’objet en entier pour que son coin en haut à gauche superpose le coin en haut à
gauche du canevas. Bien sûr, il est possible d’appuyer les 2 touches en même
temps pour appliquer tous ces changements en même temps.

Cependant, ceci ne limitera pas nécessairement l’objet à un emplacement spécifique. En

fait, si, par exemple, les ancrages sont tous placés en haut à gauche, dans un écran avec
une grande hauteur, l’objet UI sera bel et bien en haut à gauche, mais dans un écran à
grande largeur, l’objet finira peut-être au milieu à gauche. Pour le garder dans un coin
spécifique sur l’appareil d’affichage, il faut préférablement le garder proche de ses
ancrages, parfois même l’entourer avec ceux-ci. Ainsi, il maintiendra toujours une
distance proportionnelle avec chaque ancrage et n’ira pas ailleurs que dans la région
délimitée par ses ancrages lors des redimensionnements de l’écran.

Voici les résultats finaux de l’emplacement des objets UI sur différents moniteurs selon
l’emplacement de leurs ancrages.

Il y a d’abord l’option de ne pas toucher les positions de base des ancrages et positionner
l’image, peu importe sur le canevas. Cependant, comme sur la figure 24 suivante, l’objet
ne garde pas sa position avec le changement de résolutions et peu même parfois finir par
sortir de l’écran.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 38
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 A B

Figure 24 : L’effet de changement de résolutions d’écran sur une image avec des ancrages
placés au milieu du Canvas. (A) Emplacement de l’image et de ses ancrages sur la Scene. (B)
Aperçu sur un écran à grande hauteur. (C) Aperçu sur un écran à grande largeur.

Si l’objet UI et ses ancrages sont positionnés selon les Anchors Presets, l’effet devient
meilleur. Le cœur (figure 25) demeure en tout temps sur la position définie dans la Scene,
peu importe les différentes tailles d’écran.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 39
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 A B

Figure 25 : Effets de changement de résolutions d’écran sur une image et ses ancrages sur la
position prédéfinie en haut à gauche. (A) Emplacement de l’image et de ses ancrages sur la
Scene. (B) Aperçu sur un écran à grande hauteur. (C) Aperçu sur un moniteur à grande largeur.

Cependant, si l’objet était positionné sur un emplacement autre que ceux définis dans
l’Anchors Presets et que ses ancrages avaient des positions prédéterminées, les résultats
suivants s’afficheraient (figure 26). Un désavantage de ceci, dépendamment des cas, est
que, selon la résolution de l’écran, l’objet peut bouger. Dans des cas extrêmes de largeur
ou de hauteur, l’objet peut même sortir de l’écran.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 40
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 A B

Figure 26 : Effets de changement de résolutions sur une image placée au hasard sur l’écran
avec ses ancrages sur le coin en haut à gauche. (A) Emplacement de l’image et de ses
ancrages sur la Scene. (B) Aperçu sur un écran à grande hauteur. (C) Aperçu sur un écran à
grande largeur.

Dans le cas où, encore une fois, nous aurions un objet UI positionné au hasard sur l’écran,
mais que, cette fois-ci, il est entouré par ses ancrages, l’objet maintiendra sa position,
peu importe la taille du moniteur. Cependant, les ancrages maintiennent une distance
proportionnelle avec les côtés du Canvas lors du redimensionnement de l’écran. Par
conséquent, l’objet UI tend à se déformer, tel que visible dans la figure 27A et B.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 41
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 A B

Figure 27 : Effets de changement de résolutions de l’écran sur une image entourée de ses
ancrages. (A) Emplacement de l’image et de ses ancrages sur la Scene. (B) Aperçu sur un écran
à grande hauteur. (C) Aperçu sur un écran à grande largeur.

En somme, le positionnement des éléments UI et leurs Anchors dépendent entièrement

de ce que le programmeur désire ainsi que des écrans sur lesquels il veut afficher ses jeux.

1.3.3. IMAGE UI ET PANEL

L’objet Image permet l’ajout d’une image non interactive sur l’interface usager. Un
exemple très commun serait une image de fond. Cet objet contient un composant au
même nom. De base, à son ajout, un carré blanc apparait sur la Scene. Si l’on désire
ajouter une image, il faut d’abord l’importer en tant que Sprite, soit une image graphique
ou avec textures. Il sera alors possible de l’ajouter à la propriété Source Image et il
apparaitra sur l’écran. Il est également possible d’ajouter une couleur simple ou un
matériel à la place d’une image avec les propriétés au même nom. Bien sûr, il est possible

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 42
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
de les appliquer sur un objet Image qui possède déjà un Source Image, mais les résultats
varient et ne sont pas toujours satisfaisants.

Un Panel est une Image. La seule différence est que, par défaut, il s’étend sur tout le
Canvas.

1.3.4. TEXTE
Dans les versions courantes de Unity, le composant utilisé pour ajouter du texte est le
Text Mesh Pro. Autrefois, il s’agissait tout simplement du Text (qui peut être trouvé dans
la section Legacy sous la section UI). L’importance de ce choix va surtout dépendre lors
du codage où il faut ajouter une ligne de plus (using TMPRo;).

Les propriétés du Text Mesh Pro sont faciles à comprendre et ressemblent beaucoup à
n’importe quel logiciel de texte. Ils comprennent une section Text Input où l’on écrit ce
que l’on veut afficher. Comme sur Word, il est possible de séparer les styles de texte : un
titre, une référence, une citation, un en-tête, etc. Le Text Style sert justement à cela.
Comme n’importe quel média importable, il est possible d’importer des polices de
caractères sur Unity. Une fois importées, elles peuvent être assignées au texte par la
propriété Font Asset. Il y a ensuite les Font Style, Font Size et Alignment qui sont assez
explicites en soi. Il faut également souligner la fonction Auto Size qui ajuste la taille de
police automatiquement de façon à remplir l’espace qui a été alloué au texte, soit le
rectangle du Rect Tool. Enfin, il est possible de changer la couleur du texte par le Vertex
Color.

1.3.5. TOGGLE
Un Toggle est une case à cocher qui médie une variable de type booléen (vrai ou faux).
Trois objets enfants sont ajoutés à la hiérarchie à son ajout : un fond d’écran de type
Image, un crochet de type Image et un texte de type Text.

Sa 1re propriété Interactable (voir figure 28) permet son activation lors de l’exécution du
jeu. Si elle n’est pas cochée, il ne sera pas possible d’interagir avec le Toggle une fois le
jeu démarré.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 43
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 Figure 28 : Composant Toggle et ses propriétés

La propriété Transition médie l’apparence de l’interaction avec le Toggle. Plusieurs choix

sont offerts quant aux types de visualisations de l’interaction. Par défaut, elle est à Color
Tint, ce qui permet d’assigner une couleur à chaque état que ce trouve le Toggle. Le Target
Graphic est l’objet qui sera affecté par le changement de couleur, soit le fond, le crochet
ou le texte. Il est ensuite possible d’assigner des couleurs pour quand l’usager survole le
Toggle (Highlighted Color), l’appui (Pressed Color), le sélectionne tout simplement
(Selected Color), que ce soit pour l’activer ou non, et le désactive (Disabled Color). Il est
également possible d’implémenter une durée à la transition entre les différentes
couleurs par la propriété Fade Duration. Un 2e choix offert est le Sprite Swap qui, comme
son nom l’indique, permet de changer l’apparence d’une image pour une autre. Ses
propriétés sont semblables au Color Tint, mais il ne possède pas de Fade Duration. Le
dernier choix est l’Animation. Les propriétés sont également semblables aux 2 autres.
Cependant, il faut concevoir des animations par nous-mêmes avec des déclencheurs
(Triggers). Ce type d’animation ne sera pas abordé davantage dans ce document.

La propriété Is On permet de suivre l’état du Toggle lors de l’exécution. Toggle Transition

permet de déterminer si le changement de choix s’effectue instantanément (None) ou de

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 44
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
façon graduelle (Fade). Graphic permet de choisir l’apparence du crochet en changeant
son image directement sans aller le faire dans l’objet enfant.

Puisqu’il s’agit d’un élément interactif, il contient une section On Value Changed de type
booléen.

1.3.6. BUTTON
Un bouton sert à démarrer ou à confirmer des actions. À son ajout, un objet enfant de
type Text Mesh Pro va s’ajouter à la hiérarchie. De bons exemples communs sont les
boutons pour annuler, jouer, sortir, etc.

Ses propriétés (figure 29) sont quasi identiques au Toggle. Une différence est que leur On
Value Changed est appelé On Click, celui-ci gérant les évènements déclenchés par l’appui
et relâche de la souris ou du clavier.

Figure 29 : Composant Button et ses propriétés

1.3.7. SLIDER
Le Slider est une glissière qui permet de choisir une valeur numérique de type float sur un
intervalle déterminé, contrairement au Scrollbar qui permet plutôt de bouger une page.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 45
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Avec lui s’ajoutent plusieurs objets enfants de type Image : un fond, un contenu de
remplissage et un poignet.

En plus des propriétés communes aux 2 autres (figure 30), il contient des attributs qui lui
sont propres. Le Fill et le Handle Rect sont les graphiques utilisés pour représenter
respectivement le contenu et le poignet de la glissière. C’est un parallèle au Graphic du
Toggle. Direction permet de choisir le sens par lequel les valeurs numériques vont croitre.
D’ailleurs, les propriétés Min et Max Value permettent de choisir l’intervalle dans lequel
croitront ces numéros. Puisque la glissière permet de médier les valeurs de type float, il
est possible de choisir si celles-ci sont des nombres entiers ou non par Whole Numbers.
Enfin, la propriété Value représente la valeur actuelle sur laquelle se trouve la glissière.
Évidemment, son On Value Changed est de type float.

Figure 30 : Composant Slider et ses propriétés

1.3.8. DROPDOWN
Le Dropdown est un menu défilant qui regroupe plusieurs options. Fermé, il affiche le
choix actuel et ouvert, il affiche la liste des autres choix qui peuvent être affichés. À son

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 46
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ajout, les objets enfants suivants apparaissent : un Text Mesh Pro, une Image, un objet
transparent qui regroupe la liste des options affichables.

Comme les autres éléments UI interactifs, il contient des propriétés communes et

d’autres qui lui sont propres (figure 31). La propriété Template contient l’objet
transparent qui consiste en un modèle de liste d’options. Les Caption Text et Image
permettent de choisir du texte ou une image qui représente l’option choisie alors que
l’Item Text et Image permettent de choisir le texte ou l’image qui représentent tous les
choix.

Figure 31 : Composant Dropdown et ses propriétés

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 47
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Une grande section Options se trouve dans la composante Dropdown. C’est dans cette
propriété que les choix du menu défilant seront ajoutés ou retirés par les . Celui qui
sera affiché par défaut peut être défini par la propriété Value. Bien que les choix ne soient
pas nécessairement des valeurs numériques, le Value représente l’ordre dans lequel se
trouve le choix dans la liste d’options. Ainsi, une Value de 0 affichera l’option A de la liste,
une Value de 1, l’option B, ainsi de suite. L’Alpha Fade Speed est la vitesse à laquelle le
menu défilant disparait et apparait après la sélection ou désélection.

Le Dropdown a également une propriété On Value Changed, mais cette fois-ci, elle est de
type interger, soit des valeurs entières.

1.4. ANIMATION

Sur Unity, le système d’animations est appelé Mecanim. Il est composé d’une structure
relativement complexe qui permet la transition entre différents états d’animation.

Pour qu’une animation ait lieu, il faut que plusieurs facteurs soient présents. Les
animations sont soit créées sur Unity ou importées d’ailleurs, de Blender par exemple.
Elles sont par la suite regroupées en Animator Controller qui organise les différentes
Animation Clips (les animations séparées) et gère lesquelles doivent jouer, arrêter,
changer pour un autre, etc. Lorsque des animations sont ajoutées à un objet, un
contrôleur est d’ailleurs automatiquement créé dans les Assets sous forme de fichier
.controller qui se lie à la propriété Controller du composant Animator de l’objet en
question.

Ce type d’animation est souvent utilisé pour contrôler un personnage dans un jeu. Il
permet la transition facile des différents états, que ce soit de la course à la marche, au
saut, à la mort, etc. Il est possible d’ouvrir la fenêtre Animator, en double cliquant sur
l’Animator Controller dans le fichier Assets ou en allant dans l’onglet Window—
Animation—Animator, où l’on peut créer davantage des liens entre les animations et des
déclencheurs (Triggers). Cependant, ces animations complexes ne seront pas abordées
davantage dans ce manuel.

1.4.1. TIMELINE
Mis à part les Animation Clips, il y a les Playable ou Timeline Assets qui sont des types
d’animations pour des utilités singulières. Ce sont des animations dites prédéterminées
puisqu’elles ne sont pas nécessairement activées par inputs claviers par exemple.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 48
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Contrairement aux Animation Clips, les Playable Assets offrent plus de gammes de
manœuvres. Ils permettent non seulement la manipulation d’objets pour créer des
séquences cinématiques, mais permettent aussi l’ajout de séquences audio, d’effets
spéciaux par des particules et la manipulation de plusieurs objets à la fois pour créer toute
une animation à eux seuls.

Puisqu’il s’agit toujours d’une animation, l’objet contenant et subissant l’animation aura
toujours une composante Animator, même s’il ne s’agit pas d’Animation Clips et qu’il n’y
ait pas de médias de type .controller qui sont sauvegardés. En fait, lors création d’un
Timeline, un média de type .playable sera sauvegardé dans les Assets et l’objet aura une
composante Playable Director de plus.

CRÉATION D’UN TIMELINE ASSET

Pour créer un Timeline Asset, il faut d’abord ouvrir la fenêtre Timeline. Pour ce
faire, il faut aller sous l’onglet Window et trouver Timeline sous la section
Sequencing. Il est conseillé de déplacer cette fenêtre en bas avec les fenêtres
Project et Console pour obtenir un plus grand espace de travail.

Normalement, rien n’apparait sur la fenêtre. Il faut sélectionner un objet avec

lequel on désire lier un Timeline et appuyer sur le bouton Create pour commencer.
Il peut s’agir de l’objet qui subit l’animation ou un autre objet à part. Un média
de type .playable sera alors créé, une composante Playable Director s’affichera
dans l’Inspector de l’objet et la ligne du temps apparaitra dans la fenêtre Timeline.

Assurez-vous de bien verrouiller cette dernière à l’aide de l’icône de serrure (voir

figure 32). Ceci empêchera de changer d’objet sur lequel créer l’animation en
pleine modification. Par l’icône d’engrenage juste en dessous, il faut choisir les
paramètres Seconds pour que le Timeline affiche le temps en secondes et non en
Frames. La Duration Mode devrait être préférablement à Fixed Length pour
qu’une animation ne soit pas restreinte rien qu’à un Clip, mais plutôt à un temps
spécifique. Un autre avantage à changer ces paramètres est l’apparition d’un
lecteur bleu (visible sur la figure 32) qui permet de choisir la durée totale du
Timeline Asset et des Clips.

La fenêtre Timeline est divisée en 2 parties (figure 32) : la partie à droite contient
les Tracks, ou pistes, et la partie à gauche contient les Clips. Chaque Track est lié

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 49
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
à un Clip. Le Track contient l’information du média ou de l’objet auquel le Clip est
associé. Les Clips sont des enfants du Timeline Asset. Ils contiennent les divers
enregistrements faits pour concevoir une animation.

Figure 32 : Exemple d’affichage de la fenêtre Timeline avec des pistes à gauche et

des Clips à droite

Plusieurs types de pistes peuvent être créées à l’aide du menu défilant . Il y a

d’abord l’Activation Track qui, comme son nom l’indique, active un objet autre
que celui avec lequel le Playable Asset actuel est lié. Un exemple d’utilisation de
cette piste serait l’activation d’animations liées à un autre objet après un certain
délai. Il y a ensuite l’Animation Track qui permet la création d’animations de
l’objet qui est lié au Track. Si l’on désire ajouter des sons à cela, il est possible
d’ajouter un Audio Track. Le Control Track est utile pour activer un système de
particules à partir du Timeline. Le Playable Track ne sera pas abordé dans ce
manuel.

Animation Track

Pour créer une animation, on peut commencer soit par le menu défilant soit
en glissant dans la section des pistes l’objet que l’on désire animer et choisir
Animation Track.

Ensuite, il faut cliquer sur le bouton d’enregistrement , ce qui fera changer la

couleur de la ligne du temps en rouge. En ayant le signet blanc, soit la taille de
lecture, sur le temps de début de l’animation, il faut aller sur la propriété de
l’objet à modifier dans son Inspector. Si l’on désire bouger l’objet, par exemple,

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 50
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ce sera la propriété Position, pour un changement de couleur, ce sera la propriété
Materials, etc.

Il faut sauvegarder l’état initial de l’objet en premier. Pour ce faire, il faut cliquer
sur le bouton droit de la souris sur la propriété à modifier dans l’ Inspector et
cliquer sur Add Key. Ceci ajoutera un point clé sur la ligne du temps dans la même
place que le signet blanc et enregistrera l’état actuel de la propriété choisie. Il
faut ensuite bouger la taille de lecture au temps de la 1 re modification. Il est
possible de directement modifier l’objet et les changements s’enregistreront
automatiquement à ce temps choisi. Sinon, il faut encore une fois aller par Add
Key.

En cliquant sur le bouton Play the Timeline de la section des pistes, il est
possible de voir un aperçu de l’animation créée. Une foi s satisfait du résultat, il
faut arrêter l’enregistrement en recliquant sur le bouton . Sur la ligne du
temps, en cliquant sur le bouton droit de la souris — Convert Clip to Track, il est
possible de faire les ajustements fins sur l’animation.

Audio Track

Pour un Audio Track, il faut le lier à un média de type Audio Clip. Contrairement
à l’Animation Track où l’objet lié se trouve dans l’en-tête, l’audio au complet
apparaitra seulement sous forme de Clip dans la section de la ligne du temps.
Rien ne se trouvera lié dans la section des pistes.

Control Track

Pour les effets spéciaux de type Particle System, tout comme l’audio, il faut le
glisser dans la ligne du temps associé à un Control Track.

Ajustements fins

Des exemples d’ajustements simples seraient de déplacer le signet bleu pour

changer le temps de fin de l’animation au complet, d’allonger ou de rétréc ir un
Clip en rallongeant ou réduisant ses bordures, etc. Un Clip rogné aura une petite
flèche sur sa bordure modifiée pour indiquer qu’il y a du contenu caché alors
qu’un Clip rallongé vers la fin aura une section intitulée Hold.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 51
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Ce type de modification n’affectera toutefois pas la vitesse de l’animation ou de
l’audio. Pour changer la vitesse, il faut maintenir l’appui sur la touche Shift
lorsqu’on modifie les bordures du Clip.

Il est possible de voir des paramètres s’afficher sur l’Inspector à la sélection d’un
Clip. Ils comprennent entre autres les temps de début et de fin du Clip, sa durée
et d’autres paramètres selon le type de Track. Il faut au moins souligner les
paramètres d’Animation Extrapolation. Ils gèrent la façon dont l’espace vide
avant ou après l’animation est traité. À None, l’objet subissant l’animation prend
la forme telle quelle sur la Scene. Par défaut, ces paramètres sont à Hold, ce qui
signifie que l’objet maintiendra l’état précédent. Le Loop fera répéter l’animation
au complet, de début à la fin. Le Ping-Pong, contrairement au Loop, rejouera
l’animation, mais de façon inverse. Ainsi, si une animation fait changer un objet
d’une couleur blanche à une couleur rouge, à sa fin, l’animation inverse fera
changer l’objet du rouge au blanc. Le Loop et le Hold sont également présents
dans la composante Playable Director sous la propriété Wrap Mode. Le dernier
paramètre est Continue, qui fait subir au Clip la même Animation Extrapolation
que le Wrap Mode de l’objet qui contient le Timeline Asset.

Mis à part le Wrap Mode, il ne faut pas oublier de choisir avec la propriété Play
On Awake si l’animation est supposée commencer à l’exécution du jeu ou non.

ASTUCE ! CRÉER PLUSIEURS TIMELINE ASSETS À PARTIR DU MÊME OBJET

Lorsqu’on sélectionne l’objet lié à un Timeline, la fenêtre Timeline ne contiendra
qu’un Playable Asset à la fois et il ne sera pas possible de créer un autre à
nouveau.
Pour ravoir la page avec le bouton Create, ce qui permettra de créer un nouveau
fichier de type .playable, il faut sélectionner l’objet et aller dans sa composante
Playable Director. Dans sa propriété Playable, il est possible de remarquer qu’elle
contient le 1 er fichier .playable créé. En sélectionnant None à sa place, la fenêtre
Timeline affichera encore une fois l’énoncé de Create.
Cette astuce est très utile pour, par exemple, changer de Timeline Asset par du
code lors de collisions ou d’autres évènements dans le jeu.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 52
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
2. APPLICATION D’UNE CINÉMATIQUE INVERSE À UN AVATAR DE TIGE
DE PRÉHENSION

Le modèle 3D de la tige a été conçu au laboratoire LiBRTe. Tout le contenu est sous
licence CC0:

CC BY-NC-ND : Cette licence permet aux utilisateurs de copier et de distribuer le

matériel sur n'importe quel support ou format, sous une forme non modifiée
uniquement, à des fins non commerciales et à condition que le créateur soit cité.

Ce modèle 3D de la tige détaillé dans le manuel technique de Blender [14] a été importé
sur Unity. Cependant, il est à remarquer que, sur la hiérarchie où il a été placé,
l’exosquelette définit sur Blender n’apparaitra pas sur Unity, bien que les noms donnés
aux Bones soient affichés sous un groupe Armature tout comme dans Blender.

Unity vient avec plusieurs extensions qui peuvent être téléchargées. C’est le cas de
l’Animation Rigging qui contient quelques outils d’animation de Unity, dont un qui
permettra l’affichage de l’armature. Il est envisageable de l’ajouter par le Package
Manager et en le cherchant sur la barre de recherche. Un nouvel onglet s’affichera à la
suite de l’installation en haut de l’écran. En y cliquant dessus et en allant sur Bone
Renderer Setup, il sera possible de visualiser les os de l’exosquelette.

Au modèle importé, un Rig Builder a été appliqué (onglet Animation Rigging—Rig Setup)
et un objet nommé Rig sera ajouté dans la hiérarchie. Il permet d’appliquer différentes
contraintes d’animation. Pour ce projet spécifique, un composant Two Bone IK Constraint
a été ajouté à un objet enfant de l’objet Rig pour lui conférer une cinématique inverse.
Lorsque le jeu est démarré, en bougeant le Target, il est possible de remarquer que la tige
garde une cinématique inverse lorsqu’elle bouge et qu’elle se plie selon l’emplacement
du Hint.

APPLICATION D’UN TWO BONE IK CONSTRAINT

Pour appliquer la cinématique inverse, il faut d’abord ajouter un objet vide, nommé IK
dans ce projet, et parenté à l’objet Rig. Par la suite, il faut lui ajouter le composant Two

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 53
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Bone IK Constraint qui se trouve sous la section Animation Rigging du Add Component
dans l’Inspector. Par conséquent, un composant (figure 34) avec des espaces vides
apparaitra dans l’Inspector.

Weight correspond à l’effet de la contrainte sur l’objet. Pour ce composant, s’il est à 1, la
tige suivra de près la cible (ou Target) alors que si le Weight est proche de 0, la tige restera
à sa position de base et ne suivra pas ou peu la cible.

Avant de mentionner quel os va dans quelle section, il faut tenir compte du fait que la
position des os correspond à la position de sa base et non de son bout. Le Two Bone IK
Constraint est comme un mouvement de coude ; 2 segments liés peuvent se
plier/déplier autour d’une jointure. La section où il est désiré d’ajouter une cinématique
est indiquée ci-dessous en vert :

Figure 33 : Avatar d’une tige de préhension avec ses os (bleus) ainsi que la cinématique
inverse appliquée (vert)

Le Root est le point de la cinématique qui demeurera fixe. Il ne peut pas être l’os de la
base de la tige. Sinon, la moitié supérieure de l’avatar ne bougera pas. Si le Root était la
base, cette dernière commencerait à bouger également dans tous les axes alors qu’elle
doit rester immobile sur 2 axes. Le Root est alors l’os juste après celui de la base, l’Arm1.
Le Mid est la position de l’os où le pliage se fait, donc à la position de l’Arm2. Le Tip est

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 54
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
l’os qui suivra de près la cible. Puisque cette contrainte ne permet que 2 segments dans
la cinématique, il ne peut s’agir que de l’Arm3.

Le Target comme le nom l’indique est la cible que suivra le Tip. Le Hint, par contre, est
plus particulier. Il indique le sens vers lequel va se plier la tige, ce qui permet d’éviter le
phénomène de « coude inverse ».

Finalement, les Settings sont des spécificités du Weight, tels que les Target
Rotation/Position Weight qui appliquent ou non la position et la rotation de la cible sur le
Tip.

Pour ce projet, le composant Two Bone IK Constraint a été rempli de la façon suivante :

Figure 34 : Réglages utilisés du composant Two Bone IK Constraint sur l’avatar de la tige de
préhension

Il sera nécessaire d’avoir 2 autres objets vides enfants de l’objet contenant le Two Bone
IK Constraint pour faire office de Target et de Hint. Cependant, on peut laisser Unity les
créer et remplir tous les espaces automatiquement en choisissant l’os correspondant au
Tip et l’option Auto Setup From Tip Transform à partir des 3 petits points en haut à gauche
du composant. Bien sûr, il faut toutefois voir si les bons éléments ont été associés aux
espaces correspondantes.

Il est également possible de rendre visibles le Target et le Hint. Pour ce faire, en bas de la
fenêtre Scene, une fenêtre contextuelle nommée Animation Rigging se trouvera. En

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 55
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
sélectionnant le Target ou le Hint, il faut cliquer sur le petit et choisir la taille et l’objet
qui servira de marqueur pour représenter ces objets normalement transparents.

3. VISUAL STUDIO ET CODES EN C#

Le but du C# est d’offrir à Unity un environnement de programmation qui permet

d’interagir avec les effets spéciaux, les animations, les objets, la physique, etc., à l’aide
du core (ou noyau). Ce noyau génère des messages qui correspondent à des évènements
provoqués implicitement par Unity selon l’état du jeu ou explicitement par les actions de
l’utilisateur. Certains codes sont même bouclés sur eux-mêmes et se répètent tout au
long de l’exécution du jeu. Ceci est le cas de la fonction Update() par exemple.

Environ moins de 90 mots sont réservés au C# et les différents éléments peuvent être
regroupés dans des class ou name space.

abstract as base bool break by byte case catch char checked class const continue
decimal default delegate do double descending explicit event extern else enum
false finally fixed float for foreach from goto group if implicit in int interface
internal into is lock long new null namespace object operator out override orderby
params private protected public readonly ref return switch struct sbyte sealed
short sizeof stackalloc static string select this throw true try typeof uint ulong
unchecked unsafe ushort using var virtual volatile void while where yield

Normalement, un Script regroupe ses codes dans une class. Celle-ci est définie par des
accolades, soient la première et la dernière du fichier. Bien sûr, il est également possible
de voir d’autres blocs de codes encadrés par des accolades à l’intérieur de la class elle-
même, qui est un gros bloc en soi. Il peut s’agir de fonctions ou de structures sélectives.
Les lignes de codes sont d’ailleurs déterminées et terminées par un point-virgule.

Mis à part les accolades, il y a également des lignes ou des paragraphes entourés de 2
barres obliques (//…//) ou d’une barre oblique et un astérisque (/*…*/). Ceux-ci
délimitent des commentaires qui ne seront pas compilés lors de l’exécution, mais qui
servent souvent à expliquer certains codes par le programmeur ou à tenir trace des
démarches antérieures.

Dans cette section, certaines variables, des opérateurs et quelques fonctions seront
élaborés.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 56
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
3.1. VARIABLES

Les variables sont présentes dans tout langage de programmation. En C#, elles
possèdent chacune un espace mémoire spécifique et il faut les définir avant le code
exécutable de la façon suivante : description du type de variable — nom donné à la
variable spécifique — valeur donnée à la variable s’il y a lieu.

Une variable avec affectation est une variable à laquelle on attribue une valeur au
moment de sa définition. Ces valeur et variable existent dans leur portée de variables,
c’est-à-dire le bloc dans lequel elles ont été définies. Ainsi, si elles ont été créées dans le
bloc de class, elles seront accessibles par toutes les fonctions au niveau de la class. Ce
sont les propriétés. Au contraire, si elles ont été créées rien qu’à l’intérieur d’une seule
fonction, elles seront accessibles rien qu’à l’intérieur de celle-ci.

ATTENTION !

Certains programmeurs aiment réutiliser des noms de variables dans différentes

fonctions puisqu’il ne s’agit pas techniquement de la même variable. Effectivement,
puisqu’elles ont été définies dans des blocs différents, elles ne sont pas visibles aux autres
fonctions et peuvent donc avoir le même nom, mais une valeur différente (ou non).

Dans le cas où le nom d’une propriété, c’est-à-dire une variable identifiée dans la class,
serait réutilisé pour définir une variable dans une fonction, cette dernière va remplacer la
propriété pour le bloc dans lequel elle a été établie. La propriété va cependant toujours
être utilisée ailleurs dans le code.

Lors de la définition de variable, il est également possible de lui attribuer une visibilité.
En fait, qu’on le mentionne explicitement ou non, une variable est par défaut private et
n’est visible qu’à l’intérieur de sa fonction ou sa class. Si une variable est public, elle
devient visible et accessible de l’extérieur de la class, la rendant visible dans la
composante Script dans l’Inspector dans Unity. Il est ainsi possible de modifier
rapidement sa valeur à partir de Unity, sans la changer dans le code.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 57
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ATTENTION !

Si une variable public est affectée à une valeur dans Visual Studio, modifier sa valeur sur
Unity ne changera pas la valeur dans le code, bien que celle attribuée sur Unity sera
exécutée. Il faut donc faire attention dans le cas où on la remettrait private sans changer
la valeur dans Visual Studio.

REMARQUE ! REDONDANCE À DÉFINIR UNE VARIABLE COMME ÉTANT PRIVATE

Que l’on définisse une variable comme étant private ou non, une variable définie
sans état de visibilité est par défaut une variable privée. Il est donc inutile
d’alourdir les codes avec private dans le cas des variables privées.

3.1.1. VARIABLES SIMPLES

Il existe 5 variables simples qui constituent les variables de base en C#.

INTERGER
La 1re est le interger (int). Il est fort utile pour sauvegarder des valeurs entières, soit des
nombres sans décimal. Il permet de sauvegarder une valeur qui peut aller jusqu’à ± 2 147
483 647 dans un espace mémoire de 4 octets. Pour le définir, il faut d’abord choisir s’il
s’agit d’une variable public ou private, ensuite définir son type, soit int, et lui donner un
nom. Si l’on veut lui affecter une valeur, il faut taper le signe égal et mettre sa valeur
entière par après. Sinon, il faut tout simplement terminer la ligne de codes par un point-
virgule.

public int nbAleatoire = 3; // un int nommé Nb Aleatoire de valeur 3 qui peut

être modifiée sur Unity

private int nbPair = 2; // un int nommé Nb Pair de valeur 2 fixe à sa définition

int i = 2, j = 3, k = 4; // un int i de valeur 2 fixe à sa définition, int j de

valeur 3 fixe à sa définition et int k de valeur 4 fixe à sa définition

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 58
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
public int nbImpair; // un int Nb Impair de valeur indéterminée qui peut être
modifiée sur Unity

REMARQUE ! NOMINATION DES VARIABLES ET TOUT CE QUI EST SCRIPT

Que ce soit les variables dans Visual Studio ou le nom du fichier Script sur Unity,
il faut toujours suivre une nomination spécifique.

Il faut d’abord éviter les accents et tout caractère spécial dans les noms. Puis, si
le nom est composé de plusieurs mots, on évite les espaces, puisque cela
mélangerait le compilateur et causerait des erreurs dans le code. À la place, il
faut commence le nom avec une lettre minuscule et, si le nom est composé, au
lieu de mettre des espaces, à chaque nouveau mot, ce dernier débute avec une
majuscule. Commencer le nom avec une minuscule peut être facultatif, mais
parfois, cela peut causer des erreurs. Il vaut donc mieux de commencer avec des
minuscules au lieu d’attendre le jour que Visual Studio décide de ne pas être
capable de les compiler.

Il est important de suivre ces règles autant pour les noms de variables dans Visual
Studio que sur le nom du Script sur Unity. En fait, ce même nom sera utilisé pour
nommer la class dans Visual Studio qui englobe tous les codes. Une erreur dans
la class rend tous les codes non fonctionnels !

ATTENTION !

Dans le cas où l’on déciderait de modifier le nom du fichier .cs sur Unity, tout comme les
valeurs publics qui ne changent pas sur Visual Studio une fois modifées sur Unity, le nom
de la class ne changera pas. Il va falloir le changer manuellement et bien s’assurer de
l’orthographe. Sinon, des erreurs indiquant le manque de Script à tel nom ou la
discordance entre les noms du fichier .cs et de la class apparaitront. Ainsi, les codes ne
seront plus exécutables.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 59
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ASTUCE ! DÉFINIR PLUSIEURS VARIABLES DE MÊME TYPE À LA FOIS

Il est possible de créer plusieurs variables de même type en même temps comme
indiqué dans le 3 e exemple en haut. Pour ce faire, après le type de variable, il faut
définir la 1 re variable comme d’habitude, mais terminer la définition avec une
virgule. Puis, il sera possible de définir les prochaines, sur la même ligne ou non,
de la même façon que la 1 re en sautant les 2 premières étapes (visibilité et type
de variable). Ainsi, la ligne devrait ressembler à quelque chose comme suit : état
de visibilité — type de variable — nom de la 1 re variable — = valeur affectée
(facultative) —, — nom de la 2 e variable — = valeur affectée (facultative) —, —
[…] — nom de la n e variable — = valeur affectée (facultative) — ;

FLOAT
Une autre variable d’utilité forte est le float. Contrairement au int, il permet la sauvegarde
de valeurs réelles, c’est-à-dire des nombres décimaux. Il permet de définir une valeur
pouvant atteindre jusqu’à ± 3.402823 * 1038 dans 4 octets. C’est avec cette variable, entre
autres, que Unity fait les calculs internes. En fait, une opération avec des int ne donne pas
la même valeur que des opérations avec float (voir section 3.2.1.). Les floats permettent
une plus grande précision.

Pour les définir, tout comme int, il faut leur attribuer un état de visibilité (public ou
private), définir le type float, les donner un nom et une valeur si désirée. Une grande
différence, comparée aux int, est ce qui vient après cette valeur. Pour un float, que la
valeur soit un nombre réel ou entier, il faut toujours terminer la valeur par un f ou F avant
de terminer la ligne par un point-virgule. Un float sans f donnera des erreurs tout comme
un int avec des nombres décimaux.

public float a = 3.56f; // un float nommé A de valeur 3.56 qui peut être modifiée
sur Unity

private float b = 1.4F; // un float nommé B de valeur 1.4 fixe à sa définition

float hP = 100f, defense = 55.5f, attaque = 20.0f; // des floats H P de valeur

100.0 fixe à sa définition, Defense de valeur 55.5 fixe à sa définition et Attaque
de valeur 20.0 fixe à sa définition

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 60
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
public float m; // un float M de valeur indéterminée qui peut être modifiée sur
Unity

ATTENTION !

Il faut faire attention à ce qui sépare les nombres entiers des nombres décimaux dans la
valeur affectée à la variable float. Il faut toujours mettre un point ! Une virgule causera
des erreurs dans la compilation lors de l’exécution.

DOUBLE
Le double est quasi identique au float. Il est en fait le double d’un float puisqu’il contient
2 fois plus d’espace mémoire pour pouvoir sauvegarder de plus grandes valeurs (±
1.79769… * 10308). Son utilité est toutefois médiocre puisqu’il est très rarement
nécessaire d’atteindre de telles valeurs. Pour le définir, il faut déterminer sa visibilité, son
type double, son nom et sa valeur réelle avant de terminer avec un point-virgule.
Contrairement au float, il ne nécessite pas de f après la valeur.

double bulle = 1; // un double nommé Bulle de valeur 1 fixe à sa définition

public double depart, final; // des doubles nommés Depart et Final de valeur
indéterminée qui peuvent être modifiée sur Unity

ATTENTION !

Pour des valeurs aussi petites comme ci-dessus, à moins que ces variables aillent subir
des opérations majeures qui les feront atteindre des valeurs immenses, utiliser une
variable double viendrait à occuper une grande espace mémoire pour rien et ainsi alourdir
les fichiers de codes. Il serait donc préférable de choisir le float dans ces cas-ci.

STRING
Contrairement aux variables précédentes de type numérique, les 2 prochaines variables
seront de types caractères.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 61
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Le string est celui entre ces 2 qui est le plus utilisé. Il permet la sauvegarde de chaines de
caractères. Pour le définir, tout comme les autres, mis à part la visibilité, le type et le nom,
ce qui vient après le signe égal n’est pas nécessairement un chiffre. La valeur en
caractères commence et termine par des guillemets ("…") et les caractères en soi peuvent
varier à des chiffres, des mots, des caractères spéciaux, etc. Contrairement aux noms de
variables, les règles de nomination n’affectent pas tout ce qui est à l’intérieur des
guillemets. Il est donc possible de mettre des accents sur les lettres, des espaces entre
les mots, des signes d’opérations, etc. C’est à cause de cette grande variabilité que
l’espace mémoire d’un string peut varier selon les cas.

string nom = "Jérôme"; // un string nommé Nom de valeur Jérôme fixe à sa définition

public string message = "Il fait beau aujourd’hui!!1"; // un string nommé Message
de valeur Il fait beau aujourd’hui!!1 modifiable sur Unity

string enonce; // un string nommé Enonce de valeur indéterminée fixe à sa

définition; elle pourra être changé plus tard dans le code lors de l’exécution

CHARACTER
L’autre variable de type caractère est le character ou char. Semblablement au string, sa
valeur est définie entre des apostrophes (‘…’). Cependant, son utilité est très faible
puisqu’il permet la sauvegarde d’un seul caractère. Il possède un espace mémoire de 2
octets pour permettre les accents.

public char lettre = ‘c’ ; //un char nommé Lettre de valeur c modifiable sur Unity

private char chiffre = ‘3′ ; //un char nommé Chiffre de valeur 3 fixe à sa
définition

ATTENTION !

Tout comme le cas du double, le char n’est pas économe en matière d’espace mémoire.
Il est préférable d’utiliser un string à la place.

BOOLEAN
La dernière variable simple à mentionner est le boolean ou bool. Il peut n’avoir que 2
valeurs, true ou false, et ne nécessite donc qu’un octet d’espace mémoire. Pour le définir,

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 62
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
on suit la même manœuvre que les autres variables : visibilité, type bool, nom de la
variable et = true; ou false;. Son utilité est moyenne, car il est fort utilisé dans des
structures sélectives (section 3.3.). Cependant, celles-ci ne sont exécutées que lorsque
certaines conditions sont remplies, ce qui n’est pas le cas en tout temps.

public bool etat = false; // un bool nommé Etat de valeur false modifiable sur
Unity

bool run = true; // un bool nommé Run de valeur true fixe à sa définition

3.1.2. TYPES DE VARIABLES RÉFÉRANT À UNITY

Il est également possible de définir des variables qui font référence à des objets ou
composants de Unity. Contrairement aux variables simples, il n’y a pas de valeur à
affecter à ces variables. Cependant, selon leur état de visibilité, il va falloir les définir
davantage dans la fonction Start(). En voici quelques exemples :

GAMEOBJECT
GameObject est un type de variable qui fait référence à un objet quelconque sur la
hiérarchie de Unity. Il faut le définir comme variable de la façon suivante : état de
visibilité — type de variable GameObject — nom de la variable;. Un état de visibilité public
affichera dans l’Inspector la variable, comme toute autre variable, et il sera possible d’y
glisser un objet de la hiérarchie. Un GameObject privé fait normalement référence à
l’objet auquel est lié le Script. Dans ce cas, dans la fonction Start(), il faut davantage
définir cet objet. Pour ce faire, il faut taper : nom de la variable donné = gameObject;.
Contrairement au type de variable GameObject, cette épellation gameObject fait
référence à l’objet auquel le Script est lié.

public GameObject objPublic;

//

private GameObject objPrivee;

void Start()

objPrivee = gameObject;

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 63
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
TRANSFORM
Il est également possible de créer des variables qui font référence à des composants de
l’objet. Le type Transform par exemple fait référence au composant Transform. Il peut
être défini de la même façon qu’une variable de type GameObject. Cependant, dans la
fonction Start(), il faut définir davantage non seulement l’objet lié au Script, mais aussi le
composant Transform de cet objet. Pour aller chercher le composant de l’objet en codes,
il faut mentionner l’objet en question en premier et spécifier le composant après un
point : nom de la variable donné = [Link];.

ASTUCE ! LE POINT
Le point permet d’afficher les fonctions liées au mot qui le précède. Ces fonctions
incluent non seulement des actions (ex. Translate, Play, etc.), mais aussi les
composantes et les propriétés d’un objet.

public Transform transfoPub;

//

private Transform transfoPriv;

void Start()

transfoPriv = [Link];

Mis à part la définition, transform peut être utilisé ailleurs dans le code pour avoir accès
aux propriétés de la composante Transform.

[Link] = [Link]; // La position d l’objet devient

(1,1,1)

[Link](3f,5f,6f); // Bouge l’objet selon un vecteur de

coordonnées (3,5,6)

[Link](0,0,1f); // Tourne l’objet selon un vecteur de

(0,0,1)

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 64
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
[Link] *= 2f; // multiplie les valeurs de la mise à
l’échelle en x, y et z par 2

AUTRES COMPOSANTS
Tel que mentionné ci-dessus, il est également possible de faire référence à d’autres
composants de l’objet (ex. Rigidbody, AudioSource, PlayableAsset, etc.). La définition de
la variable demeure la même que celle du type Transform. Cependant, le code dans la
fonction Start() dans le cas d’une variable privée diffère. Il s’agit du nom donné à la
variable = [Link]<nom de la composante>();.

Rigidbody rb;

void Start()

rb = [Link]<Rigidbody>();

//

AudioSource monAudio;

void Start()

monAudio = [Link]<AudioSource>();

Tout comme transform, il est possible d’utiliser le GetComponent< ?>() pour aller
chercher les propriétés du composant en question.

[Link]<Animator>().enabled = false; // arrête l’animation

[Link]<AudioSource>().Play(); // démarre le son

ASTUCE ! PLUSIEURS FAÇONS DE CHERCHER CE QU’ON VEUT…

Puisque le point permet de chercher des fonctions, propriétés et composantes selon le

mot qui le précède, il est possible de retrouver la même chose en définissant une variable
plus générale (ex. Un gameobject).

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 65
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
En fait, il est préférable de commencer comme cela et, à la fin, lorsqu’on est assuré que
le code fonctionne bien, il est possible de l’optimiser avec des raccourcis, c’est-à-dire en
définissant des variables plus spécifiques (ex. Un transform, une audiosource, etc.), et
remplacer des lignes de codes avec celles-ci.
Transform transfo;

void start()

transfo = [Link];

[Link](); // équivalent raccourci

[Link](); // définition plus générale

AudioSource audio;

void Start()

audio = [Link]<AudioSource>();

[Link](); // raccourci

[Link]<AudioSource>().Play(); // générale

VECTOR3
Les vecteurs 2D (x, y), 3D (x, y, z) et 4D (w, x, y, z) permettent de regrouper des
coordonnées pour représenter un point, des positionnements dans l’espace, des
couleurs, etc. Les Vector2 et Vector3 sont utilisés grandement pour la localisation d’un
objet dans l’espace 2D et 3D. Pour les couleurs, le Vector3 est utilisé pour représenter une
couleur opaque avec des coordonnées représentant (rouge, vert, bleu) alors que le
Vector4 ajoute un composant de plus, l’opacité : (rouge, vert, bleu, opacité).

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 66
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Contrairement aux autres variables, la définition d’un vecteur comme variable diffère
grandement. Un float, par exemple, serait défini par float suivi du nom donné à la
variable. Pour un vecteur, mis à part l’état de visibilité, il faut mentionner le type, le nom
donné suivi d’un signe égal, new Vector3 et ses coordonnées entre parenthèses. Sinon, il
est également possible de partir d’un vecteur avec des coordonnées prédéfinies à l’aide
du point.

public Vector3 fleche = new Vector3(2,4,6);

private Vector3 haut = [Link];

//

Vector3 pos; // utile pour définir des propriétés comme Position de la composante
Transform

void Start()

pos = [Link];

Les vecteurs peuvent également subir des opérations (voir section 3.2.) et des mises à
l’échelle.

Vector3 vect1 = new Vector3(3,0,0);

Vector3 vect2 = new Vector3(0,0,2);

Vector3 res = new Vector3(); // (0,0,0)

res = vect1 + vect2; // — > (3,0,2)

res -= vect2; // — > (3,0,0)

res *= 3f; // -> (9,0,0)

res.y = 1; // coordonné en y devient 1 -> (9,1,0)

res = [Link](vect1, vect2); //. Scale permet de multiplier un vecteur avec

un autre — > res = (3,0,0)*(0,0,2) -> (0,0,0)

Les couleurs suivent aussi les mêmes règles. Cependant, les valeurs des coordonnées ne
peuvent pas dépasser 1.

Color couleur1 = new Color(0.3f, 0.4f, 0.6f, 1f);

public Color couleur2 = [Link];

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 67
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Color couleur3 = new Color(0.3f, 0.2f, 0.9f);

3.2. OPÉRATIONS

3.2.1. OPÉRATIONS DES VARIABLES SIMPLES

Il est possible de faire subir des opérations aux variables, qu’elles soient numériques ou
non. Pour des variables numériques, il faut toutefois tenir compte des nombres (réels ou
entiers ?) pour éviter des erreurs.

CALCULS DES INT

Pour des calculs invoquant des int, des valeurs entières sont utilisées pour donner un
résultat entier. Ainsi, il n’y aura pas d’arrondissement de valeur puisque des valeurs
fractionnaires n’existent pas dans les nombres entiers.

int res;

res = 5/2; //—> 2

CALCULS DES DOUBLES

Avec les double, les valeurs réelles sont utilisées pour les calculs. Cependant, il faut faire
attention à l’écriture, car des résultats différents peuvent en sortir sans nécessairement
déclencher des erreurs.

double res;

res = 5/2; // — > 2

res = 5.0/2; // -> 2.5

res = 5/2.0; // — > 2.5

res = 5.0/2.0; // -> 2.5

Le 1er résultat donne 2 en raison des valeurs entières utilisées. C’est un résultat tronqué
sans arrondissement. Pour avoir un résultat réel, il faut qu’au moins une des 2 valeurs
utilisées soit réelle, c’est-à-dire avec des décimales.

CALCULS DES FLOAT

Même chose que les double, les float utilisent des valeurs réelles dans leurs opérations.
Par contre, des points décimaux seuls ne seront pas suffisants. Il faut que le résultat final
soit un float également. Sinon, il y aura une erreur indiquant qu’il n’est pas possible de

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 68
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
convertir un double en float. Pour ce faire, il suffit de simplement ajouter un f après une
des valeurs. Cependant, si une valeur est décimale, c’est elle qu’il faudra transformer en
float pour éviter encore une fois l’erreur du double.

float res;

res = 5/2; //—> 0, c’est une erreur

res = 5/2.0f; //—> 2.5

ASTUCE ! CONVERSION EXPLICITE DES VALEURS

Il est possible de convertir une valeur en mettant le type de variable entre
parenthèses devant le nombre à convertir.
float res;
res = (float)5/2;

OPÉRATIONS SUR DES VARIABLES DE TYPE CARACTÈRES

Il est également possible de faire des opérations avec des string et des char. En fait, il est
même possible de concaténer des string avec des char sans besoin de convertir le résultat
final, contrairement aux variables numériques. Dans ce cas, le résultat serait de type
string.

string resString;

resString = "chaine";

char resChar = ‘s’;

resString = resString + resChar; // chaine + s -> chaines

UTILITÉ DES SIGNES DE COMPARAISON POUR DÉFINIR DES BOOL

À la place de définir une variable bool comme true ou false, il est également possible de
la définir par des équations d’inégalité ou d’égalité.

bool res;

float nb = 3f;

res = true;

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 69
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
res = false;

res = 1f <= 2f; // true

res = nb> 5; // false

3.2.2. OPÉRATEURS D’INCRÉMENTATION

Il existe des raccourcis pour des équations qui incrémentent ou décrémentent la valeur
d’une variable lors de l’exécution du code. Autrement dit, pour des équations du type :
variable = valeur actuelle de la variable ± 1. Les raccourcis consistent à soit 2 + ou 2 — qui
suivent ou précèdent la variable pour, respectivement, permette l’addition de 1 ou la
soustraction de 1. Il n’y a pas besoin de signe égal ni de répéter la variable dans la ligne
de codes pour avoir sa valeur actuelle. Peu importe l’emplacement des signes, le résultat
sera le même. En fait, les pré-incrémentations et pré-décrémentations sont utilisées
lorsque l’accès à la variable prend trop de temps ou si elle est static (une variable
constante accessible de l’extérieur d’une fonction ou d’une class). Sinon, elles ont la
même fonction que les post-incrémentations et post-décrémentations.

int i = 1;

i = i + 1; // i = 2

i++; // post-incrémentation -> i = i + 1 -> i = 3

++i; // pré-incrémentation -> i = i + 1 -> i = 4

i--; // post-décrémentation -> i = i — 1 -> i = 3

--i; // pré-décrémentation -> i = i — 1 -> i = 2

3.2.3. OPÉRATEURS D’AFFECTATION

Dans le cas où la valeur à additionner ou à soustraire ne serait pas de 1, il existe des
opérateurs d’affectation, ce qui inclut non seulement les additions et les soustractions,
mais également les multiplications et divisions. Ils permettent d’éviter la répétition de la
variable comme les opérateurs d’incrémentation.

int i = 1;

i += 4; // i = i + 4 -> i = 5, opérateur d’affectation d’incrémentation

i —= 3; // i = i — 3 -> i = 2, opérateur d’affectation de décrémentation

i *= 2; // i = i * 2 — > i = 4, opérateur d’affectation de multiplication

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 70
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
i /= 2; // i = i / 2 -> i = 2, opérateur d’affectation de division

3.2.4. MODULO
Le modulo est le reste d’une division de valeurs entières. Si l’on effectuait une division à
crochet, comme suit :

Le 2 en bleu est la valeur entière, soit le quotient en int. Le modulo est ce qui reste de la
division, soit le 1. En codes, la valeur entière du résultat peut être trouvée à l’aide d’une
division simple alors que, pour le modulo, il suffit de réécrire le même code que la division
en remplaçant la barre oblique (/) par un signe de pourcentage (%).

int i;

i = 5 / 2; // i est la valeur entière de la division -> i = 2

i = 5 % 2; // i est le modulo de la division -> i = 1

3.3. STRUCTURES SÉLECTIVES

Les structures sélectives, c’est-à-dire le if et, par extension, parfois le else, permettent
d’exécuter du code si des conditions sont remplies ou non. Ils suivent ainsi une exécution
comme suit :

if(condition)

// codes ici s’exécute si condition est rencontrée

else // partie facultative

// codes ici s’exécute si condition n’est pas rencontrée

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 71
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Les if et les else peuvent se servir d’opérateurs unaires et binaires pour aider à définir les
conditions. Ils peuvent être appliqués à des valeurs ou à des opérations complexes. Les
opérateurs binaires comprennent les signes d’inégalité (<, >, <=, >=) et d’égalité (==). Ils
comprennent également les opérateurs ET (&&), qui permet d’émettre plusieurs
conditions logiques qui doivent toutes être rencontrées, et OU (||), qui est plus permissif
que ET, permettant l’exécution de codes pourvu qu’une des conditions soit rencontrée.
Les opérateurs unaires, eux, comprennent le signe != et ! qui veulent dire n’égale pas ou
l’inverse d’une clause logique. ! est plus utilisé pour des constantes comme true et false
alors que != peut être appliqué à des opérations.

public bool lift = true;

int i = 15, j = 2;

void Update()

if (!lift && i <= 10) // si Lift est false et i est plus petit ou égal à
10

i *= j;

lift = true;

else

i--;

lift = false;

print(i); // fonction qui imprime dans la Console ce qui est entre les ()

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 72
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ATTENTION !

Dans les conditions des if, le signe égal s’écrit comme suit : ==. Dans le cas où un seul
signe égal serait posé dans la condition, une erreur s’affichera et le code ne s’exécutera
pas.

ASTUCE ! TABLES DE VÉRITÉ

Les opérateurs && et || permettent de lier plusieurs conditions dans le if, mais la
vérité globale issue des vérités des conditions peut mêler certains. Voici donc des
tables de vérité qui résument si le if sera exécuté (√) ou non (×) :

Condition 1
Opérateur &&
TRUE FALSE

TRUE √ ×
Condition
2
FALSE × ×

Condition 1
Opérateur ||
TRUE FALSE

TRUE √ √
Condition
2
FALSE √ ×

Il est possible de voir que || est permissif, permettant l’exécution du if pourvu

qu’une des conditions soit true. Comparé à cela, le && est restrictif, permettant
l’exécution du if seulement si toutes les conditions sont true.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 73
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Les structures sélectives peuvent être imbriquées l’une dans l’autre. Cependant, il est
préférable de ne pas dépasser 3 if imbriqués pour éviter de se perdre dans les conditions.
Dans le cas de plus de 3 if imbriqués, il est préférable d’utiliser un switch à la place, qui
permet de définir toutes les conditions possibles avec les codes à exécuter en un seul
bloc. Pour plus d’informations, veuillez-vous référer à sa page tutoriel Unity.

3.4. [Link]

Tel que mentionné plus haut, des messages sont constamment générés par le noyau
pour décrire l’état du jeu en exécution. De plus, la fonction de mise à jour dans
l’environnement de codes (par exemple Update()) peut être maintenue à l’aide des codes
qui se bouclent sur eux-mêmes. La fréquence de cette boucle est d’environ 0.02 seconde,
soit 50 boucles par seconde.

Cependant, ce n’est pas si simple que ça ! La fréquence de tours de boucles dépend de

plusieurs paramètres tels que la vitesse du microprocesseur, la complexité graphique de
la scène, etc. Par conséquent, au démarrage du jeu, la fréquence sera très lente. Après
les 1ers appels d’Update() ou les 1res boucles, la fréquence sera de vitesse moyenne. Ce
n’est qu’après quelques boucles de codes que la fréquence atteindra sa valeur normale
de 0.02 seconde. Visuellement, au démarrage du jeu, un objet en mouvement sera
d’abord lent et accélèrera soudainement jusqu’à atteindre une vitesse constante. Il y a
donc une variation de vitesse qui n’est pas désirée.

Pour médier à cela, la propriété [Link] existe. Elle correspond au nombre de

secondes depuis le dernier appel d’Update() et permet d’uniformiser la vitesse en
fonction de la vitesse du microprocesseur. Ainsi, à chaque boucle, le [Link] est
mis à jour en fonction du temps pris pour faire la boucle précédente.

float vitesse = 8f; // vitesse de 8 unités(ou mètres sur Unity)/seconde

[Link](vitesse * [Link], 0f, 0f); // l’objet

bougera horizontalement à une vitesse de 8 unités/seconde

3.5. INPUT MANAGER

Les commandes utilisateurs sont classées en types d’inputs et en retour d’outputs dans
l’Input Manager. Les types d’inputs ou évènements sont les types de commandes soient
le clavier, la souris, le clavier et la souris et le touch. Ces commandes peuvent être
regroupées selon ce qu’elles retournent. Il y a d’abord le retour unique de type booléen

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 74
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
qui retourne la valeur true que lorsque l’évènement a lieu. Il y a ensuite un retour en
continu, aussi de type bool, qui retourne true lorsque l’évènement se poursuit (ex. une
touche enfoncée). Enfin, il y a le retour continu, mais de type float qui retourne une valeur
réelle lorsque l’évènement se poursuit.

Voici 3 exemples d’Input Manager de chacune des catégories de retour :

3.5.1. COMMANDE CLAVIER À RETOUR UNIQUE

Cette commande inclut tout évènement issu de l’appui ou relâche d’une touche clavier.
Selon l’Input Manager invoqué, il sera true pourvu que la touche ait été appuyée ou
relâchée. Ainsi, maintenir la touche appuyée invoquera la valeur true rien qu’une fois à
l’appui et la valeur false sera retournée le long du maintien de l’appui.

Les Input Manager pour cette catégorie sont GetKeyDown(touche clavier) et

GetKeyUp(touche clavier) qui permettent respectivement les évènements de l’appui
d’une touche et la relâche d’une touche. Pour définir une touche clavier, il est possible de
mettre le nom de la touche entre guillemets ("…") ou bien de taper KeyCode. suivi du code
associé à la touche.

int i = 1; j = 2;

if([Link]("w")) // si la touche W est appuyée

i++;

print(i);

if([Link]([Link])) // si la barre d’espace est relâchée

j--;

print(j);

3.5.2. COMMANDE CLAVIER À RETOUR CONTINU

Contrairement à l’input précédent, celui-ci permet le retour de la valeur true pourvu que
la touche soit enfoncée. La réponse true est donc en continu pourvu que l’appui soit
maintenu.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 75
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
L’Input Manager qui lui est associé est le GetKey(touche clavier). La même nomenclature
est utilisée pour définir la touche clavier.

if([Link]("s")) // si la touche S est enfoncée

// code ici s’exécute

3.5.3. COMMANDE CLAVIER ET SOURIS À RETOUR CONTINU

La commande clavier ou souris de retour continu de type float retourne une valeur entre
-1 et 1 tant que l’évènement se poursuit.

Son Input Manager est défini selon les axes horizontale et verticale : GetAxis("Horizontal”
ou "Vertical").

float deplacement;

deplacement = [Link]("Horizontal");

[Link](deplacement * [Link], 0f, 0f); // bouge

l’objet sur l’axe des x selon les inputs horizontaux

3.6. FONCTIONS

La programmation sur Unity diffère de la programmation traditionnelle. Le code

s’exécute généralement de haut en bas, mais ne se boucle pas nécessairement une fois
la fin atteinte. En fait, Unity fait appel aux fonctions à l’intérieur du Script à l’aide des
évènements du jeu, d’où le nom d’Event Functions. La fonction s’exécute et retourne le
contrôle à Unity qui décide la prochaine fonction à exécuter. Ces fonctions avec des noms
spécifiques sont appelées en réponse à des évènements particuliers.

3.6.1. INITIALIZATION EVENTS

À l’ouverture d’un nouveau fichier Script, 2 fonctions de base se trouvent. La 1re est la
fonction Start(). C’est une fonction qui est appelée une seule fois avant toute mise à jour
issue du jeu dès le démarrage du jeu. Elle sert entre autres à initialiser un objet d’Unity
ou du Script (par exemple, définir les GameObjects).

Semblablement, il y a la fonction Awake(), aussi appelée une seule fois. Cependant,

contrairement à Start(), elle est appelée lorsque le Script est en cours de téléchargement.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 76
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
Ses initialisations sont donc plus rapides que celles de Start(). Ceci est utile lorsque le
chargement de nouvelles Scenes invoque l’initialisation de nouveaux Scripts ou lorsque
des objets sont activés et désactivés par le Script.

Dans ce dernier cas, il peut être nécessaire d’effectuer de multiples initialisations puisque
la réactivation d’un objet n’invoquera pas la fonction Start() qui a déjà été exécutée une
fois. Il faudra alors utiliser la fonction OnEnable() à sa place qui est appelée
automatiquement lorsqu’un objet est activé à l’aide de la commande SetActive(true).

3.6.2. REGULAR UPDATE EVENTS

La 2e fonction de base qui se trouve à l’ouverture d’un fichier Script est la fonction
Update(). Elle contient les codes qui servent à faire les mises à jour telles que les
changements de position, de l’état d’un objet, d’animation, etc. L’Update() est la
fonction de base pour programmer tout comportement de jeu et elle est appelée avant
que ces changements soient rendus et que les animations soient calculées.

Les mises à jour des contraintes physiques ne se font pas à la même fréquence que les
cadres d’animation. C’est là qu’entre en jeu la fonction FixedUpdate(). Elle est appelée
avant chaque mise à jour d’évènements physiques et permet d’avoir des résultats plus
précis.

Dans le cas où il serait nécessaire de faire des changements après que les fonctions
Update() et FixedUpdate() soient appelées, la fonction LateUpdate() peut être utilisée.
Des exemples d’utilisation seraient de faire suivre la caméra après qu’un objet ait fini de
bouger ou de modifier l’ordre d’exécution d’une animation.

En somme, les fonctions de mise à jour sont des fonctions dont les codes sont
constamment bouclés.

3.6.3. PHYSICS EVENTS

Pour détecter les collisions, il existe des fonctions spécifiques. Il y a OnCollisionEnter(),
OnCollisionStay() et OnCollisionExit() qui sont appelées respectivement lorsque l’objet
entre en collision, maintient le contact et sort d’une collision. Dans le cas d’un Collider
avec la propriété IsTrigger activée, il existe les fonctions OnTriggerEnter(),
OnTriggerStay() et OnTriggerExit(). Les fonctions d’évènements physiques peuvent donc
être appelées en tout temps pourvu qu’une collision soit impliquée.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 77
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
void OnCollisionEnter(Collision collision) // input est l’objet avec lequel on
rentre en collision

if([Link]("Player")) // si l’objet de collision

est étiquetté Player

// codes s’exécutent

3.6.4. FONCTIONS PERSONNALISÉES

Il est également possible de créer des fonctions autres que les fonctions de base. Pour ce
faire, il faut choisir un type d’output, donner un nom à la fonction et lui attribuer un type
d’input. Les inputs sont les variables que la fonction reçoit alors que l’output est ce que la
fonction retourne. S’il n’y a pas à attribuer d’inputs et d’outputs aux fonctions, l’output
sera défini comme étant void et il n’y aura pas d’inputs à définir entre les parenthèses
après le nom de la fonction.

void Fonction1()

// codes

public void Fonction2(float x) // x est comme une variable définie dans le bloc
de codes

// codes

float Fonction3(float a, float b)

float diff;

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 78
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
 diff = a—b;

return diff; // float qui sera retourné

Les codes de la fonction sont, tout comme les autres fonctions, entre des accolades.
Cependant, il n’y a pas d’évènements de Unity qui sont prédéterminés à appeler une
fonction personnalisée. Pour s’assurer de son appel, il faut la placer dans une des
fonctions de base mentionnées ci-dessus. Sinon, la fonction personnalisée ne
s’exécutera pas.

4. MOUVEMENTS DE L’AVATAR DE LA TIGE

Des déplacements translationnels (.Translate) simples et des rotations (.Rotate) ont

été codés en C# pour bouger le Target. Ces mouvements sont programmés pour être
actionnés par des touches spécifiques du clavier qui seront par la suite traduites en
commandes joystick. La touche espace du clavier
([Link]([Link])) sert à changer entre 2 modes : le mode 1
médiant les mouvements horizontaux translationnels et le mode 2 qui, lui, médie les
mouvements verticaux et l’ouverture et fermeture du préhenseur. Le bouton Enter
([Link]([Link])) sert aux fonctions modes-indépendants. Une
touche rapide permet l’ajustement de position du préhenseur (change par du code le
Playable Asset de l’un, qui a le préhenseur sur le côté, à l’autre qui l’a de haut, et vice
versa) et une touche d’une durée plus longue que 4 secondes permet la modification de
vitesse des mouvements de la tige (à l’aide d’un if qui possède comme conditions l’appui
maintenu sur Enter && un temps d’appui de plus de 4 secondes). La fonction Timeline a
été utilisée pour animer le changement de position du poignet afin de permettre une
fluidité entre les 2 positions.

5. LIMITES DES MOUVEMENTS DE L’AVATAR

Comme la vraie tige, les mouvements de l’avatar sont restreints dans une forme quasi
cylindrique. Pour ce faire, la cible, en particulier, a été codée pour maintenir la même
position que le Tip. Un cylindre avec un Capsule Colldier a été ajouté à la base de la tige
pour l’empêcher de se replier sur elle-même. Enfin, le Hint a été codé pour suivre l’Arm1
à l’aide de la fonction MoveTowards du Vector3, ce qui empêche en tout temps l’effet du
coude à l’envers.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 79
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
6. EXPORTATION D’UN PROJET

Une fois le projet Unity complété, il faut l’exporter en son produit final, que ce soit une
application de jeux, une vidéo, etc.

Il faut d’abord se rendre dans les Build Settings (figure 35 suivante) sous l’onglet File. La
1re section d’intérêt est la section Scenes In Build. C’est ici que doivent se trouver toutes
les scènes impliquées dans le projet. Pour les ajouter, il faut avoir la Scene à ajouter
ouverte avant d’ouvrir les Build Settings, puis cliquer sur Add Open Scenes. Bien sûr, cette
méthode est longue et ardue dans le cas où il y aurait plusieurs scènes à ajouter. Il est
également possible de tout simplement glisser les Scenes du dossier Project au Scenes In
Build. Assurez-vous de bien avoir les Scenes du projet à exporter cochées ! Sinon, les
scènes pas cochées ne se compileront pas dans le produit final.

Figure 35 : Build Settings

Ensuite, dans la propriété Target Platform, il est possible de choisir sur quel système
d’opérations afficher le produit final (ex. Windows ou Mac). Cependant, si les modules

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 80
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
nécessaires ne sont pas installés, rien n’apparaitra. Les modules à installer sont les Build
Support conformes au système d’opérations au choix.

Par la suite, il faut se rendre dans les Player Settings… (figure 36) qui se trouvent tout en
bas à gauche de la fenêtre Build Settings. Ceci nous amènera dans la section Player des
Project Settings. C’est ici qu’il est possible de gérer l’apparence finale du produit. Il est
possible de lui attribuer une icône, de lui donner un nom, de l’associer à notre compagnie,
etc. Il est toutefois nécessaire de régler quelques paramètres. D’abord, la propriété
Fullscreen Mode devrait être sur Windowed pour permettre de choisir une taille d’écran
d’affichage. Il faut également cocher sur Resizeable Window pour permettre le
redimensionnement de l’écran par l’utilisateur.

Figure 36 : Player Settings

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 81
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
ATTENTION !

Dans le cas d’une exportation vers Mac (ou même dans tous les cas), il faut décocher la
propriété Mac Retina Support qui pourrait rendre l’exécution du produit final un peu lente.

Une fois le tout réglé, on peut fermer la fenêtre des Player Settings… et retrouver celle
des Build Settings. Il reste juste à sauvegarder le produit final sur le disque. Pour ce faire,
il suffit de cliquer sur Build et de choisir l’emplacement désiré. Et voilà ! Nous avons
maintenant une application à part qui consiste au produit final.

ATTENTION !

Dans le cas d’une exportation/sauvegarde faite sur Windows, il faut se créer un dossier
vide dans lequel enregistrer l’application. Ceci n’est pas nécessaire pour un Mac, où
l’application peut être sauvegardée ailleurs, dans un dossier déjà rempli.

CONCLUSION

L’objectif de ce document était de regrouper les notions de base afin de pouvoir créer
des mises en situations virtuelles et appliquer certaines fonctions, dont la Timeline,
l’Animation Rigging et les Inputs Manager, pour faire bouger un avatar importé de
Blender. Ce manuel survole l’interface Unity en plus de ces divers objets et composants
de base. Il touche également une partie de l’engin d’animation de Unity. Finalement, ce
manuel explique certains aspects de la programmation en C# pour développer une
activité.

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 82
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
RÉFÉRENCES

[1] A. Koenig et al., "Controlling patient participation during robot-assisted gait training," Journal of
NeuroEngineering and Rehabilitation, vol. 8, no. 1, p. 14, 2011/03/23 2011, doi: 10.1186/1743-0003-
8-14.
[2] J. Ziherl, D. Novak, A. Olenšek, M. Mihelj, and M. Munih, "Evaluation of upper extremity robot-
assistances in subacute and chronic stroke subjects," Journal of NeuroEngineering and
Rehabilitation, vol. 7, no. 1, p. 52, 2010/10/18 2010, doi: 10.1186/1743-0003-7-52.
[3] G. G. Fluet, D. Roy, R. Llorens, S. Bermúdez i Badia, and J. E. Deutsch, "Basis and Clinical
Evidence of Virtual Reality-Based Rehabilitation of Sensorimotor Impairments After Stroke," in
Neurorehabilitation Technology, D. J. Reinkensmeyer, L. Marchal-Crespo, and V. Dietz Eds.
Cham: Springer International Publishing, 2022, pp. 429-466.
[4] H. Feng et al., "Virtual Reality Rehabilitation Versus Conventional Physical Therapy for
Improving Balance and Gait in Parkinson's Disease Patients: A Randomized Controlled Trial," (in
eng), Med Sci Monit, vol. 25, pp. 4186-4192, Jun 5 2019, doi: 10.12659/msm.916455.
[5] L. d. Chambure, M. Raison, and E. Clark, "Movements Decomposition of Upper Limbs Complex
Sequences for Rehabilitation Sessions Optimization," presented at the RehabWeek, Rotterdam,
The Netherlands, 25-29 July 2022, 2022, Poster.
[6] R. L. Sainburg and P. K. Mutha, "Movement Neuroscience Foundations of Neurorehabilitation,"
in Neurorehabilitation Technology, D. J. Reinkensmeyer, L. Marchal-Crespo, and V. Dietz Eds., 3
ed. Cham: Springer International Publishing, 2022, ch. 2, pp. 19-39.
[7] V. Dietz, L. Marchal-Crespo, and D. Reinkensmeyer, "Recovery of Sensorimotor Functions After
Stroke and SCI: Neurophysiological Basis of Rehabilitation Technology," in Neurorehabilitation
Technology, D. J. Reinkensmeyer, L. Marchal-Crespo, and V. Dietz Eds., 3 ed. Cham: Springer
International Publishing, 2022, ch. 3, pp. 41-53.
[8] V. D. Novak, A. C. Koenig, and R. Riener, "Psychophysiological Integration of Humans and
Machines for Rehabilitation," in Neurorehabilitation Technology, D. J. Reinkensmeyer, L.
Marchal-Crespo, and V. Dietz Eds. Cham: Springer International Publishing, 2022, pp. 207-221.
[9] A. Koenig et al., "Real-time closed-loop control of cognitive load in neurological patients during
robot-assisted gait training," (in eng), IEEE Trans Neural Syst Rehabil Eng, vol. 19, no. 4, pp. 453-
64, Aug 2011, doi: 10.1109/tnsre.2011.2160460.
[10] M. M. Lusardi and D. M. Bowers, "Motor Control, Motor Learning, and Neural Plasticity in
Orthotic and Prosthetic Rehabilitation," in Orthotics & Prosthetics in Rehabilitation, M. M.
Lusardi, M. Jorge, and C. C. Nielsen Eds., 3 ed.: Elsevier/Saunders, 2013, ch. 3, pp. 38-71.
[11] Á. Gutiérrez, N. Farella, Á. Gil-Agudo, and A. de los Reyes Guzmán, "Virtual Reality Environment
with Haptic Feedback Thimble for Post Spinal Cord Injury Upper-Limb Rehabilitation," vol. 11,
no. 6, p. 2476, 2021. [Online]. Available: [Link]
[12] D. Sherknies, "IFT 1119 - Initiation à la programmation de jeux vidéo," ed: Université de
Montréal, 2022.
[13] E. Martynenko. "Unreal engine vs. Unity 3D. The 2022 overview." pingle.
[Link] (accessed 21
avril 2023).

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 83
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0
[14] M. N. Ahmed, M. Raison, and E. Clark, "MANUEL DE BLENDER POUR LA MODÉLISATION D'UN
AVATAR 3D DE ROBOTIQUE," Polytechnique Montréal, Montréal, Technical Report. October
2023. [Online]. Available: [Link]

Maïsha N. Ahmed
Maxime Raison; Répertoire des expertises ([Link]) 84
Elizabeth Clark, Erg./OT; www. linke din. com/in/e lizabe th -clark -b3b2 706 0