L’animation temps réel dans les jeux vidéo
Article réalisé par  David Lanier

1. Généralités Depuis les débuts du jeu vidéo sur micro-ordinateur 8 bits dans les années 80, l’animation a été prépondérante. Elle a permit aux joueurs de s’immerger dans l’univers proposé et de rendre les actions du joueur identifiables dans cet univers. Tout d’abord réalisée en 2 dimensions (2D) par diverses techniques telles que les scrollings et les sprites, elle a acquis aujourd’hui un réalisme qu’il n’aurait pas été possible d’imaginer il y a 20 ans ! Nous allons voir les différentes techniques utilisées pour animer les jeux d’aujourd’hui. 1.1.  Prérequis Il est nécessaire pour comprendre ce qui suit d’avoir des notions minimums en 3D telles que translation, rotation, scale, changement de repère, quaternions.  Il faut avoir aussi des notions de mathématiques. Il faut connaître la dynamique pour comprendre le paragraphe sur ce sujet car les notions de bases ne seront pas expliquées. 1.2. A qui s’adresse ce cours ? Ce cours s’adresse aussi bien aux débutants dans le domaine de l’animation qu’aux gens désireux de se perfectionner. Il est plutôt orienté pour les programmeurs mais peut-être lu en grande partie par des artistes. Ce cours n’abordera pas les notions présentées avec un formalisme mathématique. Ce cours se veut accessible au plus grand nombre et ne devrait pas nécessiter d’avoir un niveau élevé en mathématiques.

Modèle : Michel Roger – https://mr2k.3dvf.net

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 :

F₁+ F₂ +…+ F_n = m*A

où les Fi sont des vecteurs forces appliqué sur le centre de gravité de l’objet, m est la masse de l’objet et 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. 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.

Figure 1 : cube avec une force de gravité

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 :

  NewPos = CurPos + h * CurSpeed

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…