[information] GL_MAX_PROJECTION_STACK_DEPTH

Salut,


en testant quelque uns de mes programmes , j ai ete surpris de rencontrer des GL_STACK_OVERFLOW sur certaines appli utilisant des projections en 2d ,

et j ai ete encore plus surpris de constater que certaines cartes dont je ne donnerais pas le nom utilise une taille de pile de matrices en mode projection de 2 ( oui deux ! GL_MAX_PROJECTION_STACK_DEPTH == 2 ! ! ! )

le plus delirant est que cette carte supporte la version 1.3.0 d openGL donc est censé etre pas trop en retard techniquement non plus..

concretement si vous appellez plus de 2 fois glPushMatrix() en mode projection votre programme va avoir des bugs largement visible , donc mefiez vous ( sachant que ce genre de carte est monté d origine sur des machines récentes d un constructeur fort connu ..)

ON VEUT DES NOMS !

bon j avais dis que je donnerais pas de nom mais sous la pression je cede

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
 
OpenGL info :  
Video Hardware   : Intel Springdale-G 
Vendor           : Intel 
Open GL version  : 1.3.0 - Build 4.13.10.3510 
 
CPU INFO
 
CPU FREQUENCY : 2593.654521 MHZ 
CPU VENDOR : GenuineIntel 
CPU BRAND NAME :               Intel(R) Pentium(R) 4 CPU 2.60GHz 
 
open gl constants 
 
 
GL_MAX_TEXTURE_SIZE 2048  
GL_MAX_PROJECTION_STACK_DEPTH 2  
GL_MAX_MODELVIEW_STACK_DEPTH 32

ce qui impressionnant c est que meme une carte qui emule openGL en soft "GDI Generic" à GL_MAX_PROJECTION_STACK_DEPTH à 10

c est à n y rien comprendre

mefiance donc sur ces cartes , malheuresement assez courantes (stations D**L )

Envoyé par bafman

houéééé !!! j'avait raison !!!
bon plus serieusement c'est vraiment impressionnant de voire des spec comme ca sur une carte openGL 1.3...
deja rien que la taille max des textures fait se poser des questions...

m en parle pas , je suis en train de rustiner mon code de partout pour faire tourner mon prog sur ces cartes "openGL"

effectivement c deja comme cela que je procede ,

le probleme j ai que j ai une classe d affichage de texte TTF ou le code resemble a ca :

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
 
void DLLFUNC VGL_TTF_Font::Print(int x, int y, const char *fmt , ...)
	{
	va_list ap;
 
	unsigned char buffer[256];
 
	// Allow formatted output
	va_start(ap, fmt);
	vsprintf((char*)buffer, fmt, ap);
	va_end(ap);
 
	int l = strlen((char*)buffer);
 
	if (x == VGL_CENTER_X) {
 
		float width = 0;
		for (int z=0;z<l;z++) width+=(widths[z]/1.33f)*scale;
		x = 400 - (int)(width/2);
	}
 
	tex->Bind();
 
	glBlendFunc(GL_SRC_ALPHA,GL_ONE);
	glEnable(GL_BLEND);	   
	glDisable(GL_CULL_FACE);
	glDisable(GL_DEPTH_TEST);
	glMatrixMode(GL_PROJECTION);	// matrice 2d 				
	glPushMatrix();	// pousse la matrice sur la pile 									
	glLoadIdentity();								
	glOrtho(0,800,0,600,-1,1);	// un plan de 800*600 pixels 						
	glMatrixMode(GL_MODELVIEW);						
	glPushMatrix();										
	glLoadIdentity();							
	glBegin(GL_QUADS);
			for(int a = 0; a < l; a++)
			{
				unsigned char c = buffer[a];
 
				glTexCoord2fv(coords[c][0]); glVertex2f(x, y + height);
				glTexCoord2fv(coords[c][1]); glVertex2f(x + widths[c], y + height);
				glTexCoord2fv(coords[c][2]); glVertex2f(x + widths[c], y);
				glTexCoord2fv(coords[c][3]); glVertex2f(x, y);
				x += widths[c];
			}
	glEnd();
 
	glMatrixMode(GL_PROJECTION);						
	glPopMatrix();										
	glMatrixMode(GL_MODELVIEW);							
	glPopMatrix();									
	glEnable(GL_DEPTH_TEST);							
	glDisable(GL_BLEND);
 
}

Alors evidemment des que je commence a l appeller alors que je suis deja en mode 2d les problemes sont pas loin

Le probleme est que ce code est appellé dans un tas de classe que j ai depuis un momment qui servent a gerer une GUI et bon c est pas tres rigolo de tout changer juste pour ces cartes

oui , c est ce que je vais faire je pense

Tu peux aussi gérer toi même ta pile de matrice.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
GLfloat matrix[16];
 
glMatrixMode(GL_MODELVIEW);
glGetFloatv(GL_MODELVIEW_MATRIX, matrix) // sauvegarde de la matrice courante
 
glLoadIdentity();
glMultMatrixf(new_matrix); // on applique la nouvelle matrice
 
... // le traitement
 
glLoadIdentity();
glMultMatrixf(matrix); // on remet la matrice dans son état initial

Bien sur, tu peux faire pareil avec les autres matrices.

Envoyé par olivic

Tu peux aussi gérer toi même ta pile de matrice.

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
GLfloat matrix[16];
 
glMatrixMode(GL_MODELVIEW);
glGetFloatv(GL_MODELVIEW_MATRIX, matrix) // sauvegarde de la matrice courante
 
glLoadIdentity();
glMultMatrixf(new_matrix); // on applique la nouvelle matrice
 
... // le traitement
 
glLoadIdentity();
glMultMatrixf(matrix); // on remet la matrice dans son état initial

Bien sur, tu peux faire pareil avec les autres matrices.

oui , j ai pensé aussi a cette technique , en fait je m etais meme dit de creer une classe qui checke la taille de la pile de matrice supporté par le GPU , et utiliser des foctions VGL_PopMatrix et VGL_PushMatrix qui checke si on est arrivé a la limite du stack overflow et dans ce cas utilise un code similaire a celui que tu as posté

mais bon c toujours pareil c lourd de faire ca rien que pour des cartes qui ont une pile de 2 , car le code de ma GUI fera exploser une pile de 10 (ou + ) de ci tot

Une possibilité d'éviter des push pop intenpestif est de pre calculer tes matrices.

Je m'explique :

une interface 3D --> une matrice de projection
une interface 2D --> une matrice de projection

Généralement, ces matrices ne sont modifiées que lorsque tu changes de résolution.

Tu créés ces matrices à la création de l'application.
Tu modifies ces matrice à chaque changement de résolution.

Tu selectionne ton interface 3D ; cela donne :

Code :

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

1
2
3
4
5
 
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMultMatrixf(projection_matrix_3D);
... // le code

Tu selectionne ton interface 2D ; cela donne :

Code :

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

1
2
3
4
5
 
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMultMatrixf(projection_matrix_2D);
... // le code

En définitive, tu applique ta matrice à chaque fois que tu en as besoin en écrasant systématiquement la précédente.

C'est très efficace pour la matrice de projection mais tu ne peux pas éviter les push/pop ou équivalent dans des fonctions similaires à l'affichage de texte à l'écran. Ou du moins, cela ne reste pas très propre ni très lisible.

Par contre pour la matrix du model, il est plus difficile de supprimer les push/pop mais cela n'est pas infaisable. On peut par exemple utiliser le même mécanisme si on dispose de la matrice de chaque objet déplaçable. Ces matrices devront être recalculer pendant l'animation tous en restant indépendante de l'affichage. On plus simplement, qu'il ne faut surtout pas manipuler ces matrices pendant l'utilisation de celle-ci par l'affichage.

Avec ces techniques, tu peux supprimer la quasi totalité des push/pop de ton application.

Il existe probablement d'autre méthode.