Discussion :

[bartmanb]

Bonjour à tous,

suite à un projet que je développe pour l'université, je dois afficher dans mon programme (à l'aide d'un tableau bi-dimensionnel stockant toutes les valeurs) plus de 77millions de pixels... Et c'est là que le bas blesse, l'affichage marche, certes c'est un peu long pour s'afficher, mais dès lors qu'il s'agit de déplacer la caméra et donc réaliser de nouveau un glutPostRedisplay pour refaire appel à la fonction d'affichage, j'ai droit encore au même temps d'attente... ainsi utiliser le programme devient vite frustrant (même les ventilos du pc ont chauds lool)

Alors ma question est assez simple : comment puis-je faire pour que l'affichage soit plus rapide afin que l'utilisation du programme devienne plus fluide.

Voici 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
 
void Draw_()
{
	Vec3 p;
 
	int pas_color ;
	float ind_color ;
 
	pas_color = floor((float)((abs(t->Elev_Min)+t->Elev_Max)/256));
        glPointSize(1);
	glBegin(GL_POINTS);
	for(int i=0; i< t->m_NL ; i=i++)
	{
		for(int j=0;j< t->m_NG; j=j++)
		{
			p.x = i ; p.y = 0 ; p.z = j;
			if ((frustum.pointInFrustum(p) != FrustumG::OUTSIDE))
			{
				if((t->ppTE[i][j]!=Zmin)&&(t->ppTE[i][j]!=Znc))
				{
					ind_color = ((float)(t->ppTE[i][j])/(float)(256*pas_color))*2;
					if(ind_color <= 1)glColor3f(ind_color,ind_color,ind_color);
					else glColor3f(1.,1.,1.);
					glVertex3f(i,0,j);
				}
			}
		}
	}
	glEnd();
}

Pour précision ici m_NL vaut 10801 et m_NG vaut 7201 d'où cette boucle sur plus de 77 millions de pixels. Comme vous pouvez le constater j'ai mis en place un frustrum culling pour optimiser l'affichage mais celà ne reste toujours pas satisfaisant,

Votre aide est donc comme toujours la bienvenue

Merci d'avance,

[TanEk]

Le probleme ici est que tu sollicites trop ton CPU et pas assez ton GPU. Je doute fort que ce que tu entendes soit le ventilo de ta carte graphique...

Pour eviter cela il faut que tu minimises les appels de fonction OpenGL (un appel OpenGL = une communication entre ton CPU et le GPU = tu passes a travers plusieurs couches systemes et tu passes a travers le bus pci express qui est pas un rapide, etc.).

De plus tu affiches ici les pixels les uns a la suite des autres ! Ton GPU peut afficher plusieurs milliers de pixels en meme temps et la tu lui dis : affiches moi ce pixel, puis celui-la, etc. bref tu utilises 1% de ton GPU la...

Pour eviter cela il faut que tu minimises le nombre d'appel OpenGL... Je te conseille donc de stocker ces 77 millions de pixels dans une texture OpenGL ca te fera une dizaine d'appels pour la copie et ensuite 1 ou 2 appels lors de l'affichage (tu ne fais la copie qu'une fois...).

Ensuite pour afficher ton image rien ne vaut un bon vieux carre qui sera texture par cette texture et tu verras ton tableau bi-dimensionnel s'afficher sur l'ecran (qui te prendra encore une vingtaine d'appels).

Donc en gros tu peux arriver a environ 20 appels OpenGL pour afficher ton image au lieu de quelques dizaines de millions, ton CPU sera plus content.

Regardes donc les tutoriels qui parlent de l'application de texture en OpenGL.

[bartmanb]

Ok je te remercie pour cette idée, si quelqu'un en connaît plus sur les textures en opengl je suis preneur, sinon j'essaierais de me débrouiller d'ici demain, et si je suis perdu de nouveau je reviendrais

En tout cas TanEK je te remercies encore, le ventilo que j'entends est bien celui du CPU je confirme lool je connais pas grand chose niveau texture, mais je vais me pencher sur le sujet, car ta piste m'a l'air forte intéressante, merci encore et je vous tiendrai au courant de l'évolution de mon problème

EDIT : Enfin la question que je me pose plutôt est : comment utiliser mon tableau bi-mensionnel pour créer la texture, parce que la plupart des sites expliquant l'application de textures se bsent sur des images à charger....

Merci encore d'avance

[bafman]

il faut que tu transforme ton tableau bidimensionnel en tableau unidimensionnel pour pouvoir l'envoyer à la carte graphique.

par contre, tu a sans doute interet à découper ta matrice en plusieurs sous matrices et donc faire plusieurs textures, ça sera plus souple pour l'affichage

[ShevchenKik]

Bonjour,

bafman, Tanek, est ce que vous pensez qu'utiliser un vertex array avec glDrawArrays(GL_POINTS,...), ou un VBO est aussi jouable? Plus ou moins rapide que l'utilisation d'une texture?

C'est juste une idée, mais c toujours bon d'etudier les différentes possibilités

[bafman]

c'est infiniment plus pourri que l'utilisation de texture