Chapitre 4.1 : animation de personnages 3D #

L’animation 3D englobe beaucoup de domaines, chacun avec ses propres techniques et spécificités. On peut noter par exemple :

l’animation de fluides (liquides, gaz, etc.);
l’animation de visages;
l’animation de particules;
l’animation de corps rigides (pierres qui roulent, collisions, etc.);
et l’animation de personnages.

Il faut aussi noter que certaines de ces techniques sont calculables en temps-réel alors que d’autres sont trop complexes et doivent être pré-calculées. Enfin, certaines techniques sont hybrides : elles pré-calculent une partie des résultats, et les réutilisent en temps-réel pour finaliser l’animation.

La vidéo suivante par exemple montre une animation de fluide (calculée en temps-réel) :

Ici, les lois de la physique sont utilisées pour calculer les mouvements de fourrure (toujours en temps-réel) :

Enfin, la vidéo suivante montre une simulation physique de corps rigides (encore en temps-réel) :

Dans cette section, nous allons nous concentrer sur l’animation de personnages en 3D et en temps-réel, comme ce qui est montré sur la vidéo suivante :

Ce que nous allons faire dans cette section :

trouver des données d’animations 3D existantes;
créer un système pour animer notre personnage 3D. On parle de moteur d’animation;
contrôler notre moteur d’animation en fonction des événements déclenchés (entrées de l’utilisateur, collisions, etc).

Trouver des données d’animations 3D #

Créer des animations 3D est très compliqué et demande beaucoup de temps. En particulier, chaque personnage 3D nécessite une configuration spécifique pour l’animation 3D. Dans de nombreuses situations, il est donc trop complexe (et trop coûteux) de créer des animations 3D spécifiquement pour notre application. Heureusement, il existe beaucoup d’animations 3D téléchargeables et directement utilisables dans Unity.

Unity Asset Store #

L’Asset Store de Unity possède de nombreuses animations 3D. Dans cette section par exemple, nous allons utiliser le Zombie Animation Pack Free :

Nous allons en particulier utiliser le personnage 3D présent dans le répertoire Assets/ZombieAnimationPackFree/Models/Appearance/BH-2/Mesh :

Mixamo #

Mixamo¹ est une base de données interactive contenant beaucoup d’animations 3D. C’est une excellente solution car les données présentes sont gratuites. Mixamo propose donc une excellente alternative à l’Asset Store de Unity.

Créer un moteur d’animation 3D #

Dans Unity, un moteur d’animation 3D est représenté par un Animator Controller². Une fois créé, ce Component doit être connecté à l’Animator du personnage 3D que nous souhaitons animer comme le montre la figure qui suit :

Un Animator Controller est en fait une machine à états finis (un graphe) qui sert à :

gérer les clips d’animation 3D (on parle d’Animation Clips³);
changer l’animation courante (celle en train d’être jouée) grâce aux State Machine Transitions et aux Triggers⁴;
mélanger les animations entre elles pour en créer de nouvelles en utilisant des Blend Trees.

Les Transitions permettent de changer d’animation active :

en temps-réel;
en fonction des entrées de l’utilisateur;
de manière fluide, sans secousse.

Pour créer un Animator Controller, il faut aller dans le menu Assets > Create > Animator Controller comme indiqué sur la figure qui suit :

Il faut ensuite l’assigner à l’Animator du personnage 3D que l’on souhaite animer puis l’ouvrir dans l’éditeur (en double cliquant dessus par exemple). Vous devriez obtenir une fenêtre ressemblant à la figure suivante :

État simple #

Comme dit précédemment, un Animator Controller est une machine d’états finis. Chaque état représente en fait une animation du personnage 3D. Pour rajouter un nouvel état à l’Animator Controller, il suffit de faire un clic droit dans la fenêtre Animator, puis de sélectionner Create State > Empty :

À chaque état créé, on peut associer un Animation Clip comme indiqué sur la figure suivante :

Nous pouvons créer des transitions entre chaque état en faisant un clic droit sur l’état initial de la transition, en sélectionnant Make Transition, puis en sélectionnant l’état d’arrivée :

Enfin, nous pouvons rajouter des Triggers aux Transitions pour les activer lorsque certains événements sont déclenchés. Pour créer un Trigger, il faut aller dans Parameters, puis cliquer sur + et choisir Trigger :

Pour le rajouter à une transition, il suffit de la sélectionner. Puis dans l’Inspector, aller dans le bloc Conditions pour en rajouter une, et sélectionner le Triggers précédemment créé :

En utilisant le pack d’animations 3D rajouté à notre projet, nous pouvons :

créer 3 états intitulés Idle, Hit et Attack;
leur associer les animations adéquates;
rajouter les transitions nécessaires pour passer de Idle à Hit (et vice-versa) et de Idle à Attack;
créer les Triggers Hit et Attack et les associer aux transitions adéquates. En suivant ces étapes, ceci nous donne un graphe qui ressemble à ceci :

Les Blend Trees #

Les Blend Trees⁵ permettent de combiner des Animation Clips en temps-réel afin de générer de nouvelles animations. Par exemple, vous pouvez combiner une animation de marche lente avec une animation de marche rapide pour créer des animations de marche à des vitesses variables.

Les Blend Trees sont en fait contenus par certains états du graphe. Ils englobent plusieurs Animation Clips et un système pour interpoler entre eux. Il est possible de créer un état contenant un Blend Tree vide en faisant un clic droit dans la fenêtre Animator puis sélectionner Create State > From New Blend Tree :

Il est aussi possible de rajouter un Blend Tree dans un état existant en faisant un clic droit sur un état existant et en choisissant Create new BlendTree in State :

Si l’on crée un Blend Tree et qu’on l’ouvre en double-cliquant dessus, alors on obtient quelque chose comme ce qui suit dans l’Inspector :

Dans un premier temps, il est important de choisir la façon donc le Blend Tree va interpoler les animations entre elles. Pour ceci, il existe plusieurs types d’interpolation :

1D⁶ : les animations sont interpolées en 1 dimension, donc selon un paramètre unique;
2D Simple Directional⁷ : les animations sont interpolées en 2 dimensions, donc en utilisant 2 paramètres. Certaines restrictions (vitesses des animations, directions inférieures à 180°, etc.) peuvent limiter son utilisation;
2D Freeform Directional⁷ : ce type d’interpolation est similaire à ce qui précède mais avec moins de contraintes. Il est cependant plus compliqué à utiliser;
2D Freeform Cartesian⁷ : ici l’interpolation n’est plus optimisée pour des animations de locomotion mais peut être utilisée pour interpoler toute sorte de mouvements.
Direct⁸ : ce dernier type d’interpolation permet de gérer directement l’interpolation avec plusieurs paramètres.

Les Blend Trees demandent donc des paramètres en entrée pour calculer l’interpolation. Ces paramètres sont rajoutés de manière identique aux Triggers vus précédemment. Dans le cas d’un moteur d’animation de locomotion par exemple, on peut vouloir contrôler la vitesse et la direction de déplacement. Dans ce cas, on peut créer des paramètres de type Float. Enfin, dans l’Inspector, on rajoute ces paramètres comme entrées au Blend Tree.

À ce stade, il nous reste encore à rajouter des Animation Clips. Pour ce faire, il faut aller dans la section Motion dans la fenêtre Inspector, cliquer sur le + et sélectionner Add Motion Field :

À chaque Motion Field ainsi créé, on va associer des valeurs des paramètres du Blend Tree. Quand ces valeurs seront entrées dans le Blend Tree, alors l’Animation Clip sera jouer à 100%. Sinon, le Blend Tree va prendre les mouvements les plus proches (en termes de valeurs des paramètres) et les interpoler.

Pour reprendre notre exemple, nous devons donc :

créer un Blend Tree dans l’état Idle;
rajouter 2 paramètres de type Float (appelés par exemple Speed et Direction) à notre Animator Controller;
choisir le type 2D Freeform Directional pour le paramètre Blend Type;
rajouter 4 Motion Fields pour les Animation Clips souhaités dans le Blend Tree comme par exemple un mouvement Idle, Move Forward, Move Left et Move Right;
pour chaque Motion Field, spécifier les valeurs (vitesse, direction) qu’ils représentent. Par exemple, pour le mouvement Idle, alors on peut lui donner les valeur (0, 0). Pour le mouvement Move Forward les valeurs (1, 0). Pour le mouvement Move Left les valeurs (1, -1) et enfin pour le mouvement Move Right les valeurs (1, 1).

Contrôler le moteur d’animations #

Nous avons donc pour le moment un moteur d’animations 3D qui a plusieurs paramètres. Il nous reste enfin à le modifier pour le faire réagir en temps-réel aux différents événements de notre application 3D.

Les transitions ont des conditions qui leur sont attachées. Par exemple, la transition entre l’état Idle et l’état Attack va s’activer lorsque l’utilisateur active l’Axis nommé Fire1. Pour ce faire, il suffit d’attacher le Script suivant au personnage 3D :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Attack : MonoBehaviour
{
    private Animator m_animator;
    // Start is called before the first frame update
    void Start()
    {
        m_animator = GetComponent<Animator>();
    }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetAxis("Fire1") > 0)
        {
            m_animator.SetTrigger("Attack");
        }
    }
}

Enfin, on peut modifier les paramètres Speed et Direction quand l’utilisateur presse les touches associées aux Axis Horizontal et Vertical :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class UserControls : MonoBehaviour
{
    private Animator m_animator;
    // Start is called before the first frame update
    void Start()
    {
        m_animator = GetComponent<Animator>();
    }

    // Update is called once per frame
    void Update()
    {
        if (Input.GetAxis("Fire1") > 0)
        {
            m_animator.SetTrigger("Attack");
        }

        float speed = Input.GetAxis("Vertical");
        if (speed != 0)
        {
            m_animator.SetFloat("Speed", speed);
        }
        float direction = Input.GetAxis("Horizontal");
        if (direction != 0)
        {
            m_animator.SetFloat("Direction", direction);
        }
    }
}