Salut Chez Playrix, nous avons décidé de fabriquer
notre Unity3D . Et il y a Animator. Dans cet article, je vais vous dire comment nous l'avons fait à la maison et comment cela fonctionne.
Lorsque nous avons commencé à concevoir l'architecture de nos graphes d'animation, nous avons bien sûr regardé d'autres analogues, notamment sur Unity Animator. Cependant, nous voulions faire une solution plus universelle. Contrairement à la même unité, nous avons la personnalisation des états d'animation via l'interface du contrôleur. Mais d'abord, il vaut la peine de comprendre ce qu'est un graphique d'état animé. Si vous l'avez déjà rencontré, il est logique d'ignorer la partie introductive et de passer aux fonctionnalités d'implémentation.
Alors, quel est exactement ce graphique d'état animé?
Un graphique d'état d'animation vous permet de représenter graphiquement les transitions entre différents états d'animation.
Prenez, par exemple, l'animation des personnages:
Nous avons un modèle en trois dimensions d'un homme et il y a plusieurs de ses animations:
- inactif - reste immobile;
- marcher - va de l'avant;
- assis
- bonjour - agite une main.
L'approche classique de la gestion des animations est la suivante: si vous voulez que l'objet se tienne - allumez le ralenti, marchez-marchez, asseyez-vous. Mais cela présente certaines difficultés.
Tout d'abord, vous devez contrôler manuellement la durée et la séquence des animations. Par exemple, pour qu'une personne s'assoie, vous devez d'abord lire l'animation, comment elle s'assoit, puis commencer à lire l'animation en boucle, où la personne est déjà assise. La personnalisation des articulations de ces animations dans le code est difficile et peu pratique.
Deuxièmement, les articulations entre les animations deviennent visibles si les extrémités de l'animation ne correspondent pas, ou si nous devons inclure une autre animation au milieu de l'animation actuelle. Dans ce cas, il est tout simplement impossible de faire correspondre parfaitement les animations. Rappelez-vous les anciens jeux où les animations des personnages changeaient instantanément.
Le graphique d'animation est conçu pour résoudre ces problèmes. Avec lui, vous n'avez pas besoin de faire fonctionner les animations manuellement, maintenant vous travaillez avec des états. La façon dont un objet sera animé pour atteindre cet état est le travail des animateurs et des concepteurs. Maintenant, le programmeur ne pense pas au timing et à la séquence de l'animation, il indique simplement dans quel état l'objet doit entrer.
De plus, avec le graphique d'animation, le problème de la jonction d'animations disparaît. Dans la transition entre les états, nous pouvons effectuer une transition en douceur d'une animation à une autre. Cela se fait en utilisant des poids. Le poids est un facteur de mélange de 0 à 1, où 0 signifie que l'animation n'affecte en aucune façon l'objet et 1 l'affecte complètement.
Par exemple, la transition entre la marche (ralenti) et la position debout (ralenti) est très exigeante pour la mise en place du processus. À tout moment dans l'animation de marche, le personnage peut s'arrêter. Par conséquent, la transition n'est pas effectuée instantanément, mais pendant une courte période de temps. À ce moment, le poids de marche diminue de 1 à 0 et le poids debout de 0 à 1. Il est important que la somme des poids soit égale à un, sinon des artefacts peuvent apparaître.
Comment ça marche?
Un graphique se compose d'états et de transitions. Un état est un ensemble de contrôleurs d'animation, chacun pouvant jouer une sorte d'animation sur un objet ou exécuter une sorte de logique. Le contrôleur a des points d'entrée et de sortie - ce sont les moments où le graphique active l'état avec ce contrôleur et le désactive en conséquence. Le contrôleur a également une fonction de mise à jour, où, en plus de l'intervalle de temps de la dernière image, vient le poids de la transition. Pour mixer des animations, il faut en tenir compte.
Les contrôleurs ont une interface unique. De plus, les développeurs peuvent ajouter leurs contrôleurs. Par exemple, vous pouvez créer un contrôleur qui exécute une sorte de logique ou définit du texte dans une fenêtre contextuelle, etc. Cette personnalisation simple vous permet d'utiliser le graphique d'animation de manière très flexible.
Nous avons également des variables. Ces variables peuvent être définies en externe, y compris à partir du code, puis lues dans les contrôleurs. Ainsi, par exemple, vous pouvez basculer une sorte d'animation pour un personnage sur le même état. En général, vous pouvez même répéter le paradigme de transition entre les états à travers des variables et des conditions, comme Unity. En conjonction avec des contrôleurs personnalisables, cela s'avère très pratique.
Les transitions peuvent être n'importe quel nombre. De nombreuses transitions peuvent entrer en état et sortir de la même manière de manière illimitée. Les transitions déterminent la possibilité d'atteindre des États. Par exemple, s'il n'y a pas de transition directement entre les états A et F, mais qu'il y a une chaîne A → B → C → D → E → F, alors lorsque vous demandez une transition de A à F, le graphique lui-même comprendra qu'il doit passer par les états intermédiaires B, C, D et E.
Les transitions ont des paramètres et des durées d'intervalle de démarrage. Avec la durée, tout est simple - c'est le temps pour lequel la transition se fera. Mais l'intervalle est déjà plus compliqué: il détermine la période de temps acceptable pour l'animation lorsque la transition peut être lancée.
Par exemple, pour qu'un personnage puisse s'asseoir, vous devez d'abord jouer l'animation pendant qu'il s'assoit, puis démarrer l'animation de siège. Dans ce cas, l'intervalle de transition de "s'asseoir" à "s'asseoir" devrait être à la fin de l'animation "s'assoit" afin que nous puissions voir comment il s'assoit, puis à la fin, rapidement mais sans à-coup, entrer dans l'animation du siège.
Autre exemple: un personnage marche et il doit s'arrêter. Dans ce cas, l'intervalle de début de transition doit être sur toute la longueur de l'animation, car le personnage peut s'arrêter à tout moment.
Le graphique d'animation fait tout le travail connexe:
- prévoit un chemin vers l'état nécessaire;
- Met à jour les états en cours d'exécution
- effectue une transition en douceur entre les États;
- ajuste les poids en eux.
Fonctionnalités intéressantes
Il existe de nombreux types d'animations dans le moteur Playrix: modèles 3D, colonne vertébrale, Flash, effets de particules, animation squelettique. Chaque type a un contrôleur spécifique.
En plus de simples contrôleurs d'animation, nous en avons plusieurs auxiliaires. Par exemple, un contrôleur aléatoire. Il peut inclure une liste d'autres contrôleurs et la probabilité de leur choix. Chaque fois qu'un objet entre dans un état avec un tel contrôleur randomisé, la sélection aléatoire prend en compte les probabilités et le contrôleur sélectionné commence à fonctionner. Les autres sont endormis et inactifs, attendant leur moment.
Mais parfois, sur un état, nous devons changer d'animation. Par exemple, si plusieurs personnages ont le même graphique et ont tous une sorte d'animation d'action. Un personnage doit obtenir son balai et commencer sa vengeance, un autre pour obtenir son appareil photo et commencer à prendre des photos, le troisième mange de la glace. Pour de telles situations, il existe un contrôleur spécial, qui contient également une liste de contrôleurs, mais, contrairement aux contrôleurs aléatoires, il sélectionne ici un contrôleur en fonction de la variable.
Les variables sont définies dans le graphique et peuvent être modifiées en externe, par exemple à partir du code. Dans cet exemple, un type de chaîne est utilisé et chaque type d'action correspond à une certaine valeur de la variable. Lorsqu'un personnage est créé dans le jeu, cette variable lui est fixée en fonction du comportement souhaité.
Nous avons également un contrôleur qui peut mélanger plusieurs animations. Par exemple, vous pouvez mélanger des animations de marche, gauche, droite et avant. Ainsi, dans les virages, vous pouvez ajuster les poids entre eux afin que les jambes du personnage ne glissent pas et que la marche semble naturelle.
Nous devons aller plus loin
Il y a beaucoup d'avantages à faire notre unité. L'un d'eux est que nous pouvons faire ce que nous voulons et ce que nous voulons. Et nous voulions une possibilité illimitée d'étendre le graphique d'animation.
Nous avons une interface de contrôleur, il y a plusieurs contrôleurs «prêts à l'emploi», et il y a la possibilité de mettre en œuvre l'interface et de faire n'importe quoi (et pas nécessairement une animation):
- changer le texte sur le bouton;
- interagir avec d'autres objets de la hiérarchie;
- et même gérer un autre graphique d'animation.
Nous avons utilisé cette approche chez les visiteurs du zoo dans le jeu Wildscapes. Chaque visiteur dispose de deux graphiques: l'un pour animer le modèle, l'autre pour animer le comportement.
Le premier graphique est assez simple, il contrôle la marche, peut jouer des animations de personnages distinctes.
Le deuxième graphique est beaucoup plus compliqué et comporte certains scénarios de comportement. Par exemple, d'abord le personnage s'en va, puis s'assoit sur un banc, salue quelqu'un, prend des photos et continue. Il s'agit d'une branche d'État distincte.
Cette logique pourrait être placée sur la première colonne, mais ensuite les animations seraient dupliquées plusieurs fois. Mais avec deux graphiques, tout est beaucoup plus simple. Le graphique de contrôle contient une chaîne d'états, y compris les états du premier graphique, qui s'exécute en parallèle.
Et ensuite?
Notre graphique en sait déjà beaucoup, mais il y a encore beaucoup de place pour le développement. Les plans font un groupement de plusieurs états, avec emboîtement. Cela simplifiera considérablement les colonnes de quête. Les plans comprennent également des travaux visant à améliorer l'affichage des graphiques et des liens. Maintenant, les connexions sur les grands graphiques ressemblent à des spaghettis (même la couleur est similaire), et parfois il est facile de se confondre.