Discussion :

[GruZloR]

Salut,
Je suis en ce moment sur la conception d'un petit labyrinthe en C. Je suis loin d'être au point niveau programmation (je me lance) et je voulais savoir s'il était déconseillé de concaténer des vertex array dans une display list. Parce que depuis que j'utilise ces deux trucs, je trouve que mon pgm tourne moins bien. Je ne suis pas sûr d'avoir tout mis au bon endroit et correctement.
Voici ma fonction qui crée ma display list qui est ensuite appelée (la display list) dans ma fonction d'affichage.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
void init_display_princ(){
int i,j;
GLUquadricObj *t;
t=gluNewQuadric();
gluQuadricNormals(t, GLU_FLAT);
gluQuadricTexture(t, GL_TRUE);
 
 
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
liste_labyrinthe=glGenLists(1);
glNewList(liste_labyrinthe,GL_COMPILE);
 
for (i=0; i<=dim_n-1;i++)
	{
for (j=0; j<=dim_m-1;j++)
		{
		glPushMatrix();
		glTranslatef(i,j,0);
		/*le sol*/
		glInterleavedArrays    (GL_T2F_V3F, 0, &inter_sol);
		glBindTexture(GL_TEXTURE_2D, texName[0]);
		glNormal3i(0,0,1);
		glDrawElements (GL_QUADS,4,GL_UNSIGNED_BYTE,indices_sol );
		/*le plafond*/
		glInterleavedArrays    (GL_T2F_N3F_V3F, 0, &inter_plafond);
		glBindTexture(GL_TEXTURE_2D, texName[2]);
		glDrawElements (GL_TRIANGLE_FAN,8,GL_UNSIGNED_BYTE,indices_plafond);
		/*les poutres*/
		glVertexPointer(3,GL_FLOAT,0,poutres);
		glBindTexture(GL_TEXTURE_2D, texName[3]);
		glNormal3f(0.0f,0.0f,-1.0f);
		glDrawElements (GL_QUAD_STRIP, 10, GL_UNSIGNED_BYTE, indices_poutres);
 
		if(univers[i][j].mur==1)
		{
		/*les murs*/
		glInterleavedArrays    (GL_T2F_V3F, 0, &inter_mur);
		glBindTexture(GL_TEXTURE_2D, texName[1]);/*Pose des murs*/
		glNormal3i(-1,0,0);
		glDrawElements (GL_QUADS,4,GL_UNSIGNED_BYTE,face_indices );
		glNormal3i(0,1,0);
		glDrawElements (GL_QUADS,4,GL_UNSIGNED_BYTE,gauche_indices );
		glNormal3i(1,0,0);
		glDrawElements (GL_QUADS,4,GL_UNSIGNED_BYTE,droite_indices );
		glNormal3i(0,-1,0);
		glDrawElements (GL_QUADS,4,GL_UNSIGNED_BYTE,derriere_indices );
		glBindTexture(GL_TEXTURE_2D, texName[3]);
		glPushMatrix(); 
		glTranslatef(0,0,0);
		gluCylinder(t,0.062,0.062,2,6,8); 
		glPopMatrix();
		glPushMatrix(); 
		glTranslatef(1,0,0);
		gluCylinder(t,0.062,0.062,2,6,8); 
		glPopMatrix();
		glPushMatrix(); 
		glTranslatef(0,1,0);
		gluCylinder(t,0.062,0.062,2,6,8); 
		glPopMatrix();
		glPushMatrix();
		glTranslatef(1,1,0);
		gluCylinder(t,0.062,0.062,2,6,8); 
		glPopMatrix();
		}
		glPopMatrix();
		}}
glEndList();
gluDeleteQuadric(t);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}

Je vous mets l'adresse du pgm en question pour vous faire une idée du biniou:
http://gruselle.free.fr/labyrinthe/laby_avec%20VA.c

Si vous avez d'autres remarques, elles sont bien sûr les bienvenues.
Merci

[bafman]

je me demande (a verifier) si il n'y a pas un risque a utiliser des vertex array dans des display list, car le vertex array et stocker au niveau du client alors que les display list sont au niveau serveur (ne pas oublier qu'openGL a une structure client/serveur), ce qui peut potentiellement poser des problemes... mais je ne suis vraiment pas sure de mon coup la...
a verifier dans le red book

[gybe]

Il n'y a pas de problème à compiler un vertex array dans une display list, sauf qu'ici il y a tellement de trucs pas rapport de fait dans la display list que le ne pense pas que le driver va être capable de cacher le data en mémoire vidéo.

[dabeuliou]

Je rebondis sur ce sujet pour tenter d'éclaircir un point sur lequel je m'interroge : le redbook et la documentation que l'on trouve sur internet sur glVertexPointer (par exemple) dit "The glVertexPointer subroutine is not included in display lists."
Je peux comprendre cette phrase de deux manières:
* Appeler glVertexPointer alors qu'on est dans un bloc glNewList / glEndList va brancher le tableau de vertex sur le pointeur passé pour ensuite pouvoir lire les coordonnées des sommets depuis ce tableau. La liste qu'on compile utilisera bien les sommets du tableau.
Mais si les valeurs dans le tableau changent entre deux affichages de la liste ainsi compilée il n'y a aucun espoir de voir les vertex de la liste refléter les changements dans le tableau. Il faudrait pour cela recompiler la GL list.
* Appeler glVertexPointer alors qu'on compile une GL list a un comportement indéfini voire va planter à tous les coups. Il ne faut donc jamais le faire et se débrouiller pour brancher les tableaux OpenGL AVANT l'appel de glNewList.

Autant la première version me paraît logique autant la seconde me poserait plus de problèmes. La documentation n'est pas assez précise pour m'aider. Est-ce que quelqu'un sait quelle interprétation est la bonne ?

Merci d'avance !