TP — Les bases d’Unity 3D

Premiers pas · Création 3D

Durée

2–3 heures

Environnement

Unity 6.3 LTS · URP

Niveau

Débutant Unity

Une première initiation à Unity pour des étudiants à l’aise en informatique, sans expérience du moteur. Vous construirez une scène de cubes, ajouterez physique et interactions, naviguerez à la première personne, lancerez des objets, importerez une voiture et créerez un exécutable.

Unity 6.3 LTS (6000.3) doit être installé. La création du projet, l’installation des packages et l’import des ressources se font pendant la séance. Le temps nécessaire dépendra de votre expérience en C#.

Fichiers du TP Télécharger les ressources ↓ Texture du sol et modèle de voiture · ZIP À consulter Consignes du compte rendu ↗ Attendus et canevas du rapport

Documentation Manuel Unity 6.3 Unity Learn

Brest uniquement Configurer les PC de l’école →

Des définitions au fil du TP

Les termes soulignés en pointillés ont une définition : survolez-les ou cliquez dessus. Vous pouvez aussi les atteindre avec Tab et utiliser Entrée ou Espace ; Échap ferme l’infobulle.

Plan du TP

Préparer le projet

1. Dans Unity HubUnity HubApplication qui permet de créer et ouvrir des projets Unity et de gérer les versions de l’éditeur installées. , sélectionnez 6.3 LTS et créez un projet Universal 3D (URPURPUniversal Render Pipeline : système de rendu de Unity qui transforme la scène en images. Ses matériaux doivent utiliser des shaders compatibles URP. ). Utilisez le même patch 6000.3.xf1 pour toute la séance. Les matériauxMatériauAsset qui décrit l’apparence d’une surface en combinant un shader et ses paramètres, comme la couleur et les textures. et le contrôleur utilisés ici sont prévus pour URP.
2. Les assetsAssetRessource enregistrée dans le projet : scène, script, texture, matériau, modèle ou prefab. Elle peut être utilisée par plusieurs objets. sont les ressources de votre projet : scènes, scriptsScriptFichier de code C# du projet. Un script dérivant de MonoBehaviour peut être attaché comme composant à un GameObject. , matériaux, texturesTextureImage utilisée par un matériau pour détailler une surface : couleur, relief apparent, etc. Une texture seule ne définit pas tout le rendu. , modèles 3DModèle 3DRessource importée contenant une géométrie et éventuellement des matériaux, une hiérarchie ou des animations. et prefabsPrefabAsset servant de modèle réutilisable de GameObject, avec ses composants et enfants. Ses instances héritent des modifications du modèle, sauf leurs réglages remplacés localement. . Ils sont regroupés dans le dossier Assets, visible dans la fenêtre ProjectProjectFenêtre de l’éditeur affichant les fichiers et assets du projet. Elle se distingue de Hierarchy, qui montre les objets de la scène. . Pour les organiser, créez les sous-dossiers Scenes, Materials, Textures, Prefabs et Scripts avec clic droit dans Assets > Create > Folder ; utilisez Scenes s’il existe déjà. Dans Project, retrouvez la scène ouverte (généralement SampleScene), renommez-la UnityBasics avec Rename (ou F2), puis déplacez-la dans Assets/Scenes si nécessaire. Sauvegardez la scène avec Ctrl+S.
3. Ouvrez Window > Package Management > Package ManagerPackage ManagerFenêtre qui permet de rechercher, installer et gérer les packages et d’importer les assets de votre compte. . Dans Unity RegistryUnity RegistryCatalogue de packages publié par Unity, consultable dans le Package Manager. , recherchez Input SystemInput SystemPackage qui reçoit les entrées clavier, souris ou manette et les associe à des actions de l’application. (com.unity.inputsystem) et cliquez sur Install s’il n’est pas installé. La version utilisée lors du test du TP est 1.20.0. Dans Edit > Project Settings > Player > Other Settings > Configuration > Active Input HandlingActive Input HandlingRéglage du projet qui choisit les systèmes d’entrées activés : Input System, ancien Input Manager ou les deux. , choisissez Input System Package (New) si ce réglage n’est pas déjà sélectionné, puis acceptez le redémarrage demandé. Dans le Package Manager, sous In Project, vérifiez que Unity UIUnity UI / uGUISystème d’interface de Unity basé sur les GameObjects. Il fournit aussi l’EventSystem et les interfaces d’événements de pointeur utilisées ici. (com.unity.ugui) est installé : ce package fournit l’EventSystemEventSystemComposant qui distribue les événements d’interaction aux objets concernés, avec l’aide d’un module d’entrées et de raycasters. , le Physics RaycasterPhysics RaycasterComposant de caméra qui identifie les colliders 3D sous le pointeur et fournit ces résultats à l’EventSystem. et les interfaces de clic/survol utilisés plus loin. S’il manque, recherchez-le dans Unity Registry et installez-le.
4. Ajoutez le contrôleur officiel première/troisième personne à votre compte puis importez-le via My Assets dans le Package Manager. Acceptez l’installation de ses dépendances lorsqu’elle est proposée, puis revenez à UnityBasics.
5. Téléchargez et décompressez les ressources du TP (resources-unity63.zip). Depuis l’explorateur de fichiers, glissez grid_grey.png dans Assets/Textures dans la fenêtre Project. L’archive contient aussi Ford_Mondeo.zip : décompressez-la pour obtenir le dossier Ford_Mondeo, contenant car.obj, car.mtl et les textures .tga. Gardez ce dossier pour l’activité Charger une géométrie, où vous l’importerez en entier dans Unity.

L’éditeur d’Unity 3D

Une scène du templateTemplateModèle de départ qui crée un projet avec des packages et des réglages déjà configurés. contient généralement Main CameraCaméraObjet muni d’un composant Camera qui rend une vue de la scène. La navigation dans Scene n’est pas la même chose que cette vue de jeu. , Directional LightDirectional LightLumière qui éclaire selon une direction uniforme, comme un soleil très éloigné. et éventuellement un Global VolumeGlobal VolumeObjet qui applique des réglages de rendu, notamment des effets de post-traitement, à l’ensemble de la scène selon sa configuration. pour le rendu URP. La disposition des fenêtres peut varier.

Capture de Unity 6.3 LTS. Les repères 6 et 7 désignent les onglets GameGameFenêtre affichant l’image produite par les caméras du jeu ; on y teste les interactions de l’application. et ConsoleConsoleFenêtre affichant les logs, avertissements et erreurs, notamment les erreurs de compilation C#. ; cliquez dessus pour afficher leur contenu.

Les notions fondamentales

Avant de manipuler les objets, prenez le temps de comprendre les liens entre les ressources du projet, les objets de la scène et leurs composants. Les encarts suivants servent de repères pour toute la séance.

Sélectionnez un objet et appuyez sur F dans Scene pour le cadrer. Utilisez Move, Rotate et Scale (W, E, R, hors saisie de texte). Maintenez le bouton droit pour regarder autour de vous dans Scene ; les touches de déplacement permettent alors de naviguer. Local/GlobalLocal / GlobalLocal utilise les axes propres à l’objet ; Global utilise les axes du monde. Les coordonnées d’un enfant peuvent aussi être exprimées relativement à son parent. choisit le repère de manipulation. Consultez la navigation et le positionnement.

Créer une scène simple

Nous allons créer un sol et une pile de douze cubes bleus.

1. Ajoutez GameObject > 3D Object > Plane, nommé Ground, en position (0, 0, 0), rotation (0, 0, 0), échelle (10, 1, 10). Le plan mesure 10 × 10 unités à l’échelle 1 : vous obtenez ici 100 × 100 unités. Une unité représente environ un mètre ; le plan reste fini.

2. Ajoutez un cube Cube, d’échelle (1, 1, 1), en position (0, 3, 0).

3. Créez CubeBlue dans Assets/Materials (Assets > Create > Material). Choisissez le shaderShaderProgramme qui calcule l’apparence d’une surface. Le matériau choisit le shader et fournit ses paramètres et textures. Universal Render Pipeline/LitURP LitShader standard d’URP qui calcule un matériau éclairé à partir de la couleur, des textures et des propriétés de surface. et une couleur bleue dans Base MapBase MapTexture et couleur de base d’un matériau URP Lit. Elles sont combinées pour déterminer sa couleur de surface. . Glissez le matériau sur le cube.

4. Créez GroundGrid, également en URP Lit, puis glissez grid_grey.png dans sa Base Map. Assignez ce matériau au plan. Cliquez sur la texture grid_grey.png dans la fenêtre Project : ses paramètres d’import apparaissent dans l’Inspector. Vérifiez que Wrap ModeWrap ModeRéglage d’une texture qui détermine ce qui se passe hors de ses coordonnées normales. Repeat répète l’image. = Repeat ; ce réglage est normalement déjà sélectionné. Si vous le modifiez, cliquez sur Apply. Essayez un TilingTilingParamètre de matériau qui règle combien de fois la texture se répète sur la surface. = (100, 100) sur le matériau et ajustez-le. Un matériau décrit l’apparence ; une texture est une image utilisée par le matériau.

5. Placez la caméra, par exemple en position (8, 6, -12) et rotation (20, -30, 0). Ajustez le cadrage dans Game pour voir le sol et le cube. Conservez le tagTagÉtiquette attribuée à un GameObject pour l’identifier depuis les scripts. Par exemple, Camera.main trouve une caméra active portant MainCamera. MainCamera.

6. Ajoutez un RigidbodyRigidbodyComposant qui permet au moteur physique de simuler le mouvement d’un objet : gravité, forces et collisions. au cube avec Add Component. Gardez Use GravityUse GravityOption d’un Rigidbody qui active l’effet de la gravité sur ce corps. activé et Is KinematicIs KinematicQuand cette option est active, le Rigidbody est piloté par le code ou l’animation plutôt que par les forces de la simulation. désactivé. Le cube possède déjà un Box ColliderBox ColliderCollider en forme de boîte, simple et peu coûteux pour représenter un cube ou une partie d’objet. ; le plan possède un colliderColliderComposant définissant une forme de collision. Il peut détecter les contacts sans afficher de géométrie. . Lancez la scène : le cube tombe et reste sur le sol. Le RendererRendererComposant qui affiche une géométrie et utilise ses matériaux pour déterminer son apparence. affiche l’objet, le Collider définit sa forme de collision, le Rigidbody permet sa simulation physique.

7. Arrêtez Play. Glissez le cube de Hierarchy vers Assets/Prefabs et nommez l’asset CubePrefab. Créez au total douze instances, disposées en deux colonnes de six cubes qui se rapprochent vers le haut, comme sur l’image ci-dessous. Gardez une échelle (1, 1, 1), une rotation (0, 0, 0) et Z 0 pour tous les cubes.

Astuce — pour manipuler beaucoup d’objets : la duplication avec Ctrl+D (Cmd+D sur macOS), la sélection multiple et les expressions numériques de l’Inspector, comme L(a,b) pour répartir des objets régulièrement peuvent faire gagner du temps. Pour les douze cubes de ce TP, placez simplement les instances pour reproduire la forme de l’image.

8. Testez la pile. Ouvrez CubePrefab en double-cliquant et changez sa MassMassMasse du Rigidbody. Elle influence la réponse aux forces et impulsions, sans rendre la chute libre plus rapide à elle seule. , puis sa Linear DampingLinear DampingAmortissement qui réduit progressivement la vitesse linéaire du Rigidbody. Il se distingue du frottement entre surfaces. . Angular DampingAngular DampingAmortissement qui réduit progressivement la vitesse de rotation du Rigidbody. freine la rotation. Comparez les instances, puis remettez Mass à 1 et Linear Damping à 0.

À observer : sans amortissement, une masse supérieure ne rend pas la chute plus rapide. Elle change la réponse à une même impulsion, que vous testerez ensuite. Le frottement au contact se règle avec un Physics MaterialPhysics MaterialAsset qui règle le frottement et le rebond des colliders. Il ne définit pas la couleur visible de l’objet. sur le Collider et se distingue de l’amortissement. Les valeurs modifiées seulement sur une instance peuvent être des overridesOverride de prefabModification propre à une instance de prefab qui remplace un réglage hérité du modèle. : vérifiez-les si une modification du prefab ne se propage pas.

Animer un objet de la scène

Un script C# dérivant de MonoBehaviourMonoBehaviourClasse de base des scripts attachables aux GameObjects. Unity appelle ses méthodes de cycle de vie, telles que Update. devient un composant. Nous allons créer un script qui fait simplement tourner les cubes sur eux-mêmes.

Écrire RotateCube

1. Dans Assets/Scripts, créez Assets > Create > Scripting > MonoBehaviour Script, nommé RotateCube. Ouvrez-le dans votre éditeur C# ; le nom de classe doit correspondre au fichier.

2. Déclarez speed comme un attribut de la classe RotateCube (appelé champ en C#). Placez cette déclaration dans les accolades de la classe, mais en dehors des méthodes comme Start() et Update(). Ce champ stocke la vitesse de rotation du composant ; ce n’est pas une variable locale à une méthode. L’annotation SerializeFieldSerializeFieldAttribut C# qui permet à Unity d’enregistrer un champ privé et de l’afficher dans l’Inspector. permet de l’exposer dans l’Inspector.

[SerializeField] private float speed = 90f; // degrés par seconde

3. Dans Update()UpdateMéthode d’un MonoBehaviour appelée une fois par image lorsque le composant est actif. , appelé une fois par image, utilisez :

transform.Rotate(Vector3.up, speed * Time.deltaTime, Space.Self);

Time.deltaTimeTime.deltaTimeDurée de l’image précédente, en secondes. Multiplier une vitesse par cette durée donne le déplacement ou la rotation pour l’image courante. est le temps écoulé depuis l’image précédente : la vitesse ne dépend ainsi pas du nombre d’images par seconde. Une rotation de 3° par image donnerait des vitesses différentes selon la machine.

4. Testez sur un seul cube. Sélectionnez une instance dans Hierarchy. Glissez RotateCube.cs depuis Project sur ce cube ou dans son Inspector ; vous pouvez aussi cliquer sur Add Component, rechercher RotateCube et le sélectionner. Vérifiez que le composant apparaît dans l’Inspector. Lancez Play : seul ce cube tourne, car transform désigne le GameObject auquel le script est attaché.
5. Étendez le comportement aux autres cubes. Arrêtez Play. L’ajout du composant sur cette instance est un override. Dans Overrides, en haut de son Inspector, sélectionnez l’ajout de RotateCube et appliquez-le au prefab avec Apply. Le modèle CubePrefab possède maintenant ce composant, et les autres instances en héritent. Lancez Play pour observer la rotation de tous les cubes.
6. Autre méthode : modifier directement le modèle. Vous pouvez aussi ouvrir CubePrefab depuis Project et lui ajouter RotateCube avec le même glisser-déposer ou Add Component. Pour faire tourner seulement quelques cubes, ajoutez plutôt le script aux instances choisies sans appliquer cet ajout au prefab. Ajoutez-le une seule fois par cube, pour éviter que deux composants RotateCube cumulent leurs rotations.
7. Testez plusieurs vitesses dans l’Inspector. Puis, hors Play, remplacez temporairement la déclaration par public float speed = 90f;, puis par private float speed = 90f;. Enregistrez et laissez Unity compiler à chaque fois : Speed apparaît-il encore dans l’Inspector ? Terminez en remettant [SerializeField] private float speed = 90f;.

Vérification : les cubes tournent sur eux-mêmes et la vitesse se règle dans l’Inspector sans éditer le script.

Gestion des interactions

Complétez Assets/Scripts/RotateCube.cs pour que le cube soit immobile au démarrage et que chaque appui sur R démarre ou arrête sa rotation.

1. Importer l’Input System. Ajoutez using UnityEngine.InputSystem; en haut du fichier, en conservant using UnityEngine;.
2. Déclarer l’action. Dans la classe, à côté de speed et en dehors des méthodes, ajoutez un champ privé activateRotation de type InputActionInput ActionAction logique, comme sauter ou tourner, liée à des contrôles d’entrée. Elle peut être lue ou déclencher des callbacks. , exposé avec [SerializeField]. Initialisez-le avec new InputAction(...) et ces trois arguments, dans cet ordre : le nom "ActivateRotation", le type InputActionType.Button et le bindingBindingAssociation entre une action et un contrôle, par exemple la touche R ou le bouton droit de la souris. "<Keyboard>/r".
3. Mémoriser l’état de la rotation. Ajoutez un champ privé rotating de type bool, initialisé à false. Il indique si le cube doit tourner ; il n’a pas besoin d’être exposé dans l’Inspector. Conservez le champ speed déjà créé.
4. Écrire la méthode de basculement. Ajoutez une méthode privée ToggleRotation, qui retourne void et reçoit un paramètre InputAction.CallbackContext context. Dans son corps, affectez à rotating l’inverse de sa valeur actuelle avec l’opérateur ! : false devient true, et inversement. Le paramètre context est fourni par l’Input System ; vous n’avez pas à l’utiliser ici.
5. Faire l’abonnement dans Start(). Abonnez ToggleRotation à l’événement performed de activateRotation avec +=, en écrivant le nom de la méthode sans parenthèses. Cet abonnement indique quelle méthode appeler lorsque l’action se déclenche.

6. Activer l’action dans Start(). Après l’abonnement, appelez Enable() sur activateRotation. Cette seconde instruction permet à l’action de recevoir les entrées : l’abonnement seul ne suffit pas.
7. Conditionner la rotation dans Update(). Gardez l’instruction transform.Rotate(...) de l’exercice précédent, mais placez-la dans un if qui vérifie rotating. Le cube tourne alors uniquement lorsque ce booléen vaut true.
8. Vérifier dans Unity. Enregistrez, attendez la compilation et inspectez le composant RotateCube : l’action doit être de type Button, liée à R. Ces réglages sont les valeurs initiales proposées par le code. Comme pour Speed, vous pouvez les modifier dans l’Inspector ; sur une instance de prefab, cela crée un override. Pour ce test, gardez R et le comportement d’appui par défaut.

Vérification : cliquez dans Game après avoir lancé Play. Les cubes sont immobiles au départ ; un appui sur R les fait tourner, relâcher R ne change rien, et un nouvel appui les arrête.

Documentation des actions.

Programmation d’interaction simple avec la souris

Nous allons rendre chaque cube rouge lorsque la souris le survole, lui rendre sa couleur initiale lorsque la souris s’en éloigne et le pousser au clic gauche.

Pour détecter ces interactions, nous allons ajouter un EventSystem à la scène et un Physics Raycaster à la caméra. Le premier transmet les événements de la souris ; le second détermine quel objet est sous le pointeur en utilisant ses colliders. Notre script MouseInteraction recevra alors ces événements dans trois méthodes : OnPointerEnter pour le début du survol, OnPointerExit pour sa fin et OnPointerClick pour le clic.

1. Ajoutez GameObject > UI > Event System si la scène n’en possède pas. Gardez un seul EventSystem actif. Son module doit être Input System UI Input ModuleInput System UI Input ModuleModule qui traduit les actions de l’Input System en événements distribués par l’EventSystem. : remplacez Standalone Input Module si présent. Utilisez Assign Default Actions si les références d’actions UI sont vides.
2. Ajoutez Physics Raycaster via Add Component sur la caméra active portant le tag MainCamera. Les cubes doivent avoir leurs colliders et appartenir à un layerLayerCatégorie attribuée aux GameObjects pour filtrer notamment le rendu, les collisions et les raycasts. Un masque sélectionne plusieurs layers. inclus dans le masque du raycaster.
3. Créez un nouveau script MouseInteraction.cs dans Assets/Scripts et complétez-le dans les étapes suivantes. Importez UnityEngine.EventSystems et implémentez les trois interfaces IPointerClickHandler, IPointerEnterHandler et IPointerExitHandler. Les méthodes à définir sont OnPointerClick, OnPointerEnter et OnPointerExit, chacune publique, retournant void et recevant PointerEventData eventData.

4. Préparer le composant. Laissez d’abord les trois méthodes d’interaction vides, enregistrez et vérifiez que le script compile. Ajoutez MouseInteraction à CubePrefab pour que chaque cube possède ce comportement. Toutes les modifications ci-dessous se font dans MouseInteraction.cs. Vous n’avez rien à mettre dans Update() : les méthodes d’interaction seront appelées lors des événements de souris.
5. Mémoriser la couleur de départ. Déclarez un champ privé initialColor, de type Color, dans la classe, en dehors des méthodes. Dans Start(), récupérez le Renderer du cube avec gameObject. suivi de GetComponentGetComponentMéthode qui cherche un composant du type demandé sur le même GameObject. GetComponentInChildren cherche aussi dans ses enfants. <Renderer>(). Accédez ensuite à sa propriété material.color et enregistrez cette couleur dans initialColor. Chaque cube mémorise ainsi sa propre couleur au démarrage.
6. Rendre le cube rouge au survol. Dans OnPointerEnter, récupérez le Renderer de la même façon et affectez Color.red à sa propriété material.color. Test : enregistrez, lancez Play et passez la souris sur un cube dans Game : seul ce cube doit devenir rouge.
7. Restaurer la couleur à la sortie. Dans OnPointerExit, affectez cette fois initialColor à la même propriété material.color. Test : éloignez la souris du cube : il doit retrouver sa couleur de départ. Utilisez bien material, qui permet de modifier l’apparence de ce cube individuellement.
8. Pousser le cube au clic gauche. Dans OnPointerClick, ajoutez un if qui compare eventData.button à PointerEventData.InputButton.Left. À l’intérieur, récupérez le Rigidbody avec gameObject.GetComponent<Rigidbody>(), puis appelez sa méthode AddForce avec deux arguments : la direction Camera.mainCamera.mainRéférence obtenue vers une caméra active portant le tag MainCamera. Ce n’est pas le Transform cible de Cinemachine. .transform.forward multipliée par 5f, et le mode ForceMode.ImpulseForceMode.ImpulseMode d’application d’une poussée instantanée au Rigidbody, dont l’effet dépend de sa masse. pour une poussée ponctuelle. Test : le clic gauche pousse le cube dans la direction du regard de la caméra ; le clic droit ne le pousse pas.

Vérification : seul le cube survolé devient rouge ; le clic gauche le pousse, le clic droit ne le pousse pas. MonoBehaviour et son cycle de vie.

Navigation en réutilisant des scripts d’interaction clavier/souris

Intégrez un contrôleur première personne à votre scène avec le package officiel First Person + Third Person | Character Controllers. Il fournit les scripts nécessaires pour déplacer le personnage au clavier et regarder autour de lui avec la souris.

1. Après l’import via Package Manager > My Assets, ouvrez dans Project Assets/Starter Assets/Sample/FirstPersonController/Playground.unity, la scène de démonstration première personne, et testez-la. Relevez les bindings de déplacement, saut, sprint et regard dans l’Input Actions asset : les touches dépendent de sa configuration et du clavier.
2. Identifiez le personnage avec CharacterControllerCharacterControllerComposant de déplacement de personnage avec une forme de capsule et une gestion des collisions, piloté par un script plutôt que par les forces d’un Rigidbody. , la caméra de rendu avec Camera / AudioListenerAudioListenerComposant représentant le point d’écoute du son dans la scène, généralement placé sur la caméra active. / Cinemachine BrainCinemachinePackage qui pilote des caméras : suivi d’une cible, cadrage et transitions. La caméra Unity conserve le rôle de produire l’image. , et la Cinemachine Camera pilotant le suivi. La cible de suivi (par exemple PlayerCameraRoot) est un Transform ; ce n’est pas nécessairement la caméra de rendu.
3. Dans Hierarchy, sélectionnez ensemble MainCamera, PlayerFollowCamera, PlayerCapsule, UI_EventSystem et UI_TouchScreenInput, encadrés sur la capture ci-dessous, puis copiez-les. Ouvrez UnityBasics, la scène du TP, puis collez-les. Copiez ces objets ensemble pour conserver les références du rigRig de caméra/personnageEnsemble d’objets et de composants reliés qui assurent le déplacement du personnage et le suivi de caméra. première personne.

4. Retirez les doublons après le collage. Désactivez le GameObject de l’ancienne caméra fixe de UnityBasics et conservez la MainCamera copiée. Supprimez l’EventSystem créé dans la partie précédente et conservez UI_EventSystem copié. Il doit rester un seul EventSystem actif, une seule caméra de rendu active portant MainCamera et un seul AudioListener actif. Gardez également PlayerFollowCamera, qui pilote la caméra de rendu via Cinemachine. Placez le personnage près de la pile, par exemple X 0, Z -8, avec son bas juste au-dessus du sol.
5. Tester la navigation et constater ce qui a changé. Vérifiez que le layer de Ground est inclus dans le masque de sol du contrôleur. Lancez Play et cliquez dans Game : testez déplacements, regard, saut et sprint. Le personnage fonctionne, mais le survol rouge et le clic sur les cubes ne fonctionnent plus comme avant : le curseur est verrouillé et la nouvelle caméra n’a pas encore de raycaster. Si le contrôleur produit des sons de pas ou de saut, repérez-les également.
6. Rétablir les interactions au centre de l’écran. Arrêtez Play. Ajoutez Physics Raycaster à la MainCamera copiée. Sélectionnez UI_EventSystem et, dans son composant Input System UI Input Module, ouvrez Advanced, puis choisissez Cursor Lock Behavior = Screen Center. Relancez Play en gardant le curseur verrouillé et le regard à la souris : le cube visé au centre de l’écran devient rouge et le clic gauche le pousse. Le Physics Raycaster détecte maintenant l’objet devant vous, au centre de l’image.
7. Retrouver une souris libre. Arrêtez Play. Sur PlayerCapsule, dans le composant qui gère les entrées du contrôleur (Starter Assets Inputs), décochez Cursor Locked et Cursor Input For Look. Relancez Play : la souris est visible, ses mouvements ne tournent plus la tête et vous pouvez survoler et cliquer sur les cubes avec le pointeur, comme dans la partie précédente. Le réglage Screen Center n’impose le centre de l’écran que lorsque le curseur est verrouillé.

Configuration de Cursor Lock Behavior.

Création dynamique d’objets

InstantiateInstantiateFonction Unity qui crée une nouvelle instance d’un objet ou d’un prefab pendant l’exécution. crée une copie d’un GameObject ou d’un composant et de son objet. Un prefab permet de créer des objets sans modèle caché dans la scène. Nous allons lancer des cubes jaunes vers l’avant au clic droit.

1. Créez un cube Projectile, de taille (0.25, 0.25, 0.25), avec un matériau URP Lit jaune, Box Collider et Rigidbody, masse 1, gravité activée, Is Kinematic désactivé. Faites-en ProjectilePrefab, puis supprimez l’instance de la scène. Il ne porte pas RotateCube ni MouseInteraction, afin de ne pas recopier les actions et comportements des cibles.
2. Dans Assets/Scripts, créez un nouveau script CreateOnClick.cs et ajoutez-le à la caméra portant réellement Camera, pas à la cible Cinemachine. Complétez ce script dans les étapes suivantes. Déclarez [SerializeField] private Rigidbody projectilePrefab; et glissez ProjectilePrefab dans ce champ : cette référence donne directement accès à la physique.
3. Importez UnityEngine.InputSystem et déclarez une InputAction nommée fire, de type Button, liée à <Mouse>/rightButton. Activez-la dans Start() comme précédemment. Ici, au lieu de vous abonner à performed, interrogez l’action dans Update() avec fire.WasPressedThisFrame() : cette méthode renvoie true seulement pour l’image où le bouton vient d’être pressé.
4. Calculer la position de départ. Dans Update(), placez les opérations suivantes dans un if qui vérifie l’appui détecté au point 3. Déclarez une variable locale position de type Vector3 : partez de la position de la caméra (transform.position) et ajoutez sa direction avant (transform.forward) multipliée par 2f. Le projectile apparaîtra ainsi deux unités devant elle.
5. Créer le projectile. Appelez Instantiate avec trois arguments : projectilePrefab, la position calculée et la rotation de la caméra (transform.rotation). Stockez le résultat dans une variable locale projectile de type Rigidbody pour pouvoir agir sur cette nouvelle instance.
6. Lancer le projectile. Comme pour la poussée des cubes, appelez AddForce sur le Rigidbody créé. Utilisez la direction avant de la caméra multipliée par 12f, avec ForceMode.Impulse.
7. Supprimer le projectile après un délai. Appelez Destroy avec le GameObject de l’instance (projectile.gameObject) et un délai de 8f secondes. Gardez cet appel dans le même if : chaque projectile aura ainsi sa propre durée de vie.

Le jaune vient du matériau du prefab ; vous pouvez aussi changer la couleur du Renderer de l’instance. La position devant le joueur évite de créer le projectile à l’intérieur du personnage. Vérifiez également un espace libre devant la caméra : 2 unités ne garantissent pas d’éviter un mur proche.

À observer : comparez trajectoires et poussées en modifiant masse et impulsion. Une impulsion est appliquée une seule fois ; une force continue serait appliquée au rythme de la simulation dans FixedUpdateFixedUpdateMéthode appelée au rythme fixe de la simulation physique, indépendamment du nombre d’images affichées. . Destroy retire l’objet, ici après huit secondes. Instantiate, AddForce.

Charger une géométrie

Importez la Ford Mondeo, rendez ses vitres transparentes et définissez ses collisions.

1. Décompressez Ford_Mondeo.zip depuis les ressources du TP. Le fichier car.obj contient le maillageMeshGéométrie d’un objet 3D, décrite par des sommets et des faces. Le mesh visible et la forme de collision peuvent être différents. de la voiture et les fichiers .tga sont ses textures.
2. Dans Project, créez le dossier Assets/Models (clic droit dans Assets > Create > Folder). Depuis l’explorateur de fichiers, glissez tout le dossier décompressé Ford_Mondeo dans Assets/Models dans Project. Attendez la fin de l’import, puis glissez car.obj de Project vers Hierarchy pour créer une instance dans la scène. Sélectionnez cette instance et réglez son Transform > Scale à (0.01, 0.01, 0.01) comme point de départ. Vérifiez sa taille en la comparant aux cubes d’un mètre, puis ajustez si nécessaire sa taille, sa rotation et sa position. Les textures des Base Maps sont normalement déjà assignées.
3. Extraire les matériaux pour les modifier. Sélectionnez l’asset car.obj dans Project, puis ouvrez l’onglet Materials de ses Import Settings dans l’Inspector. Les matériaux sont inclus dans le modèle : cliquez sur Extract Materials… et choisissez un dossier, par exemple Assets/Materials/Car. Ils deviennent des assets de matériau que vous pouvez modifier.
4. Rendre les vitres transparentes. Repérez le matériau utilisé par les vitres et sélectionnez le matériau extrait dans Project. Dans son Inspector, avec le shader Universal Render Pipeline/Lit, choisissez Surface Type = Transparent et Blending Mode = Alpha. Ouvrez la couleur de Base Map, puis diminuez sa valeur alpha (A)AlphaComposante qui décrit l’opacité : 0 signifie transparent et 1 opaque. Le shader doit aussi être configuré pour la transparence. , par exemple à 0.3. Observez la transparence des vitres dans la scène.
5. Lancez des cubes sur la voiture et essayez de marcher à travers. Un mesh visible ne fournit pas automatiquement un collider. Ajoutez des Box Colliders pour une approximation simple ou des Mesh CollidersMesh ColliderCollider utilisant un mesh comme forme de collision. Les formes non convexes sont adaptées aux décors fixes ; les corps dynamiques demandent d’autres choix. sur les parties pertinentes de la voiture immobile.

Un Mesh Collider non convexeCollider convexeForme de collision sans creux. Unity impose des contraintes aux Mesh Colliders des corps dynamiques ; une approximation convexe est un choix possible. convient à un décor fixe, sans Rigidbody dynamique. Pour une voiture physique mobile, privilégiez des colliders primitifs assemblés ou des Mesh Colliders convexes, avec un Rigidbody sur la racine. Des collisions plus détaillées peuvent coûter plus de calcul. Mesh Colliders, URP Lit.

Vérification : échelle plausible, textures visibles, vitres transparentes, collisions avec le personnage et les projectiles.

Créer un exécutable pour la scène

1. Arrêtez Play et sauvegardez UnityBasics.
2. Ouvrez File > Build ProfilesBuild ProfilesConfigurations d’export qui regroupent la plateforme cible et les réglages utilisés pour construire l’application. . Choisissez Linux, Windows ou macOS selon la machine, puis créez/activez son profil si nécessaire. Le module de build correspondant doit être installé via Unity Hub.
3. Dans Scene ListScene ListListe des scènes incluses dans le build ; la première scène activée est normalement celle chargée au démarrage. , ajoutez la scène avec Add Open Scenes. Vérifiez qu’elle est cochée et en premier ; retirez les scènes de démonstration. Un profil peut remplacer la liste partagée : vérifiez celle effectivement utilisée.
4. Cliquez sur BuildBuildApplication produite à partir du projet pour une plateforme cible. Elle peut fonctionner sans l’éditeur Unity. , choisissez un dossier dédié hors de Assets, par exemple Builds/Linux, puis lancez l’application. Build And Run l’exécute immédiatement.
5. Testez navigation, R, clics, physique et matériaux hors de l’éditeur. Distribuez le dossier complet du build. Explorez Player SettingsPlayer SettingsRéglages de l’application exportée, comme son nom, sa résolution et les options de la plateforme. > Resolution and Presentation pour la résolution et le plein écran.

La plateforme Web permet également un build pour navigateur avec son module. Il nécessite un serveur HTTP : ouvrir directement le HTML ne suffit pas. Pour cette séance, commencez par le build local. Build Profiles.

Pour aller plus loin

Choisissez une piste pour enrichir la scène que vous venez de construire. Les variations proposées dans le TP — maintenir R, pousser pendant l’appui et changer de mode de souris — constituent un premier prolongement.

• Personnaliser les tirs. Exposez l’impulsion, la durée de vie et la distance de création du projectile dans l’Inspector avec [SerializeField]. Comparez plusieurs réglages sans modifier le code.
• Créer un petit parcours. Réutilisez vos prefabs pour placer des obstacles et des cibles. Utilisez les layers pour choisir quels objets peuvent entrer en collision ou être visés.
• Donner une ambiance à la scène. Modifiez la skyboxSkyboxFond qui représente l’environnement lointain de la scène, souvent le ciel. et l’éclairage dans Window > Rendering > Lighting. Pour approfondir, étudiez les objets Static et l’éclairage précalculéÉclairage bakedÉclairage calculé à l’avance et enregistré dans des ressources, plutôt que recalculé entièrement pendant l’exécution. : ne marquez pas les cubes mobiles comme statiques. Éclairage baked.
• Ajouter un effet visuel. Créez de la fumée avec un Particle SystemParticle SystemComposant qui anime de nombreuses petites particules pour représenter fumée, feu ou autres effets. , puis réglez son émission et sa durée de vie. Documentation. Explorez ensuite Visual Effect Graph ou des matériaux personnalisés avec Shader GraphShader GraphOutil visuel pour créer des shaders en reliant des nœuds au lieu d’écrire tout le code du shader. pour URP.
• Animer un élément du décor. Faites ouvrir une porte avec Animation et AnimatorAnimatorComposant qui contrôle la lecture et les transitions des animations à partir d’un Animator Controller. . Pour des événements différés, explorez les coroutinesCoroutineMéthode pouvant suspendre son exécution avec yield puis reprendre plus tard, par exemple après un délai. . Animation, coroutines.
• Afficher une information à l’écran. Ajoutez une interface indiquant le nombre de projectiles créés. Choisissez Unity UI ou UI Toolkit en vous aidant de la comparaison des systèmes d’interface.

Pour un projet ultérieur, vous pouvez aussi importer un personnage Humanoid et ses animations, étudier l’Inverse Kinematics, comparer un contrôleur personnalisé fondé sur CharacterController ou Rigidbody, ou rendre une voiture pilotable avec WheelCollider. Ces sujets demandent davantage de temps : Avatar, IK, véhicules.

Pour renforcer vos scripts, explorez RequireComponentRequireComponentAttribut C# déclarant les composants nécessaires à un script pour aider Unity à les ajouter lors de son attachement. , la vérification des références et la gestion des abonnements lorsqu’un composant est désactivé ou détruit.

Ressources

Pour comprendre et programmer :

Pour enrichir la scène : ambientCG pour les textures et matériaux, Poly Haven pour les HDRI, textures et modèles, et Mixamo pour les personnages et animations. Avant d’importer un asset, vérifiez ses conditions d’utilisation et, pour un package Unity, sa compatibilité avec Unity 6.3 / URP.

Pour poursuivre après ce TP : Une première application de réalité virtuelle reprend les bases acquises ici pour découvrir le suivi du casque, les contrôleurs, la téléportation et la manipulation avec OpenXR et XR Interaction Toolkit.

En cas de blocage

Commencez par Console : corrigez la première erreur rouge avant de tester à nouveau. Double-cliquez sur le message pour ouvrir la ligne concernée. Si vous demandez de l’aide, indiquez l’étape du TP, le résultat attendu et le message exact.