TP1 : Fondamentaux Unity

Rémy Frenoy, Florian Jeanne, Yann Soullard, Azzeddine Benabbou, Yohan Bouvet (maj 2022)

Création d’un projet

Lors du lancement de Unity, ce n’est pas le logiciel qui s’ouvre, mais le « Unity Hub », qui sert à gérer vos projets ainsi que les différentes versions d’Unity installées.

Figure : L’interface de Unity Hub peut être différente si vous avez une version plus récente.

Créez un nouveau projet en sélectionnant le template « 3D URP » (Universal Render Pipeline) et nommez-le comme vous le souhaitez. Il est possible que le template ne soit pas téléchargé. Il faudra alors le télécharger.

Note

La création d’un nouveau projet prend généralement du temps. C’est donc normal si vous voyez des fichiers se charger en continu.

Interface graphique de Unity

Figure : Interface principale de Unity pour l’édition d’un projet

1 (rouge) Hierarchy – Hiérarchie des éléments disposés sur la scène.

2 (vert) Project – Ensemble des ressources du projet.

2 bis (vert) Console – Sortie des erreurs de compilation en mode Scene, et les outputs console en mode Game (ex: messages de Debug.Log(« message »))

3 (bleu) Scene – Scène d’édition, permet d’ajouter, modifier, supprimer des éléments de l’environnement.

3 bis (bleu) Game – Affiche l’application une fois celle-ci lancée.

4 (orange) Inspector – Affiche les propriétés et les options de configuration de l’objet sélectionné.

5 (violet) Control bar – Permet de lancer, suspendre et arrêter l’application en cours.

Organisation du projet

Lors de la création d’un nouveau projet, Unity crée une première scène, qui est déjà enregistrée dans les ressources (Assets), dans le dossier Scenes. En ouvrant le dossier, vous pouvez observer que le nom de l’objet correspond à celui qui est tout en haut de la hiérarchie. Pour signifier que ceci va être notre scène principale, faites un clic-droit sur l’objet SampleScene et renommez-la en Main. Selon la version de Unity, il est possible que l’éditeur vous indique que ce changement nécessite de recharger la scène ! Après recharge, vous pouvez voir que l’objet, dans la fenêtre Hierarchy, a été renommé.

Note

(Pour les versions antérieures à 2021 : le dossier « Assets > Scenes » n’est pas automatiquement créé et votre scène pas sauvegardée, vous devez le faire manuellement !)

La quantité de ressources présentes dans un projet Unity peut rapidement être imposante.

Ces ressources sont très variées (scènes, scripts, matériaux, …). Vous vous attacherez donc à organiser rigoureusement vos ressources dans des dossiers correspondants à leur nature (les scènes dans un dossier “Scènes”, les scripts dans le dossier “Scripts”, etc). Toutes les ressources Unity sont considérées comme des “assets”, ainsi tous les dossiers que vous créerez seront à placer dans le dossier “Assets”.

Figure : L’organisation de vos projets devrait ressembler plus ou moins à ça.

Avant d’attaquer la suite de ce TP, vous pouvez surpprimer l’objet Global Volume présent dans la scène et le dossier TutorialInfo

Naviguer dans la scène

Pour naviguer dans la scène, Unity Editor propose plusieurs façon de faire. A vous de vous habituer et adopter les habitudes de navigation qui vous conviennent.

Placez votre curseur sur la scène et déplacez vous grâce aux touches directionnelles.
Sélectionnez l’outil View Tool (cf.image). Maintenez le bouton gauche de la souris appuyé puis bougez votre souris. Vous pouvez utiliser les touches directionnelles pour vous déplacer.

Figure: Outil View Tool

Pour vous déplacer dans la scène comme vous le feriez dans un jeu à la première personne (Fly mode), maintenez le bouton droit de la souris appuyé puis bougez votre souris. Utilisez ensuite les boutons Q,S,D,Z et A,E.

Note

Par défaut, Unity Editor est configuré pour une utilisation avec un clavier QWERTY. Pour modifier cela, il suffit d’aller dans Edit > Shortcuts, puis sélectionnez la catégorie 3D Viewport.

Créer un objet

La scène est vide… Ou presque ! Comme nous pouvons le voir dans la fenêtre Hierarchy, il y a deux éléments : Main Camera et Directional Light, qui sont une caméra par défaut et une lumière d’ambiance.

Nous allons commencer par créer des objets ( Game Objects dans le jargon Unity) simples comme une balle et un sol. Pour cela, il vous suffit d’aller dans le menu puis dans GameObject > 3D Object > Plane, pour ajouter le sol. L’objet apparaît dans la scène et dans la hiérarchie des objets. Il est déjà sélectionné et prêt à être renommé, comme ce sera le sol, renommons-le en “Ground” dans la fenêtre Hierarchy. (Si vous avez cliqué ailleurs et que l’objet n’est plus sélectionné, vous pouvez toujours faire un clic droit sur l’objet “Plane”, puis Rename).

Faites la même chose pour la balle que l’on nommera “Ball” : GameObject > 3D Object > Sphere.

Positionner un objet

Pour positionner les objets dans la scène, il faut tout d’abord sélectionner l’outil Move Tool.

Lorsque vous sélectionner ensuite l’objet à déplacer, vous devriez voir apparaitre 3 flèches sur l’objet sélectionné. Ces flèches correspondent aux 3 axes : x,y et z.

Figure : Les 3 axes affichés sur la sphère (x en rouge, z en bleu et y en vert).

Note

Dans Unity, l’axe par défaut pour la hauteur est l’axe Y. Si vous avez du mal à vous souvenir quel axe représente la hauteur, une astuce : les axes X, Y, Z sont représentés par les couleurs R, V, B. L’axe Y est vert : vert comme vertical !

Pour déplacer la sphère, sélectionnez un axe et maintenez le bouton gauche de la souris appuyé puis déplacez la sphère.

Dans certains cas, on aimerait définir précisement la position de l’objet dans la scène grâce à des valeurs numériques. Pour cela, dans la fenêtre Inspector, localisez la partie Transform. C’est ici que nous allons pouvoir modifier la position, la taille et l’orientation des objets. Tous les GameObjects possèdent un component Transform.

Placez la Sphère à la position (0,3,0)
Placez le Plan à la position (0,0,0)

Figure : Notre balle est au-dessus du sol.

Lancez la scène grâce au bouton Play. Il ne se passe rien. C’est normal !

Composants et physique

Maintenant que notre scène possède des objets, il serait intéressant de pouvoir les déplacer.

Pour cela, nous allons devoir ajouter une nouvelle propriété à notre balle. Dans le jargon Unity, on parlera de Composant (Component) afin de lui ajouter des contraintes physiques. Sélectionnez donc la balle puis ajoutez-lui un rigidbody : dans la fenêtre Inspector, cliquez sur le bouton Add Component, ou dans le menu Component > Physics > Rigidbody. Un nouveau component est alors ajouté à notre balle dans l’Inspector.

Lancez la scène grâce au bouton Play. Miracle, la gravité est rétablie et la balle tombe !

Déplacer un objet

Programmer les interactions (un peu de lecture)

Les interactions consistent à lier une commande, par exemple l’appui sur une touche, avec un comportement. Lorsque vous faites un clic droit avec la souris, vous interagissez avec l’application. Pour notre balle, c’est la même chose : on veut pouvoir la déplacer, par exemple grâce aux flèches directionnelles du clavier. Depuis la version 2019 de Unity, un nouveau système de gestion des commandes (Inputs) a été développé. Pour comprendre la différence avec l’ancien système, il faut comprendre comment fonctionne l’application.

Lorsque vous cliquez sur Play pour lancer la scène, des scripts se lancent. Parmi eux, certains seront créés par nous, pour pouvoir « faire ce qu’on veut ». Le comportement qui permet de dire qu’un GameObject qui possède une propriété RigidBody est automatique : la présence de la propriété RigidBody fait que l’objet sera considéré comme ayant un corps soumis aux lois physiques. Pourquoi peut-on voir l’objet tomber, pour finalement s’arrêter sur le sol ? Car il existe des fonctions qui tournent en boucle, et qui permettent d’actualiser l’état du monde, qui sera ensuite affiché.

Lorsqu’on clique sur Play, tous les objets de la scène lancent une fonction nommée « Start », qui permet de les initialiser dans le monde. Ensuite, à chaque « photo » du monde (frame), tous les objets appellent leur fonction Update. C’est là qu’on va pouvoir calculer les changements qui peuvent avoir lieu, par exemple, si on a demandé à la balle de se déplacer, c’est ici qu’on va calculer de combien elle doit se déplacer en fonction du temps écoulé et de la durée d’appui sur une touche.

Avant la version 2019 de Unity, on devait donc tester nous-mêmes, dans un script qu’on aurait créé, dans cette fonction Update, si, à chaque frame, il y a eu un appui sur une touche, et si c’est le cas, faire les changements appropriés.

Figure : Gestion des inputs dans les versions de Unity inférieures à 2019

Comme on ne peut pas changer le code d’un script « pendant » que l’application est lancée, si on veut finalement utiliser une autre touche, il faut avoir pensé à tester tous les cas possibles dans notre fonction Update. Depuis la version 2019, ce n’est plus le cas, et un nouveau système a été développé. À présent, lors de la fonction Update, on va juste tester si la commande liée à l’action qu’on veut faire a été activée ou non.

Figure : Gestion des inputs dans les versions de Unity depuis la version 2019

Input Manager (Ancienne version)

Dans le cadre de ce TP, nous testerons les deux systèmes. Nous utiliserons en premier lieu l’ancien Input Manager, puis,nous basculerons vers le nouveau système.

Pour déplacer notre sphère, il faut créer un script C#. Mais avant cela, et dans un souci d’organisation, nous allons créer un dossier Scripts dans notre projet. On y stockera tous nos scripts. Pour cela, faites un clic droit dans la fenêtre Project > Create > Folder. Maintenant, faites un clic droit dans le dossier nouvellement créé puis Create > C# Script (ou allez dans Assets > Create > C# Script à partir du menu). Un fichier apparaît dans l’explorateur du projet. Renommez-le “BallController”. Ce script va nous servir à contrôler le déplacement de notre balle. Il faut donc l’associer au GameObject “Ball”. Un simple glisser-déposer de l’objet BallController sur la balle, que ce soit dans la scène ou dans la hiérarchie, suffit. Vous pouvez aussi associer le script à la balle en passant par la fenêtre de l’Inspector en cliquant sur le bouton Add Component (Scripts > Ball Controller). Le script apparaît maintenant comme Component de la balle.

Pour éditer notre script, double-cliquez dessus et l’étideur que vous avez lié à Unity s’ouvrira alors automatiquement. Le script comprend par défaut deux méthodes : Start() et Update(). Start() contient les instructions qui seront exécutées au chargement du script, à sa première exécution. Elle n’est donc appelée qu’une seule fois ; Update() est appelée à chaque frame, et contient donc les instructions qui seront exécutées en boucle.

Définissons une nouvelle méthode nommée, par exemple, KeyboardMovements(). Cette méthode aura pour objectif de tester les touches du clavier qui sont utilisées et d’appliquer une force sur la balle, plus précisément sur le composant Rigidbody de la balle, dans la direction souhaitée.

Concrétement :

Nous avons besoin de récupérer une référence au composant Rigidbody de note balle (voir méthode GetComponent). C’est sur ce composant que nous allons agir.
Nous avons besoin de savoir si l’utilisateur a appuyé sur une des touches prévues pour déplacer la balle (voir les méthodes de la classe Input). On utilisera pour cette exemple, les touches directionnelles du clavier.
Si l’utiliseur a appuyé sur une touche prévue pour déplacer la balle, nous devons appliquer une force dans la direction souhaitée (voir la méthode AddForce et la classe Vector3)

Comme indiqué dans la documentation Unity, le paramètre de la fonction AddForce() est un Vector3. Il existe des Vector3 de base qui sont préétablis, comme Vector3.left qui correspond au vecteur (-1, 0, 0). En fonction de la touche appuyée, nous appliquerons donc une force dont la direction et l’intensité est définie par le Vector3 spécifié.

Indice

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class BallController : MonoBehaviour
{

private Rigidbody rb;

// Start est appelée une seule fois et au tout début.
void Start()
{
    rb = GetComponent<Rigidbody>();
}

// Update est appelée une fois par frame
void Update()
{
    //A chaque frame on appelle la fonction de déplacement qu'on aura créée
    KeyboardMovements();


}

void KeyboardMovements()
{
//Si on utilise des else if, on autorise l'appui sur une seule touche à la fois
//Si on veut pouvoir aller en diagonale, il faudrait faire le AddForce à la fin et gérer l'ajustement des valeurs dans les if, sans qu'il y ait de else

    if(Input.GetKey( ... ))
    {
     ....
    }
    else if(Input.GetKey( ... ))
    {

    }
    else if(Input.GetKey( ... ))
    {

    }
    else if(Input.GetKey( ... ))
    {

    }
}
}

Sauvegardez le script et retournez sur l’interface de Unity. S’il y a des erreurs, celles-ci apparaîtront dans l’onglet Console, juste à côté de l’onglet Projet. Appuyez sur play et amusez-vous en utilisant les touches. Attention à ne pas dépasser le sol !

Ajouter ensuite une variable publique speed et modifier votre script de façon à ce que la balle se déplace à la vitesse définie dans la direction souhaitée.

Placer la caméra

Unity place automatiquement une caméra sur la scène. Vous pouvez sélectionner cette caméra en choisissant Main Camera dans la fenêtre Hierarchy. Un pop-up Camera Preview s’ouvre et affiche la vue depuis la caméra sélectionnée. Vous remarquerez, en scrutant l’Inspector, que la caméra est positionnée en (0, 1, -10). Déplacez la caméra de telle sorte que vous puissiez voir le plan et la sphère dans Camera Preview.

Lancez l’application. Déplacez la sphère afin qu’elle sorte du champ de la caméra. On ne la voit plus (c’était le but de l’opération…). Une question existentielle se pose : comment faire pour que la caméra suive la sphère ?

Mieux placer la caméra

La hiérarchie des objets permet de définir un objet comme étant enfant d’un autre. Glissez-déposez l’objet Main Camera sur Ball dans la fenêtre Hierarchy : la caméra est désormais “enfant” de la sphère.

Lorsqu’un objet est enfant d’un objet parent, sa position devient relative à la position du parent, c’est-à-dire que le référentiel de l’objet enfant n’est plus le centre de la scène (0,0,0) mais le centre de son objet “parent”. Relancez l’application. La position initiale de la caméra ne change pas. Déplacez la sphère. La caméra se déplace désormais en suivant les déplacements de la balle. Ça vous plaît ? J’espère que vous avez le cœur bien accroché…

La méthode consistant à placer la caméra comme étant l’enfant d’un objet que l’on souhaite suivre est pertinente dans le cas d’un personnage à la première/troisième personne par exemple. En vue à la première personne, disposer la caméra comme “enfant” permet par exemple de suivre les déplacements et les mouvements de la tête. Attention toutefois aux déplacements de l’objet “parent” ! Lorsque celui-ci est amené à faire de nombreuses rotations (typiquement le cas d’une sphère !), mieux vaut utiliser une autre méthode…

Correctement placer la caméra

On souhaite que la caméra suive les translations de la sphère dans l’espace, mais pas les rotations. La caméra ne peut donc pas avoir comme référentiel celui de la balle. Dans la hiérarchie, faites donc en sorte que la caméra ne soit plus enfant de la sphère.

Figure : S’émanciper dans Unity, c’est facile!

On se retrouve dans la configuration initiale, avec une caméra fixe. Pour modifier cela, ajoutons un script CameraController à nos assets, et affectons-le à l’objet Main Camera. Ouvrez ensuite le script dans votre éditeur. Dans ce script, on souhaite que tout changement de position (c’est à dire une translation dans l’espace) d’un GameObject modifie de la même manière la position de la caméra. Nous avons donc besoin de deux variables :

Une variable que l’on nommera baseObject, de type GameObject et qui correspondra à l’objet que l’on souhaite suivre.
Une variable que l’on nommera offset, de type Vector3 et qui correspond au vecteur représentant l’écart entre la position initiale de la caméra et la position initiale de l’objet à suivre.

L’esprit de ce script est donc de repositionner la caméra afin que l’offset soit constant.

Il suffit donc de calculer l’offset au chargement de la scène (donc dans la méthode Start) de la façon suivante :

offset = transform.position - baseObject.transform.position;

A chaque frame (donc dans la méthode Update), on modifie la position de la caméra comme étant la position de l’objet à suivre plus l’offset.

transform.position = baseObject.transform.position + offset;

On obtient alors le code suivant :

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CameraController : MonoBehaviour
{
    public GameObject baseObject; //l'objet à suivre
    private Vector3 offset; //la distance initiale entre l'objet et la caméra

    // On calcule l'offset avant même que la balle ne tombe!
    void Start()
    {
        offset = transform.position - baseObject.transform.position;
    }

    void Update()
    {
        transform.position = baseObject.transform.position + offset;
    }
}

Lancez l’application.

Figure : Une erreur de compilation sauvage apparaît!

Oups ! En effet, nous avons déclaré avoir besoin d’une variable baseObject dans le script, mais Unity n’a aucune idée de quel objet il s’agit. C’est donc à nous de lui donner cette information.

Sélectionnez la caméra dans la fenêtre Hierarchy afin que ses propriétés apparaissent dans la fenêtre Inspector. Dans le cadre Camera Controller, vous voyez votre script, et vous voyez également la variable Base Object qui est pour l’instant à None, d’où l’erreur de compilation !

Depuis la fenêtre Hierarchy, glissez-déposez la balle vers la valeur de BaseObject dans la fenêtre Inspector. Vous obtenez ceci :

Lancez l’application, et déplacez la balle. Vous remarquez que la caméra suit les déplacements de la balle, sans en subir les rotations. Parfait !

Ajouter des textures aux objets

Cette scène est un peu terne. Ajoutons-y un peu de couleur. Pour modifier l’apparence d’un objet, celui-ci doit avoir un Material. Commençons par créer un dossier “Materials” dans la fenêtre Project, qui permettra de stocker l’ensemble des Materials utilisés dans un projet. Pour créer un Material, faites un clic droit > Create > Material. Renommez-le “GreenColor”. Pour donner une couleur verte à votre material, modifier la propriété Base Map dans la fenêtre Inspector et attribuez-lui la couleur verte. Pour appliquer un material sur un objet, il suffit de glisser-déposer le material depuis la fenêtre Project vers l’objet dans la scène.

Figure : Résultat de l’application du Material sur la balle.

Il est également possible d’utiliser des images plutôt que de simples couleurs. Créez un dossier Images dans le dossier Assets. Copiez-y l’image de gravier que vous pouvez télécharger ici (ou une autre image de votre choix). Nommez-la gravels, par exemple.

Créez maintenant un nouveau Material “Gravels”. Sélectionnez ce nouveau material afin qu’il s’affiche dans la fenêtre Inspector. Cliquez sur le petit cercle à gauche de la propriété Base Map et choisissez l’image gravels dans la fenêtre qui apparaît.

Comme nous l’avons fait précédemment pour la sphère, glissez-déposez le nouveau Material sur le sol de la scène.

Exporter votre projet

Pour exporter votre projet, cliquez sur Assets > Export Package.

Vérifiez bien que tout est coché, puis confirmez. Vous obtenez un fichier portant l’extension unitypackage. Vous pouvez désormais importer dans n’importe quel projet les assets (dont la scène) que vous venez d’exporter.

Passage au nouveau système d’Input

Configuration

Nous allons ici vous présenter le nouveau système d’input. Pour changer la façon dont les commandes sont gérées, allez dans le menu Edit > Project Settings > Player, puis dans la section Configuration, si la propriété « Active Input Handling » est réglée sur « Input Manager (Old) », changez-la, et mettez « Input System Package (New) ». Unity devrait vous indiquer qu’il doit redémarrer, acceptez ! Une fois Unity relancé, vous pouvez fermer la fenêtre Project Settings.

Allez ensuite dans le menu Window > Package Manager, cliquez sur le bouton « Packages : In My Project » pour sélectionner « Packages : Unity Registry », et cherchez le package Input System. Cliquez dessus et installez-le. Figure : le package Input System

Dans la fenêtre Project, faites un clic droit, puis Create > Input Actions. Ce nouvel asset va vous servir à lier des actions (dont l’activation sera testée dans les fonctions Update) et des commandes. Double-cliquez sur l’asset, une nouvelle interface s’est ouverte, nous allons la détailler.

Figure : Nous avons renommé notre asset « AllControls », d’où le nom affiché en haut.

1 (rouge) Control Scheme : la configuration matérielle qu’on va utiliser (par exemple, quand vous jouez à un jeu vidéo et que vous avez la possibilité d’alterner entre souris/clavier et manette…)

2 (bleu) Action Maps : des groupes d’actions qu’on va développer (pensez aux jeux vidéo, quand vous vous déplacez à pied puis en voiture…)

3 (vert) Actions : les actions qui seront testées, et les commandes qui les déclenchent.

4 (orange) Properties : les propriétés des commandes

Avant tout chose, cochez la boîte « Auto-save », sinon il vous faudra cliquer manuellement sur le bouton « Save Asset » pour que vos changements soient pris en compte…

Vide, l’interface n’est pas très parlante, alors commençons à remplir pour comprendre. Tout d’abord, nous allons créer un Control Scheme : cliquez sur « No Control Scheme » puis sélectionnez « Add Control Scheme ». Nommez le schéma « MainControls », puis cliquez sur le petit « + » sous la liste vide : c’est là où nous allons préciser quel matériel est nécessaire (ou optionnel) pour commander notre balle. Restons simples et sélectionnons « Keyboard ». Cliquez sur « Save » : ça y est, on a défini que pour pouvoir interagir, nous aurons besoin d’un clavier.

Dans Action Maps, comme notre application est simple, cliquez sur le « + » et nommez le groupe « Main ». Une nouvelle action s’est automatiquement créée ! Cliquez sur le petit triangle à gauche pour l’ouvrir.

Pour l’instant, notre action se nomme « New action » et n’est liée à aucune commande. Comme nous voulons déplacer la balle, renommons l’action en « MoveBall » (double-clic ou clic droit sur l’action). Dans les propriétés, nous pouvons voir que l’action a un type, ici « Button ». Il existe en fait 3 types d’actions, mais nous en utiliserons principalement 2 :

Button : l’action va être liée à un seul input binaire (ex. l’appui sur la touche Espace permet de sauter)
Value : l’action va être liée à une commande sur la durée (tant qu’on appuie sur la flèche droite, on se déplace à droite)

Comme nous gérons ici le mouvement, le type de l’action va être « Value ». Tant qu’on appuiera sur une touche, la balle se déplacera dans un sens. Mais le fait d’avoir une « valeur » renvoyée va nous permettre de pouvoir appuyer sur plusieurs touches en même temps et d’aller dans la bonne direction (si on veut aller en diagonale par exemple) car le calcul sera fait automatiquement !
Dans Control Type, sélectionner « Vector 2 » pour indiquer que nous souhaitons un control sur 2 vecteurs. Il est à noter que ce sélecteur conditionne les choix possibles du cadre « Action ».

Définissons maintenant quelles touches nous allons utiliser : faites clic-droit sur l’action MoveBall, nous voulons que la balle se déplace selon 2 axes (X et Z), donc ajoutons un «2D Vector Composite» (ou UpComposite). (Le « No Binding » est inutile, vous pouvez le supprimer en faisant clic droit dessus et Delete)

Figure : Après l’ajout du 2D Vector Composite

Nous avons presque fini la création de nos inputs. Cliquez sur une direction, et dans les propriétés, cliquez sur « Path » : la liste des matériels disponibles (quand vous avez créé le Control Scheme) s’affiche. Naviguez dans Keyboard pour trouver la touche que vous voulez utiliser, ou bien dans la barre de recherche.

Note

La partie « Usages » propose les touches les plus couramment utilisées dans les applications pour l’interaction, mais ne sont pas forcément en accord avec le matériel que vous avez choisi. Mieux vaut ne pas l’utiliser. Il y a également la solution de facilité, qui consiste à cliquer sur le bouton « Listen » puis à appuyer sur la touche (ou le bouton d’une manette, ou un clic de souris) désirée, ce qui va réduire les choix.

Figure : En cliquant sur Listen puis sur la flèche du bas, l’interface propose la touche (Down Arrow), mais également « n’importe quelle touche ». Choisissez “Down Arrow”.

Faites la même chose pour les autres bindings. A la fin, l’interface devrait ressembler à la capture suivante :

Ça roule !

Maintenant, nous allons mettre en place le script pour déplacer la balle.

Pour que la balle puisse adapter sa position, il faut qu’elle sache si des inputs ont été activés. Pour cela, sélectionnez la balle, puis, dans la fenêtre Inspector, ajoutez un nouveau Component > Input > Player Input. Il faut maintenant préciser quelles sont les commandes et les actions qui lui seront appliquées : pour cela, glisser-déposer l’asset InputActions, que vous venez de créer, dans le champ « Actions » du composant.

L’objet Ball est maintenant au courant des actions qui peuvent être activées. Il ne nous reste plus qu’à programmer ce que la balle doit faire lorsque ces inputs sont activées.

Avec le nouveau système de gestion des inputs, l’appui sur les touches que nous avons liées à notre action MoveBall permet de lancer un signal à notre objet Balle. Chaque action entraîne la création d’une méthode dont le nom est structuré de la même façon : On[Le_Nom_De_Votre_Action]. Ici, notre action s’appelle MoveBall, nous aurons donc une fonction dans notre script qui s’appellera OnMoveBall. Si on avait créé une action ChangeColor, la fonction qu’on devrait créer s’appellerait OnChangeColor, etc.

Le script agit comme un component de la balle, il a donc accès aux autres composants de celle-ci ; c’est pour cela que nous le lions à la balle.

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.InputSystem;
public class BallController : MonoBehaviour
{
    private Rigidbody rb;
    private Vector2 moveValue; 

    // Start : Fonction appelée une seule fois au lancement du script
    void Start()
    {
        rb = GetComponent<Rigidbody>();
    }

    // Update : Fonction appelée à chaque frame
    void Update(){
        rb.AddForce(moveValue.x, 0, moveValue.y);
    }


    // OnMoveBall : Fonction appelé à chaque fois qu'une touche liée à l'action MoveBall a été appuyée
    void OnMoveBall(InputValue value){
        Debug.Log("Move Ball Action is called");
        moveValue = value.Get<Vector2>();
        Debug.Log(moveValue);
    }
}

Debug.Log(moveValue) affiche à chaque fois la valeur du vecteur qui est reçu par la fonction. Appuyez sur une touche, puis deux touches à la fois et observez les valeurs.

Pour aller plus loin

Les lumières

Comme son nom l’indique, la lumière placée automatiquement lors de la création d’une scène est directionnelle. Vous pourrez trouver de nombreux autres types de lumière (Point Light, Spot Light, Area Light) dans GameObject >Light. Vous pouvez également modifier les propriétés de ces lumières dans la fenêtre Inspector, une fois la lumière sélectionnée.

L’Asset Store

Unity possède un asset store qui permet de télécharger des contenus gratuits ou payants afin de les intégrer à un projet.

Les contenus sont classés par catégories (3D Models, Textures and Materials, …).

Parmi les contenus, vous trouverez notamment des fichiers portant les extensions .fbx et .obj. FBX et OBJ font partie des principaux formats de fichiers de modèles 3D. Des logiciels de modélisation tels que Blender ou 3ds Max permettent de créer de tels fichiers.

Solution du TP

Téléchargez et importez le package suivant : Package TP01