La plupart du temps on utilise un package 3D pour créer les animations.
Voyons ces méthodes :

2.1.                   Procédurale

Il s’agit ici d’une animation qui se définit par rapport à une action, par exemple nous pouvons rajouter un comportement sur un objet qui le ferait tourner sur lui-même. Nous pouvons aussi lui affecter une trajectoire géométrique tel qu’un cercle et lui demander de suivre ce cercle à une certaine vitesse. Ce type d’animation n’est, en général, pas éditable directement sous un package 3D car ces comportements sont des éléments du moteur de jeu et donc rarement disponible dans le package 3D lui-même. Il est cependant possible de programmer ces comportements et de les rajouter au package 3D.

2.2.                   Dynamique

On anime ici les objets par de la dynamique. Il s’agit de mécanique du point et du solide plus rarement des fluides. C’est à dire, les objets sont animés par un comportement basé sur des lois physiques.

Exemple : Un personnage tenant une épée, la lâche. La gravité s’appliquant sur cette épée fait qu’elle tombe sur le sol puisqu’aucune contrainte ne la retient. Précédemment, la gravité s’appliquait aussi mais la main du personnage empêchait l’épée de tomber.

On utilise des lois similaires à celle-ci bien qu’en réalité dans les jeux vidéo, nous n’ayons pas forcément besoin d’un réel comportement dynamique mais uniquement de faire croire à ce comportement, de le rendre plausible… Nous n’allons que brièvement parler de la dynamique du point dans ce document. Pour cela on introduit l’équation fondamentale de la dynamique :

où les F_i sont des vecteurs forces appliqué sur le centre de gravité de l’objet, m est la masse de l’objet ett A son vecteur accélération.

On considère ici un objet où seul son centre de gravité reçoit l’application de forces. Cela est suffisant pour simuler des lancés d’objets par exemple. Dans ce cas, on néglige toute rotation, seul un point (qui n’a donc pas d’orientation) est considéré comme représentant de l’objet sur lequel s’applique les forces.

Figure 1 : cube avec une force de gravité

Cette méthode permet de gérer des particules. C’est un effet très couramment utilisé dans les jeux. On l’utilise en autres pour :

-          simuler de la poussière lors de dérapage de voitures.

-          simuler un feu avec de la fumée qui monte au-dessus

-          Etc.

Voyons sur un exemple comment on applique cette formule :

Considérons que seule une force s’applique sur un objet lancé : son poids noté P = m*g où m est la masse de l’objet, et g la constante gravitationnelle sur terre dont la valeur numérique est 9.81. Avec l’équation fondamentale de la dynamique précédente, on obtient dans ce cas que la somme des forces vaut P le poids, et donc :

P = m*A

Ceci nous permet de calculer l’accélération qui est constante par rapport au temps et vaut A = P / m = g. Or ce qui nous intéresse pour faire bouger un objet c’est sa position à un instant donné.

Pour calculer la position à partir de l’accélération, on est obligé de passer par la calcul de sa vitesse. Pour la calculer, il suffit d’intégrer par rapport au temps l’équation donnant l’accélération, puis pour retrouver la position à un instant donné, il nous faudra encore intégrer la vitesse.

Ce qui fait :

A ( t ) = g

(constant par rapport au temps t)

V(t) = g*t + V₀

où V₀ est la vitesse au temps 0 (vitesse initiale de l’objet)

Et enfin, on calcule

P( t ) = 1 / 2*g* t² ₊ V₀ * t + P₀

Où est P₀ est la position au temps 0 (position initiale)

Ces formules s’appliquent pour des vecteurs 3D, voir la figure précédente pour l’orientation des axes. L’accélération s’applique sur l’axe y dans le sens inverse. On a donc les vecteurs suivants :

A( t ) = ( 0 , -g , 0 )

V( t ) = ( V_x( t ), V_y( t ), V_z( t ) ) et V₀ = (V_{0x ,} V_{0y ,} V_0z )

P( t ) = ( P_x( t ), P_y( t ), P_z( t ) ) et P₀ = (P_{0x ,} P_{0y ,} P_0z )

Ceci est la résolution théorique d’une équation différentielle linéaire du second ordre par rapport à t avec second membre constant qui est :

P( t ) ’’ = ( 0, –g , 0 )

En pratique comment résout-on ces équations ?

Nous allons procéder numériquement de manière itérative en considérant ces équations sur des intervalles de temps petits et en calculant une solution approchée sur chaque extrémité de l’intervalle. Chaque nouvelle position 3D calculée avec sa vitesse nous permettra de calculer la position et vitesse approchée sur l’intervalle suivant…

Cela s’appelle les méthodes numérique de résolution des équations différentielles linéaires du premier ordre. Les méthodes d’Euler et celles de Runge-Kunta en font partie. Nous n’allons pas nous étendre sur les différentes méthodes et leurs avantages / inconvénients, cela dépasserait la cadre de ce document.

Nous allons nous intéresser uniquement à la méthode d’Euler explicite qui est la plus simple et la plus rapide (et qu’il faut éviter en pratique si on veut un résultat précis J)

Cette méthode permet à un temps donné, connaissant la position et la dérivée (dans notre cas c’est vitesse) en ce temps de calculer la position et vitesse suivante. La formule est la suivante :

Où h est la longueur de l’intervalle de temps ( 1/30 dans notre cas ), CurPos est la position courante et CurSpeed la vitesse courante au temps t.

On démarre à t₀ = 0 :

V( t₀ ) = V₀ connu.
P( t₀ ) = P₀ connu.

On va considérer par exemple des intervalles de 1 / 30 secondes (ce qui représente une frame sur deux pour un jeu tournant à 60 FPS).

Donc au temps suivant t₁ = 1/30, on aura

V( t₁ ) = V( t₀ ) + (1/30) * A( t₀ ) avec A( t₀ ) = A( t ) = g constant par rapport à t.
P( t₁ ) = P( t₀ ) + (1/30) * V( t₀ )

Puis au temps t₂ = 2 / 30, on aura :

V( t₂ ) = V( t₁ ) + (1/30) * A( t₁ )
P( t₂ ) = P( t₁ ) + (1/30) * V( t₁ )

Etc…

2.3.                   Keyframes

C’est le moyen le plus commun de création d’une animation. Prenons un exemple concret :

Nous avons une caméra qui doit présenter deux combattants dans une arène, et nous souhaitons que la caméra fasse le tour de des 2 personnages en un temps de 5 secondes.

Remarque : On parle plus fréquemment en nombres de frames plutôt qu’en unité de temps. Pour passer d’un nombre de frames à un nombre de secondes on se sert de la vitesse d’affichage. Si on définit qu’une animation se jouera à 30 FPS sous le package 3D, on sait que 30 frames représenteront donc 1 seconde. Donc en faisant durer une animation 150 frames cela représentera 150 / 30 = 5 secondes d’animation. Mais en général le nombre de frames d’un jeu n’est pas constant…

On peut placer des clés d’animation sur la translation de la caméra, sa rotation ou son scale. Il y a d’autres possibilités que ces 3 cas mais nous n’en parleront pas ici.

Prenons par exemple la translation. Une clé d’animation contiendra au minimum un temps (ou une frame) et une translation qui est un vecteur 3D.

Les animateurs placent ces clés sous un package 3D. Le programmeur les récupère par une phase d’export du package 3D puis il créé l’animation dans le moteur du jeu.

Dans notre exemple, nous voulons que notre caméra passe d’une clé à une autre avec les informations que nous avons fixé dans chaque clé. La manière de passer d’une clé à une autre est appelé l’interpolation.

L’interpolation permet, à partir de 2 clés existantes, de calculer une valeur intermédiaire à un temps donné permettant de relier les 2 clés.

2.3.1.                       Algorithme général d’animation par keyframe

Il nous faut un tableau contenant toutes les clés d’animation. Chacune de ces clés contient un temps, celui auquel s’applique cette clé et une valeur pour la clé. Dans ce tableau les clés sont triées en fonction du temps par ordre croissant.

L’algorithme est le suivant :

-          On prend en entrée le temps courant. Notons le t.

-          On recherche entre quelles clés on se trouve dans le tableau de clés, pour cela on cherche à vérifier que t soit inférieur au temps d’une clé. On connaît maintenant la clé de départ et d’arrivée notons les respectivement Key_n et Key_{n + 1.} Appelons t_n et t _{n + 1} respectivement les temps des clés de départ et d’arrivée.
Ces clés vérifient : t_{n <=} t _<= t _{n + 1}.

-          Avec ces 2 clés nous pouvons utiliser une fonction d’interpolation pour nous renvoyer au temps courant la valeur de ce que nous interpolons (translation, rotation etc..)

Remarque : la fonction d’interpolation peut utiliser d’autres informations que ces 2 clés, elle peut utiliser d’autres clés pour lisser l’animation comme dans le cas du TCB.

Voyons quelques fonctions d’interpolation utilisées dans les jeux.