Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox
EN CHANTIER
Cette page n'est pas terminée et est en cours d'écriture. Merci de votre patience.

Menu général

Compatible ActionScript 3. Cliquer pour en savoir plus sur les compatibilités.Par Monsieur Spi, le 24 septembre 2010

Mode7 : Sprites et objets

Nous avons défini le point de vue de la projection (la caméra), la position du plan dans l’espace (le sol), les effets possibles pour renforcer la perspective et jouer avec le ciel et la gestion des surfaces pour le moteur.

A présent il faut rajouter des objets sur le terrain de jeu, que ce soit des objets fixes comme un baril ou des pneus ou des objets animés, comme par exemple d’autres joueurs ou le joueur lui même.

Si le processus de placement des objets n’est pas compliqué en soit il nécessite tout de même de passer par certaines étapes indispensables au bon fonctionnement de l’ensemble.

N’oubliez pas que nous ne travaillons pas réellement dans un univers en trois dimensions mais sur un plan en deux dimensions que nous avons déformés.

Bien que semblant liés à l'écran l'affichage du terrain et celui des sprites utilisent des techniques distinctes. Dans un jeu vidéo en deux dimensions on se sert de ce que l’on appelle des sprites pour afficher les objets. Ce sont des suites d’images sensées représenter un objet en mouvement ou fixe (dans ce cas une seule image suffit).

Or le moins que l’on puisse dire c’est que la 3D (ou du moins la perspective) et les sprites (plats) forment une étrange combinaison. Par leur nature les sprites sont des images en deux dimensions, pour les rendre réalistes dans un monde en trois dimensions nous allons devoir les déplacer et les orienter à l’écran en fonction de la manière dont ils sont sensés se déplacer sur le plan puis les mettre à l’échelle en fonction de leur position sur le plan et par rapport à la caméra.

Positionnement et ancrage

Positionner un sprite comporte deux facettes.
La première consiste à transposer sa position sur le plan en une position sur l’écran.

Un sprite est une image donc un rectangle dont la surface en contact avec le sol est une ligne composée de multiples points. Nous avons besoin de connaitre avec précision un point unique de référence qui lie le sol et le sprite. Pour cela il est possible de définir le point d’ancrage, c’est à dire le point précis du sprite qui correspond exactement à sa position sur le plan.

Lorsqu’on affiche le sprite à l’écran il faut prendre en compte cette position relative pour le repositionner correctement.

"Culling"

Le “culling” ou détermination des surfaces cachées est une opération qui consiste à ne pas afficher tout ce qui se trouve en dehors du “viewing frustum” (Tronc - la zone visible à l’écran).

Il est inutile de surcharger l’affichage donc tout ce qui n’est pas dans la zone visible n’est tout simplement pas ou plus affiché.

La première chose à faire c’est de vérifier la distance d’affichage de l’objet, si il est trop loin alors on ne peut plus le voir, il n’est donc pas affiché.

On peut également vérifier si l’objet est trop prés de la caméra, dans ce cas il n’est pas affiché non plus ou remis à une échelle spécifique.

Ensuite il faut vérifier sa position relative au champ de vision, si l’objet n’est pas dans la zone visible il n’est pas affiché. A ceci près qu’un objet est représenté par un sprite, donc un rectangle, il faut donc cette fois vérifier la position du rectangle et non pas seulement celle de l'ancre si on veut éviter d'avoir des objets qui entrent ou sortent brutalement de l'écran. Un objet n'est pas affiché si il est complétement en dehors de la zone visible (viewing frustum).

Animation

Jusqu’à présent notre sprite ne présente qu’une seule face, toujours la même, de n’importe quel point d’où on le regarde. C’est tout à fait logique, un sprite est une image pas un objet en trois dimensions. Pour donner l’illusion que l’objet représenté est en trois dimensions nous allons utiliser une série de sprites, un pour chaque angle de vue.

En fonction de l’angle sous lequel la caméra observe le sprite, on affiche une image différente.
Seulement cette méthode est valable pour des objets fixes, c’est à dire que l’objet ne change jamais d’orientation et que la caméra se contente de tourner autour. Si l’on souhaite qu’un objet puisse avoir sa propre mobilité il ne faut plus qu’il se positionne uniquement en fonction de la caméra mais également en fonction de sa propre orientation sur le plan.

Prenons un exemple toujours avec Super Mario Kart.
En fonction du circuit un kart peut très bien se trouver dans la même direction que vous, par exemple face à vous, mais être orienté dans deux sens opposés, il va vers vous ou vous devance.

Le résultat affiché correspond à la combinaison de ces deux orientations, à savoir l’orientation générale du sprite sur le plan et son orientation par rapport à la caméra.

A présent que nous connaissons le point de vue du sprite, il faut encore savoir à quelle image il correspond. Imaginons que nous ayons X images représentant la rotation d’un objet sur son axe, chaque image représente une portion d’un cercle découpé en X sections égales (ou pas).

L’angle de rotation de l'objet donne l’image à afficher à l’aide de la portion du cercle dans lequel il se trouve. On peut utiliser une image par angle de vue, mais ont peut aussi utiliser la technique du miroir, qui consiste en l’inversion d’une image sur un axe.

On gagne ainsi un grand nombre d’images et d’opérations inutiles. En fonction de la direction de l’objet on inverse simplement l’affichage de l’image.

Il nous reste 12 images représentant la rotation de l’objet sur 180 degrés atour d’un axe. Avec le miroring on obtient un cercle composé de 24 tranches, 12 affichent l’image normalement et 12 affichent la même image mais inversée.

Mais vous remarquerez que deux de ces images sont identiques quel que soit l’axe choisi, il s’agit de la vue de face et celle de dos, inverser ces images n’aurait pas de sens, nous avons donc 2 images valables pour les deux côtés et deux fois 9 images inversables situées de chaque côté d’un cercle, soit au total 20 images et non 24.

Dans le cas de notre exemple nous avons 20 images réparties sur un cercle de 360 degrés, soit des portions de 18 degrés d’arc de cercle par image.

Ordre d'affichage

Dans les jeux 2D le problème de l’ordre d’affichage (ou Z-sorting) apparaît rarement puisque tous sprites sont posés sur le même plan. Vous ne l’utiliserez que partiellement lorsque certains de vos objets doivent passer derrière le décor. Mais dans les jeux en 3D (ou pseudo 3D) vous ne pouvez tout simplement pas vous en passer.

Le problème se pose lorsqu’il y a plus d’un objet à afficher à l’écran (presque tout le temps en fin de compte), il est impératif de savoir quel objet se trouve devant l’autre si on veut respecter la perspective.

Prenons un exemple tiré de Super Mario Kart.

Dans les exemples ci-dessus les 4 pierres ont un ordre spécifique fixé au départ.
A gauche la pierre la plus proche de la caméra est bien placée avant la plus éloignée, la perspective est respectée.

Mais si on place la caméra de l’autre côté et qu’on regarde les pierres “par derrière” on obtient la figure 2, l’ordre n’est plus bon et la pierre la plus proche est affichée derrière la plus éloignée. Pour corriger çà dans la figure 3, il faut réaffecter l’ordre d’affichage des objets lorsque l’on change de position. Il suffit souvent pour cela de vérifier la distance entre chaque objet et la caméra, les plus proches couvrant les plus éloignés.

Ce qu’il faut faire c’est classer les objets affichés par ordre d’affichage, une sorte de z-buffer pour les objets (voir aussi : l’algorithme du peintre). Le niveau d’affichage du sprite dépend essentiellement de sa position par rapport à la caméra.

Normalisation

Nous avons déjà mis les sprites à l’échelle mais cela ne sera pas suffisant.
Dans bien des cas vous serez obligés de les mettre de nouveau à une échelle différente.

Par définition l’échelle est de 1 lorsque la distance entre la caméra et l’objet est la même que celle entre la caméra et l’écran de projection. Mais que se passe il dès que l’objet est plus proche de la caméra que ne l’est l’écran de projection, par exemple la moitié de la distance : 0.5*D ?

Dans ce cas l’échelle est de 0.5 et l’objet va être agrandi par un facteur de 2.
Or dans ce cas le sprite se trouve juste devant vous à une taille plus grande que sa taille d’origine (x2 dans notre cas) non seulement il sera pixellisé (enfin plus que d’habitude) mais en plus il risque fort de vous empêcher de voir ce qui se trouve devant vous.

L’échelle des sprites affichés est modifiée dès que la caméra bouge ou que le sprite bouge, il faut imposer des normes (d’où la normalisation) qui vont imposer aux sprites de ne pas dépasser une certaine échelle, qu’ils soient près comme nous venons de le voir mais aussi lorsqu’ils sont loin comme nous l’avons vu un peu plus tôt dans cette page.

Enfin, bien souvent dans un jeu de ce type, le joueur est représenté visuellement à l’écran, si on prend l’exemple de l’image illustrant cette page (Super Mario Kart) on peut voir clairement que le kart de Mario représente le joueur, la caméra est donc située derrière le joueur, ce qui change l’échelle pour les sprites qui doivent alors se rapporter à l’échelle donnée par le kart de Mario, le niveau 1 de l’échelle n’est alors plus la position de l’écran mais celle du kart qui représente le joueur.

Conclusion

C'est une conclusion temporaire que je vous propose ici.
Il y a encore beaucoup à dire sur le sujet mais le monde ne s'est pas fait en un jour ;-)

J'espère que ces quelques explications pourront vous servir et que vous en avez apprécié la lecture.
J'espère aussi ne pas m'être trompé, je compte sur vous pour apporter des corrections si elles s'imposent.

Bons jeux à tous.