[information] GL_MAX_PROJECTION_STACK_DEPTH

Version imprimable

30/09/2004, 12h18
venomelektro

[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 ..)
30/09/2004, 17h09
Jbx 2.0b

ON VEUT DES NOMS !
01/10/2004, 17h15
bafman

mmm d'apres moi ca doit etre une carte intel ton truc car j'ai jamais rien rencontré de tel sur ATI ou NVidia... a moins que ce soit vraiment du tres tres bas de gamme et que les mec du marketing ai vraiment trop poussé l'economie.

sinon c'est vrai que ce serait cool d'avoir le nom histoire de se mefier :wink:

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

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 )

02/10/2004, 08h50
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...
02/10/2004, 12h21
venomelektro

Citation:

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"
04/10/2004, 12h31
bafman

un methode pourrait (enfin c'est juste une proposition vu que je ne connait pas ton prog :wink: ) etre d'avoir une fonction pour l'affichage en mode normal (3D) et a la fin de cette fonction tu en appel une autre qui elle gere l'affichage en mode ortho. ainsi tu sait que tout les appels de fonction dans le premiere sont en 3D, ce qui peut eviter de glPush/pop et de même pour l'affichage en 2D...

enfin c'est surtout une methode pour limiter les glPush/pop, je sait pas si ca resoudra ton probleme...

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:

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

06/10/2004, 13h05
bafman

moi ce que j'ai fait c'est que j'ai une fonction glDrawText2D(...) qui fait les operations sur les matrices (donc que je peut appeler quand je veut) et une autre glDrawText2Dortho(...) qui suppose qu'on est deja en mode ortho.

par contre je craint que tu ne soit quand même obligé de changer tout le code de ta GUI...
06/10/2004, 13h21
venomelektro

oui , c est ce que je vais faire je pense

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

Exemple :

Code:

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.

Citation:
Envoyé par olivic
Tu peux aussi gérer toi même ta pile de matrice.

Exemple :
Code:

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 :wink:

06/10/2004, 15h28
olivic
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:

1 2 3 4 5 glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMultMatrixf(projection_matrix_3D); ... // le code
Tu selectionne ton interface 2D ; cela donne :
Code:

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.