Computer Graphics | Étienne Peillard

TP — Rendu 3D : diorama stylisé

Mon, 09 Feb 2026 00:00:00 +0000

🎯 Objectif du TP

Réaliser une scène type diorama (petit monde en miniature) sous Unity avec l’URP, en travaillant :

la composition visuelle (mise en scène, lisibilité, point focal),
le rendu (lumières, matériaux, post-processing),
et une première dimension tech-art (Shader Graph et/ou VFX).

Le rendu final doit être cohérent visuellement : même si vous utilisez des assets externes, vous devrez harmoniser leurs matériaux et l’ambiance lumineuse.

📌 Contraintes obligatoires (socle commun)

Votre scène doit impérativement inclure les éléments suivants :

1) Composition / environnement

Une scène lisible de type diorama (miniature, cadre clair, point focal).
Vous pouvez utiliser des assets gratuits (Asset Store, Kenney, Poly Pizza, etc.),
mais vous devez modifier les matériaux pour assurer une cohérence visuelle.

2) Lumières

Au minimum 3 sources lumineuses distinctes, par exemple :
- Directional Light (soleil),
- Spot Light (mise en valeur d’un objet),
- Point Light (ambiance locale).
Attendu : une intention claire (ambiance chaude/froide, contrastes, hiérarchie visuelle).

3) Skybox / environnement

Une Skybox (HDRI ou procédurale).
Réglages d’environnement (Ambient Light, Reflections).

4) Effets visuels

Au moins 1 Particle System (Shuriken) intégré à la scène
(fumée, poussière, neige, lucioles, étincelles, bulles…).
Au moins 1 Volume URP de post-processing, avec au minimum :
- Bloom ou
- Color Adjustments.

5) Matériaux et shaders

Utiliser au moins un Material standard URP (Lit).
- Vous pouvez ici utiliser les différentes map de textures (albedo, normal, metallic, etc.) pour enrichir le rendu.
Créer au moins un Shader personnalisé avec Shader Graph, et l’appliquer à un objet de la scène.

🧩 Options à la carte

Ces options permettent d’aller plus loin selon votre niveau et votre créativité.

A — Lighting avancé (recommandé)

Lighting Baked ou Mixed.
Utilisation de Light Probes et/ou Reflection Probes pour améliorer le rendu.

B — VFX Graph (ou particules avancées)

Un effet avec VFX Graph (si compatible avec votre version Unity),
ou un Particle System avancé (collision, noise, trails, forces).

C — Cinématique (Timeline)

Une mini-cinématique de 5 à 10 secondes :
- mouvement de caméra,
- reveal du point focal,
- variation de lumière ou d’effet.

D — Modélisation in-editor (ProBuilder)

Créer au moins deux éléments de décor avec ProBuilder
(socle, rocher stylisé, arche, mur, pont, plateforme…).

E — Interaction simple

Implémenter une interaction basique, par exemple :

bascule jour/nuit,
changement de palette de couleurs,
activation/désactivation de particules,
ouverture de porte,
allumage d’une lanterne.

F — Ambiance sonore

Ajouter :
- une ambiance sonore (vent, forêt, mer, usine, ville…),
- au moins un effet sonore localisé en 3D.

🎨 Idées de thèmes (au choix)

Pour éviter des scènes trop similaires, vous pouvez vous inspirer de ces pistes :

Atelier miniature (horloger, alchimiste, bricoleur).
Ruines dans une bulle (temple, statues, végétation).
Station de métro miniature (néons, fumée, reflets).
Cabane enneigée (neige + lumière intérieure chaude).
Fond marin stylisé (bulles, caustiques simulées, particules).

Vous pouvez aussi proposer votre propre thème, tant qu’il respecte l’esprit diorama.

📦 Livrables attendus

1) Projet Unity

Scène principale nommée : Diorama.unity
Projet fonctionnel en URP.

2) README (1 page max)

À inclure dans le projet (Markdown ou PDF) :

Titre et thème du diorama,
Liste des 5 contraintes obligatoires (cochées),
Liste des 3 options choisies (avec courte justification),
Sources des assets utilisés (liens + licences).

3) Image ou vidéo de présentation

un plan fixe “beau rendu”,
un bref mouvement de caméra (pan, rotation, ou travelling).

🧮 Barème indicatif

Critère	Pondération
Composition & direction artistique	30 %
Cohérence des matériaux	25 %
Lighting, Skybox & Post-process	20 %
Shader Graph (qualité + intégration)	15 %
Options choisies (pertinence)	10 %

Bonus : polish général (petites animations, détails, optimisation simple).

📚 Ressources utiles

Assets gratuits

3d textures: https://3dtextures.me
Kenney (CC0) : https://kenney.nl
Poly Pizza : https://poly.pizza
Poly Haven (HDRI Skyboxes) : https://polyhaven.com
Unity Asset Store (Top Free) : https://assetstore.unity.com/top-assets/top-free

TP — Les bases d’Unity 3D

Mon, 02 Feb 2026 00:00:00 +0000

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

Dans , sélectionnez 6.3 LTS et créez un projet Universal 3D ( ). Utilisez le même patch 6000.3.xf1 pour toute la séance. Les et le contrôleur utilisés ici sont prévus pour URP.
Les sont les ressources de votre projet : scènes, , matériaux, , et . Ils sont regroupés dans le dossier Assets, visible dans la fenêtre . 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.
Ouvrez Window > Package Management > . Dans , recherchez (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 > , 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 (com.unity.ugui) est installé : ce package fournit l’ , le et les interfaces de clic/survol utilisés plus loin. S’il manque, recherchez-le dans Unity Registry et installez-le.
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.
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 contient généralement , et éventuellement un 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 et ; cliquez dessus pour afficher leur contenu.

Repère	Fenêtre	Rôle
1		Naviguer et manipuler les objets de la scène.
2		Voir les et leurs relations parent/enfant.
3		Voir et modifier tous les , y compris les scripts.
4	Project	Voir les assets : scènes, textures, matériaux, prefabs, scripts…
5	/ Pause / Step	Exécuter, suspendre et avancer image par image.
6	Game	Voir le résultat rendu par la caméra.
7	Console	Lire les messages, avertissements et erreurs.

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. 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.

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.
Ajoutez un cube Cube, d’échelle (1, 1, 1), en position (0, 3, 0).

Notion essentielle

Matériau, shader et texture : trois rôles différents

Le Mesh définit la géométrie. Le Renderer l’affiche avec un ou plusieurs matériaux. Un matériau est un asset : il choisit un shader et lui fournit des paramètres, comme une couleur et des textures.

Le shader calcule l’apparence de la surface ; une texture est une image utilisée dans ce calcul. Plusieurs matériaux peuvent utiliser la même texture, et plusieurs objets peuvent partager un matériau.

Dans ce TP : CubeBlue utilise le shader URP Lit et une couleur bleue ; GroundGrid utilise aussi une texture dans Base Map. Le matériau doit employer un shader compatible avec le pipeline URP du projet.
Créez CubeBlue dans Assets/Materials (Assets > Create > Material). Choisissez le et une couleur bleue dans . Glissez le matériau sur le cube.
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 = Repeat ; ce réglage est normalement déjà sélectionné. Si vous le modifiez, cliquez sur Apply. Essayez un = (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.

Notion essentielle

Le tag : identifier un objet dans les scripts

Un tag est une étiquette attribuée à un GameObject, distincte de son nom. Un script peut chercher un objet portant un tag précis. Chaque GameObject possède un tag ; plusieurs objets peuvent partager le même.

Dans ce TP : le tag MainCamera permettra à Camera.main de retrouver la caméra active. Nommer un objet « Main Camera » ne suffit pas : vérifiez aussi son champ Tag dans l’Inspector.
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 MainCamera.

Ajoutez un au cube avec Add Component. Gardez activé et désactivé. Le cube possède déjà un ; le plan possède un . Lancez la scène : le cube tombe et reste sur le sol. Le affiche l’objet, le Collider définit sa forme de collision, le Rigidbody permet sa simulation physique.
Notion essentielle

Le prefab : réutiliser un objet et garder le lien
Un prefab est un asset qui enregistre un GameObject, ses composants et ses enfants. Chaque exemplaire placé dans la scène est une instance liée au modèle. Ici, les douze cubes partageront CubePrefab.

Deux façons de modifier le modèle, hors Play :
- Depuis Project : sélectionnez CubePrefab pour régler ses paramètres dans l’Inspector, ou double-cliquez dessus pour modifier sa structure en Prefab Mode.
- Depuis une instance : changez, par exemple, la Mass d’un cube. Ce changement est un override local. Dans Overrides, en haut de l’Inspector, utilisez Apply pour le reporter au modèle, ou Apply All pour reporter toutes les modifications.
Les instances héritent des changements du modèle, sauf celles qui possèdent leur propre override sur la propriété concernée. Revert annule un override pour retrouver la valeur du modèle. Déplacer un cube reste propre à cette instance.

Appliquer ou annuler des overrides.
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.

Testez la pile. Ouvrez CubePrefab en double-cliquant et changez sa , puis sa . 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 sur le Collider et se distingue de l’amortissement. Les valeurs modifiées seulement sur une instance peuvent être des : 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 devient un composant. Nous allons créer un script qui fait simplement tourner les cubes sur eux-mêmes.

Notion essentielle

Du fichier C# au composant Unity

Un script est un asset C# (.cs) qui décrit un comportement. Dans ce TP, il contient une classe dérivée de MonoBehaviour, de même nom que le fichier : RotateCube.cs contient public class RotateCube : MonoBehaviour.

Enregistrez le fichier, puis revenez dans Unity : il compile automatiquement le code. Corrigez les erreurs de Console avant de continuer.

Pour s’exécuter, le script doit être ajouté à un GameObject comme composant, par glisser-déposer ou Add Component. Chaque cube possède alors sa propre instance du composant et ses réglages. Ses champs peuvent être exposés dans l’Inspector, comme vous allez le tester avec speed.

transform donne directement accès au Transform du GameObject qui porte le script : aucune référence à assigner pour faire tourner le cube.

Créer un script · Exposer un champ avec SerializeField.

Notion essentielle

Start, Update et le cycle de vie d’un MonoBehaviour

Unity appelle ces méthodes automatiquement : pas de boucle à écrire ni d’appel à faire vous-même. Respectez leurs noms et signatures, par exemple void Start() ; supprimez les méthodes vides inutiles.

Start() : préparer une fois, avant le premier Update du composant actif. Ici, vous y activerez les entrées ou mémoriserez la couleur initiale. Désactiver puis réactiver le composant ne relance pas Start.
Update() : agir à chaque image, tant que le composant et son GameObject sont actifs. Vous y ferez tourner le cube avec Time.deltaTime et y détecterez les tirs.

Pour les interactions souris, vous récupérerez directement le Renderer ou le Rigidbody avec GetComponent dans la méthode qui en a besoin.

Pour référence : les autres méthodes courantes

Méthode	Quand intervient-elle ?	Utilisation typique
`Awake()`	Une fois, à l’initialisation sur un GameObject actif, avant Start ; même si le composant est désactivé.	Préparer ses références internes.
`OnEnable()`	Chaque fois que le composant devient actif sur un GameObject actif.	S’abonner aux événements.
`FixedUpdate()`	Au rythme fixe de la simulation physique.	Appliquer des forces continues à un Rigidbody.
`LateUpdate()`	À chaque image, après les Update.	Mettre à jour une caméra après le déplacement des objets.
`OnDisable()`	Lorsque le composant ou son GameObject est désactivé.	Retirer les abonnements aux événements.
`OnDestroy()`	Lors de la destruction d’un objet précédemment actif.	Libérer les ressources possédées par le composant.

Repère simplifié pour un composant actif : Awake → OnEnable → Start, puis Update → LateUpdate à chaque image. FixedUpdate suit son propre rythme : il peut y avoir zéro, un ou plusieurs pas de physique par image. Ce repère ne fixe pas l’ordre des scripts entre différents GameObjects.

Cycle de vie et ordre d’exécution · Méthodes de MonoBehaviour.

Écrire RotateCube

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.

Vérification indispensable

Avant de coder : vérifier l’autocomplétion

Attendez que l’éditeur C# ait chargé le projet. Dans le corps de Update(), faites ces essais temporaires, un par un :

Saisissez	Suggestion attendue
`transform.`	`Rotate`, `position`…
`Vector3.`	`up`, `forward`…
`Time.`	`deltaTime`…

La liste doit proposer des membres de l’API Unity, pas seulement des mots déjà présents dans le fichier. Si elle ne s’ouvre pas automatiquement, essayez Ctrl+Espace. Effacez les essais avant d’enregistrer.

Ne poursuivez pas tant que ces suggestions ne fonctionnent pas. Dans Unity, vérifiez Edit > Preferences > External Tools > External Script Editor, puis rouvrez le script depuis Project. Avec VS Code, vérifiez que l’extension Unity de Microsoft et ses dépendances C# sont actives. Consultez le guide de configuration ou demandez de l’aide à l’enseignant.

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 permet de l’exposer dans l’Inspector.

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

Dans , appelé une fois par image, utilisez :

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

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.

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é.
É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.
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.
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;.

Notion essentielle

À retenir : public, private et SerializeField

public : accessible aux autres scripts et visible dans l’Inspector pour un type pris en charge.
private : réservé à la classe, masqué dans l’Inspector.
[SerializeField] private : privé dans le code, mais enregistré par Unity et réglable dans l’Inspector. C’est le choix conseillé ici.

Encapsulation : gardez les champs privés et exposez seulement les réglages utiles. Pour les échanges entre scripts, préférez une propriété en lecture seule ou une méthode qui contrôle la modification. L’Inspector peut toujours recevoir une valeur incohérente.

La valeur enregistrée dans l’Inspector prime sur la valeur initiale du code. Choisissez instance ou prefab selon la portée souhaitée. Pour garder un réglage essayé en Play, remettez-le en mode édition et sauvegardez.

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.

Importer l’Input System. Ajoutez using UnityEngine.InputSystem; en haut du fichier, en conservant using UnityEngine;.
Déclarer l’action. Dans la classe, à côté de speed et en dehors des méthodes, ajoutez un champ privé activateRotation de type , exposé avec [SerializeField]. Initialisez-le avec new InputAction(...) et ces trois arguments, dans cet ordre : le nom "ActivateRotation", le type InputActionType.Button et le "<Keyboard>/r".
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éé.
É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.
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.

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.
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.
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.

À essayer

Variation optionnelle : maintenir R pour tourner

Adaptez le script pour que les cubes tournent uniquement pendant que R est maintenue.

Remplacez le basculement dans ToggleRotation par une affectation de rotating à true. Vous pouvez renommer cette méthode StartRotation et mettre à jour son abonnement à performed dans Start().
Créez une seconde méthode, StopRotation, avec le même type de paramètre InputAction.CallbackContext context, qui affecte false à rotating.
Dans Start(), abonnez cette seconde méthode à canceled avec +=. Avec notre configuration par défaut, cet événement est émis au relâchement de R. Gardez l’appel à Enable() et la condition dans Update().

Test : maintenez R : les cubes tournent. Relâchez R : ils s’arrêtent. Appuyez de nouveau pour recommencer.

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.

Ajoutez GameObject > UI > Event System si la scène n’en possède pas. Gardez un seul EventSystem actif. Son module doit être : remplacez Standalone Input Module si présent. Utilisez Assign Default Actions si les références d’actions UI sont vides.
Ajoutez Physics Raycaster via Add Component sur la caméra active portant le tag MainCamera. Les cubes doivent avoir leurs colliders et appartenir à un inclus dans le masque du raycaster.
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.

Notion essentielle

Rappel : une interface est un contrat

Une interface C# décrit des méthodes qu’une classe doit fournir, avec leurs noms, paramètres et types de retour. La classe qui l’implémente écrit le comportement de ces méthodes ; elle peut implémenter plusieurs interfaces.

Syntaxe : après :, indiquez la classe de base, puis les interfaces séparées par des virgules :

public class MouseInteraction : MonoBehaviour,
 IPointerClickHandler, IPointerEnterHandler, IPointerExitHandler

Dans les accolades de cette classe, définissez ensuite les méthodes demandées par les interfaces.

Ici : IPointerClickHandler demande une méthode OnPointerClick. L’EventSystem reconnaît cette interface et appelle cette méthode lors d’un clic. Vous décidez ce que fait le cube dans son corps. Les deux autres interfaces suivent le même principe pour le début et la fin du survol.

En savoir plus sur les interfaces C# — Microsoft Learn.

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.
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 <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.
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.
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.
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 .transform.forward multipliée par 5f, et le mode 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.

À essayer

Pour aller plus loin : une force pendant l’appui

Notre script applique une impulsion une seule fois par clic : il donne une poussée ponctuelle au cube. Imaginez maintenant une force appliquée tant que le bouton gauche reste enfoncé.

Pour adapter le script, mémorisez l’appui dans un booléen : IPointerDownHandler et sa méthode OnPointerDown permettent de commencer la poussée, tandis que IPointerUpHandler et OnPointerUp permettent de l’arrêter au relâchement. Dans FixedUpdate(), si ce booléen est vrai, appelez AddForce avec ForceMode.Force. La force est alors appliquée à chaque pas de simulation physique, plutôt qu’une seule fois dans OnPointerClick ; retirez l’ancienne impulsion pour ne pas cumuler les deux.

À comparer : un appui bref et un appui prolongé. Comment changent le mouvement du cube et l’effet de sa masse ?

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.

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.
Identifiez le personnage avec , la caméra de rendu avec Camera / / , 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.
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 première personne.

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.
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.
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.
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

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.

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.
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.
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é.
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.
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.
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.
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 . 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.

Décompressez Ford_Mondeo.zip depuis les ressources du TP. Le fichier car.obj contient le de la voiture et les fichiers .tga sont ses textures.
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.
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.
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 , par exemple à 0.3. Observez la transparence des vitres dans la scène.
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 sur les parties pertinentes de la voiture immobile.

Un Mesh Collider non 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

Arrêtez Play et sauvegardez UnityBasics.
Ouvrez File > . 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.
Dans , 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.
Cliquez sur , choisissez un dossier dédié hors de Assets, par exemple Builds/Linux, puis lancez l’application. Build And Run l’exécute immédiatement.
Testez navigation, R, clics, physique et matériaux hors de l’éditeur. Distribuez le dossier complet du build. Explorez > 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 et l’éclairage dans Window > Rendering > Lighting. Pour approfondir, étudiez les objets Static et l’ : ne marquez pas les cubes mobiles comme statiques. Éclairage baked.
Ajouter un effet visuel. Créez de la fumée avec un , puis réglez son émission et sa durée de vie. Documentation. Explorez ensuite Visual Effect Graph ou des matériaux personnalisés avec pour URP.
Animer un élément du décor. Faites ouvrir une porte avec Animation et . Pour des événements différés, explorez les . 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 , 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 :

Besoin	Ressource
Retrouver une notion ou un réglage de l’éditeur	Manuel Unity 6.3
Comprendre les arguments d’une méthode C#	Référence de l’API Unity 6.3 : cherchez par exemple `Instantiate`, `AddForce` ou `GetComponent`.
Approfondir les actions et les bindings	Documentation Input System
Continuer avec des exercices guidés	Unity Learn
Retrouver les fichiers utilisés ici	Ressources du TP et contrôleur première/troisième personne

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.

Symptôme	Vérifications à faire
Pas d’autocomplétion Unity	Reprenez le test au début de Écrire RotateCube. Vérifiez l’éditeur externe et ses extensions, puis rouvrez le script depuis Unity.
Le script ne compile pas ou ne peut pas être ajouté	Vérifiez le nom du fichier et de la classe, les `using`, les accolades et les méthodes demandées par les interfaces.
R ne fait rien	Cliquez dans Game. Vérifiez que RotateCube est attaché et activé, que le binding est R et que `Start()` contient l’abonnement et l’appel à `Enable()`. Vérifiez aussi Active Input Handling = Input System Package (New).
Pas de survol rouge ni de clic	Vérifiez le collider du cube, MouseInteraction sur le cube, Physics Raycaster sur la caméra de rendu active et un seul EventSystem avec Input System UI Input Module. En navigation, réglez Advanced > Cursor Lock Behavior = Screen Center pour viser avec le curseur verrouillé.
Le cube devient rouge mais ne bouge pas au clic	Utilisez le clic gauche. Vérifiez le Rigidbody du cube, Is Kinematic désactivé et le tag MainCamera de la caméra active.
Aucun projectile ou référence manquante	Vérifiez CreateOnClick sur la caméra de rendu, l’action du clic droit et le champ Projectile Prefab. Le prefab assigné doit avoir un Rigidbody.
Le joueur traverse le sol ou la voiture	Vérifiez leurs colliders ; pour le sol, vérifiez aussi son layer et le masque de sol du contrôleur.
Matériau rose ou vitres opaques	Vérifiez le shader Universal Render Pipeline/Lit. Pour les vitres, modifiez le matériau extrait : Surface Type = Transparent, puis diminuez l’alpha de Base Map.
Une modification ne se propage pas aux cubes	Vérifiez si vous avez modifié le prefab ou une instance et si cette dernière possède un override.
Le build ne montre pas la bonne scène	Vérifiez la Scene List du profil actif : `UnityBasics` doit être cochée et en premier.

Computer Graphics | Étienne Peillard

TP — Rendu 3D : diorama stylisé

🎯 Objectif du TP

📌 Contraintes obligatoires (socle commun)

1) Composition / environnement

2) Lumières

3) Skybox / environnement

4) Effets visuels

5) Matériaux et shaders

🧩 Options à la carte

A — Lighting avancé (recommandé)

B — VFX Graph (ou particules avancées)

C — Cinématique (Timeline)

D — Modélisation in-editor (ProBuilder)

E — Interaction simple

F — Ambiance sonore

🎨 Idées de thèmes (au choix)

📦 Livrables attendus

1) Projet Unity

2) README (1 page max)

3) Image ou vidéo de présentation

🧮 Barème indicatif

📚 Ressources utiles

Assets gratuits

Shader Graph

Post-processing URP

Particles / VFX

Lighting (Baked, Probes)

ProBuilder

Timeline / Cinématique

TP — Les bases d’Unity 3D

Préparer le projet

L’éditeur d’Unity 3D

Les notions fondamentales

Créer une scène simple

Animer un objet de la scène

Écrire RotateCube

Gestion des interactions

Programmation d’interaction simple avec la souris

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

Création dynamique d’objets

Charger une géométrie

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

Pour aller plus loin

Ressources

En cas de blocage