Dans ce tutoriel, nous allons voir ce qu’est Time.deltaTime dans Unity et comment l’utiliser.
La version vidéo de ce tutoriel n’est actuellement pas disponible dans cette langue.
Transcription de la vidéo
Bonjour à tous ! Dans ce tutoriel, nous allons voir ce qu’est Time.deltaTime dans Unity et comment l’utiliser.
Ce tutoriel pour débutants est parfait pour celles et ceux qui découvrent le scripting en C# dans Unity, car le sujet est fondamental et mérite d’être bien compris, puisque vous le rencontrerez dans de nombreux scripts et tutoriels.
Le tutoriel a été réalisé avec Unity 2022, mais Time.deltaTime est présent depuis plusieurs versions du logiciel et continuera très probablement à l’être à l’avenir.
Time.deltaTime est une variable qui représente le temps écoulé, en secondes, entre la dernière frame et la frame actuelle, autrement dit le temps nécessaire pour calculer la frame précédente.
Elle est utilisée pour rendre les mouvements et les animations indépendants du frame rate, généralement en multipliant la vitesse d’un objet exprimée en unités par seconde par Time.deltaTime à chaque frame.
De cette façon, la vitesse par frame varie en fonction du frame rate, garantissant la même vitesse sur des appareils aux performances différentes.
Voyons un exemple pratique de ce que nous venons de décrire, avec un cas très simple : le déplacement d’un objet le long d’un axe à vitesse constante. Insérez un objet dans la scène, en cadrant la scène depuis le dessus avec une vue Isometric.
Attribuez à l’objet un script C#, en l’appelant par exemple movement, puis créez un Vector3 pour indiquer un déplacement d’une unité que nous souhaitons parcourir en une seconde :
private Vector3 obVelocity = new Vector3(0.0f, 0.0f, 1.0f);
Nous savons que Update est appelée à chaque frame ; cependant, nous ne savons pas combien de frames par seconde le jeu exécutera, car cela dépend de plusieurs paramètres.
Si notre frame rate était constamment de 50 frames par seconde, nous pourrions modifier obVelocity en (0.0f, 0.0f, 0.02f), en déplaçant l’objet de 0.02 unité à chaque appel de Update, donc à chaque frame, pour obtenir un déplacement d’une unité par seconde.
Comme nous ne pouvons pas garantir cela, dans Update nous écrirons :
transform.position += (obVelocity * Time.deltaTime);
Enregistrez le script, puis revenez dans l’éditeur Unity pour observer le résultat : l’objet se déplace de manière linéaire en maintenant une vitesse d’une unité de la scène par seconde.
En conclusion, pour déplacer un objet à une certaine vitesse exprimée en unités de la scène par seconde, définissez cette vitesse dans une variable et, dans la fonction Update, multipliez-la par Time.deltaTime, comme je vous l’ai montré précédemment.
Voyons maintenant un autre exemple.
Dans la scène que j’utilise à présent, la Main Camera a reçu un script de déplacement qui détecte les pressions sur les touches fléchées en utilisant Input.GetAxis pour Horizontal et Vertical.
Les valeurs de Horizontal et Vertical vont de -1 à 1 pour chacun. Si je multipliais directement ces valeurs par Time.deltaTime dans la fonction Update du script, j’obtiendrais un déplacement d’une unité de la scène par seconde, mais cette solution ne permettrait pas d’ajuster la vitesse.
Pour résoudre ce problème, la solution la plus simple consiste à définir une variable private avec le modificateur Serialized, afin qu’elle soit visible et modifiable dans l’Inspector lors des tests du jeu dans l’Editor.
Dans l’exemple présenté en vidéo, cette variable s’appelle "speed" et a initialement une valeur de 12.
Dans la fonction Update, le mouvement est géré à l’aide de controller.Move, car le personnage est associé à un composant Character Controller qui est déplacé avec la fonction Move.
La fonction est appelée avec un paramètre assez long, divisé en deux parties.
Dans la première partie, le déplacement sur les axes X et Z est calculé en fonction de l’entrée utilisateur, stockée dans la variable move, qui est un Vector3.
Dans la seconde partie, la force de gravité est calculée lorsqu’un saut est effectué.
Time.deltaTime est utilisé à la fois dans le calcul du mouvement sur les axes et dans le mouvement vertical dû à la gravité, mais nous ignorerons cette seconde partie, qui nécessiterait une explication plus longue, pour nous concentrer sur la première.
Le vecteur de mouvement move est multiplié par Time.deltaTime, comme pour le cube dans le premier exemple, mais il est également multiplié par la variable float speed.
Je passe ensuite à l’éditeur Unity et je lance le jeu pour vous montrer qu’il est possible de modifier la vitesse de déplacement du personnage en changeant, en temps réel, la valeur du paramètre Speed dans l’onglet du script.
Il est ainsi possible d’ajuster la vitesse au début du jeu.
Comme cette vitesse est multipliée par Time.deltaTime, nous savons qu’elle restera identique sur différents appareils, indépendamment du frame rate d’exécution.
Puisque "speed" est une variable dans le code, il sera également possible de la modifier pendant le jeu en fonction de certains événements.
Par exemple, le joueur pourrait boire une potion lui permettant de se déplacer deux fois plus vite ou, au contraire, d’avancer plus lentement que d’habitude.
Le point clé est que cette vitesse restera cohérente sur différents appareils, car elle est indépendante du frame rate grâce à Time.deltaTime.
En conclusion, dans cette vidéo, nous avons vu deux exemples simples d’utilisation de Time.deltaTime.
Je publierai prochainement une vidéo sur les rotations avec Slerp, où Time.deltaTime sera utilisé pour obtenir des rotations à vitesse constante, indépendamment du frame rate.
C’est tout pour ce tutoriel ! À très bientôt !