IN Synthèse d'Images Rendu - IUT d'Arles

IUT de Provence – Site d’Arles 2012 - 2013
Département d’Informatique
LP SIL IN
IN – Synthèse d’images
TP 4
Animation de feu d'artifice par système de particules
Nous allons maintenant utiliser des textures translucides au moyen d’images 32 bits. Chaque pixel
de ces images est codé sur un quadruplet RGBA où A est un octet indiquant le niveau d’opacité du
pixel : si A = 0 le pixel est complètement transparent ; si A = 255 le pixel est complètement
opaque ; entre les deux, le pixel est plus ou moins translucide.
On veut représenter un feu d'artifice par un système de particules (voir le chapitre 4 du cours) où
chaque particule correspondra à une étincelle. Les étincelles seront affichées au moyen de
quadrilatères sur lesquels on plaque la texture RGBA « etincelle.tga ».
Récupérez sur ma page web la base de ce TP.
Classe Etincelle
1. Ecrire une classe Etincelle pour représenter une étincelle, qui sera affichée au moyen d’un
quadrilatère texturé. Une étincelle est caractérisée par sa position (xpos, ypos, zpos : 3
float), sa taille (taille : 1 float, le quadrilatère étant carré), sa couleur (rouge, vert,
bleu : 3 float), sa vitesse de déplacement selon x, y et z (vitesse_x, vitesse_y,
vitesse_z : 3 float) et le temps qu’il lui reste à « vivre » en secondes (vie : 1 float).
Ecrire le constructeur de cette classe, permettant d’initialiser ces données.
2. Ecrire une méthode anime() de la classe Etincelle qui recevra en paramètre le temps
écoulé en secondes entre deux affichages :
void Etincelle::anime (float temps);
Elle permettra de modifier la position de l'étincelle en fonction du temps écoulé et de sa
vitesse :
nouvelle position = position courante + vitesse * temps
On réduira aussi le temps de vie restant de l'étincelle en lui soustrayant le temps écoulé.
3. Ecrire une méthode affiche() de la classe Etincelle, permettant d’afficher l'étincelle
au moyen d’un quadrilatère texturé :
void Etincelle::affiche();
1

On verra dans la question 8 comment faire pour toujours orienter ce quadrilatère face à
l’observateur, mais vous pouvez pour le moment lui donner une orientation fixe (par exemple
dans un plan z).
A la fin du TP, vous pourrez aussi modifier la transparence de l'étincelle en jouant sur la valeur
alpha grâce à glColor4f().
// Comme on ne veut pas que ce quadrilatère soit affecté
// par la lumière, on désactive l’éclairage juste avant
// de l’afficher, et on le réactivera juste après. Vous
// n’aurez donc pas besoin de spécifier la normale du
// quadrilatère
glDisable(GL_LIGHTING);
// On veut pouvoir voir les deux côtés du quadrilatère
glDisable(GL_CULL_FACE);
// On colore la texture
glColor4f(rouge, vert, bleu, alpha);
// On active le blending pour que la couleur de la texture
// se mélange à la couleur du reste de la scène dans des
// proportions données par la valeur alpha de chaque texel
// de la texture
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
// Affichage du quadrilatère texturé avec la texture RGBA
// glBegin(GL_QUADS)
// ...
// glEnd() ;
// On désactive le blending
glDisable(GL_BLEND);
// On reactive l’utilisation de la lumière
glEnable(GL_LIGHTING);
// Pour ne voir qu’un seul côté des polygones
// (affichage plus rapide)
glEnable(GL_CULL_FACE);
2

Classe Feu
4. Ecrire une classe Feu pour représenter le feu d'artifice constitué d'étincelles. Elle contiendra
les données membres suivantes :
- La position (x,y,z) de l’origine du feu d'artifices, là où il éclate en étincelles.
- Le nombre d'étincelles à générer lors de l'explosion.
- Une liste chaînée d’objets de classe Etincelle. On utilisera la classe list de la STL :
list liste_etincelles;
- Un pointeur sur un objet de classe Texture servant de texture pour les étincelles. Vous
chargerez la texture dans un objet de classe Texture dans le programme principal et
vous passerez son adresse au constructeur de l’objet de classe Feu.
5. Ecrire une méthode explose(float x, float y, float z, float vie_min,
float vie_max) de la classe Feu qui remplira la liste liste_etincelles avec des
objets de type Etincelle dont la position correspondra à celle du feu, avec des durées de
vie comprises aléatoirement entre vie_min et vie_max. On donnera initialement au vecteur
vitesse (vitesse_x, vitesse_y, vitesse_z) de chaque étincelle une direction
aléatoire, afin que les particules partent dans toutes les directions par rapport au centre de
l'explosion.
6. Ecrire une méthode anime() de la classe Feu qui recevra en paramètre le temps écoulé en
secondes entre deux affichages (variable globale dt du programme principal, à passer en
paramètre lors de l’appel de la méthode anime() dans la fonction affiche_scene() du
programme principal) :
void Feu::anime(float temps);
On décomposera cette fonction en deux étapes :
1. Suppression d'étincelles : on parcours la liste d'étincelles à la recherche de celles dont
la durée de vie s’est complètement écoulée (≤ 0). Si c’est le cas, elles seront
supprimées de la liste grâce à la méthode erase() de list :
list::iterator i;
i = liste_etincelles.begin();
while( i != liste_etincelles.end() )
{
if( i->duree_de_vie

7. Ecrire une méthode affiche() de la classe Feu qui affichera l’ensemble des étincelles de
la liste :
void Feu::affiche();
8. Les étincelles apparaissent comme plates si on regarde de côté les quadrilatères qui les
forment. Une solution est d’utiliser le principe de « billboarding », qui consiste à toujours
orienter le quadrilatère face à l’observateur.
Pour afficher en billboarding un quadrilatère de dimensions (largeur x hauteur) et centré
autour de (xpos, ypos, zpos), on peut procéder comme suit :
// On récupère le positionnement de la camera
float matrice [16];
glGetFloatv( GL_MODELVIEW_MATRIX, matrice );
Vector Haut, Droite;
Droite.x = matrice[0] * (largeur / 2.0f);
Droite.y = matrice[4] * (largeur / 2.0f);
Droite.z = matrice[8] * (largeur / 2.0f);
Haut.x = matrice[1] * (hauteur / 2.0f);
Haut.y = matrice[5] * (hauteur / 2.0f);
Haut.z = matrice[9] * (hauteur / 2.0f);
Vector A, B, C, D;
// On calcule la position des 4 sommets du quadrilatère
A.x = xpos + Haut.x - Droite.x;
A.y = ypos + Haut.y - Droite.y;
A.z = zpos + Haut.z - Droite.z;
B.x = xpos + Haut.x + Droite.x;
B.y = ypos + Haut.y + Droite.y;
B.z = zpos + Haut.z + Droite.z;
C.x = xpos - Haut.x + Droite.x;
C.y = ypos - Haut.y + Droite.y;
C.z = zpos - Haut.z + Droite.z;
D.x = xpos - Haut.x - Droite.x;
D.y = ypos - Haut.y - Droite.y;
D.z = zpos - Haut.z - Droite.z;
// Affichage du billboard
glBegin(GL_QUADS);
glVertex3f(D.x,D.y,D.z);
glVertex3f(C.x,C.y,C.z);
glVertex3f(B.x,B.y,B.z);
glVertex3f(A.x,A.y,A.z);
glEnd();
4