Voici le deuxième de deux tutoriels consacrés à la création d’un script « Look At » dans Unity 2022 afin de faire pointer un objet vers un autre.
La version vidéo de ce tutoriel n’est actuellement pas disponible dans cette langue.
Transcription de la vidéo
Bonjour à tous !
Voici le deuxième de deux tutoriels consacrés à la création d’un script « Look At » dans Unity 2022 afin de faire pointer un objet vers un autre.
Plus précisément, dans la première partie nous avons analysé le problème et implémenté une solution impliquant une rotation instantanée de l’objet ; dans ce tutoriel, en revanche, nous allons créer une rotation plus lente et plus progressive en utilisant les Quaternions et Slerp.
Dans ce tutoriel, je suppose que vous connaissez déjà des concepts tels que Time.deltaTime et la méthode Quaternion.Slerp, car je les ai abordés dans d’autres tutoriels ; si ce n’est pas le cas, je vous recommande de consulter d’abord ces tutoriels.
Dans le tutoriel précédent, nous avons parlé des axes globaux et locaux de la caméra, afin d’identifier à la fois l’axe qui indique son orientation et l’axe autour duquel effectuer les rotations.
Nous avons ensuite réduit le problème au plan bidimensionnel et calculé l’angle de rotation autour duquel faire pivoter le modèle 3D de la Surveillance Camera.
Dans notre script, cet angle s’appelle deltaAngle et il est mesuré en degrés.
Pour utiliser Slerp, nous avons besoin de trois éléments :
le quaternion qui indique l’orientation initiale ;
le quaternion qui indique l’orientation cible à atteindre ;
une méthode permettant d’indiquer, à chaque frame d’exécution du jeu, à quel point nous en sommes, dans un intervalle allant de 0 à 1, dans la transition de l’orientation initiale vers l’orientation finale.
Le premier point est le plus simple : la propriété rotation de transform exprime en effet l’orientation de l’objet sous forme de quaternions ; pour ce champ, nous utiliserons donc transform.rotation.
Le deuxième point n’est pas très compliqué non plus : étant donnée une orientation initiale exprimée en quaternions, le quaternion qui exprime l’orientation cible obtenue en faisant tourner l’orientation initiale est donné par le produit de l’orientation initiale et de la rotation à effectuer.
La rotation à effectuer, dans notre script, est deltaAngle, qui est exprimé en degrés ; nous devons donc l’exprimer sous forme de Quaternion.
Heureusement, la fonction Euler de la classe Quaternion est exactement ce dont nous avons besoin : elle prend trois paramètres, c’est-à-dire les angles de rotation autour des axes X, Y et Z, et renvoie un quaternion représentant cette transformation.
Comme mentionné précédemment, pour obtenir le quaternion cible, nous devons multiplier le quaternion initial par celui de la rotation ; dans Update, je peux donc écrire :
Quaternion targetRotation = (transform.rotation * (Quaternion.Euler(0f, 0f, deltaAngle)));
Juste après, je peux mettre à jour l’orientation de l’objet en assignant à transform.rotation le quaternion calculé par Quaternion.Slerp, avec :
transform.rotation = Quaternion.Slerp(transform.rotation, targetRotation, evaluationTime);
Évidemment, nous devons maintenant définir evaluationTime : une valeur float comprise entre 0 et 1 qui représente le point auquel nous nous trouvons dans la transition de l’orientation initiale vers l’orientation finale.
Tout d’abord, je déclare et j’initialise cette variable en écrivant :
private float evaluationTime;
au début de la classe du script, puis :
evaluationTime = 0f;
à l’intérieur de la méthode Start.
La variable evaluationTime doit ensuite être augmentée à chaque frame, ce qui peut être fait en écrivant :
evaluationTime += Time.deltaTime;
juste après l’instruction contenant Slerp.
Il s’agit bien sûr d’un exemple ; je vous conseille de multiplier Time.deltaTime par une variable dont la valeur peut être ajustée en temps réel dans l’Inspector, jusqu’à obtenir une vitesse de rotation optimale. J’ai abordé ce sujet dans mon tutoriel sur Time.deltaTime.
Cependant, de cette façon, à un certain moment evaluationTime atteindra 1.0, puisqu’elle est incrémentée à chaque frame du jeu sans option de réinitialisation.
Mais quand devons-nous la réinitialiser ?
La question peut être formulée ainsi : quand sommes-nous prêts à commencer une nouvelle rotation du modèle ?
La réponse est : lorsque le modèle est déjà orienté vers le Player et attend qu’il se déplace.
Normalement, je vous dirais que lorsque le modèle de la Surveillance Camera pointe vers le Player et que le Player reste immobile, alors deltaAngle est égal à 0, puisqu’il n’y a aucune rotation à effectuer ; cependant, avec des valeurs float, surtout en cas de conversions entre différentes unités de mesure, il est préférable de conserver une certaine marge. Nous dirons donc que l’animation est terminée, et qu’une nouvelle peut commencer dès que le Player se déplace, lorsque la valeur absolue de deltaAngle est inférieure à 1f.
Ainsi, juste avant la création de targetRotation, à l’intérieur de la méthode Update, j’écris :
if(Mathf.Abs(deltaAngle) < 1f) evaluationTime = 0f;
puis je place les trois instructions suivantes, c’est-à-dire la définition du quaternion cible, le changement d’orientation avec Slerp et l’incrémentation de evaluationTime, à l’intérieur du bloc else de cette instruction if.
Je sauvegarde le script modifié, je retourne dans l’éditeur Unity et j’appuie sur Play pour observer le résultat. Dans ce cas, la vitesse de rotation est déterminée exclusivement par Time.deltaTime et peut être diminuée ou augmentée, comme mentionné précédemment, en multipliant Time.deltaTime par une variable à calibrer de manière interactive.
Pour résumer : dans ce tutoriel, nous avons vu comment convertir l’angle de rotation en Quaternions afin de calculer le Quaternion représentant l’orientation cible, puis nous avons utilisé Slerp pour effectuer des rotations plus lentes, dont la vitesse peut être ajustée tout en restant indépendante de la plateforme d’exécution, grâce à Time.deltaTime.
Nous avons également défini une condition de réinitialisation pour Slerp afin que la rotation redémarre lorsque le Player est immobile et prêt à se déplacer de nouveau.
Très bien, c’est tout pour ces deux tutoriels ! À bientôt !