Discussion :

[forthx]

Bonjour,
Je me demandais par curiositée le nombre de polygone que peu prendre en charge une carte graphique de nos jours... et par la meme ocasion je me suis mis a l'opengl (donc je debute).

J'ai donc utilisé glGenLists pour generer une liste de ... 1 000 000 carrés !

Je tente un rendu et la paf je tourne environ a 10.3 fps ce qui me fait donc, si on considere qu'un carré est fait de deux polygones 20.6 millions de polygones rendu par seconde.

Et la gros doute : quant je rend des triangles je passe a 10.6 fps (et non 20.6) ! me sui je planté dans mon code?
En me basant la dessu, autre doute : les cartes de 2005 affichent 8 millions de triangles par seconde. Or je me doute que depuis il y a eu pas mal de changement. Par contre mon processeur graphique est a 100%.

Je travail avec jogl (je suis plutot a l'aise en java), j'utilise une ATI R.HD 5750.

Avez vous une idée du pourquoi de ces resultats? Y a t'il un moyen plus propre/optimisé d'implementer un tel rendu?

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
import [...]
 
public class SimpleScene implements GLEventListener {
 
private int list=0;
 
	public static void main(String[] args) {
		GLProfile glp = GLProfile.getDefault();
		GLCapabilities caps = new GLCapabilities(glp);
		GLCanvas canvas = new GLCanvas(caps);
 
		Frame frame = new Frame();
		frame.add(canvas);
		[...]
 
		canvas.addGLEventListener(new SimpleScene());
		FPSAnimator animator = new FPSAnimator(canvas, 60);
		animator.add(canvas);
		animator.start();
	}
 
	@Override
	public void display(GLAutoDrawable drawable) {
		render(drawable);
	}
 
	@Override
	public void init(GLAutoDrawable drawable) {
	//on met tout a 0 et on initialise la liste
		GL2 gl = drawable.getGL().getGL2();
		gl.glLoadIdentity();
		gl.glClear(GL.GL_COLOR_BUFFER_BIT);
		list = genlist(gl);
		gl.glShadeModel( GL2.GL_FLAT );
	}
 
	private void render(GLAutoDrawable drawable) {
	//on affiche le contenu de la liste et on le fait tourner
		GL2 gl = drawable.getGL().getGL2();
		gl.glClear(GL.GL_COLOR_BUFFER_BIT);
		gl.glCallList( list );
		gl.glRotatef(0.2f, 0.0f, 0.0f, 1.0f);
	}
 
	//om genere la liste de 1 000 000 rectangles (nb^2)
	private int genlist(GL2 gl){
		float nb = 1000;
		float x = -1;
		float y = -1;
		float fullPitch = 2/nb;
		float smalPitch = fullPitch/20;
		float largePitch = smalPitch*19;
		int list;
 
	    list = gl.glGenLists( 1 );
	    gl.glNewList( list, GL2.GL_COMPILE );
		gl.glColor3f(1, 1, 1);
	    for(int i=0;i<nb;i++){
			for(int j=0;j<nb;j++){		
				gl.glBegin(GL2.GL_QUADS);
				gl.glVertex2d(x+smalPitch,y+smalPitch);
				gl.glVertex2d(x+smalPitch,y+largePitch);
				gl.glVertex2d(x+largePitch,y+largePitch);
				gl.glVertex2d(x+largePitch,y+smalPitch);
				gl.glEnd();
				x=x+fullPitch;
			}
			y=y+fullPitch;
			x = -1;
		}   
	    gl.glEndList();
	    return list;
	}
}

J'ai tenter d'épurer le code (include et initialisation awt) au besoin je peu le mettre au complet.

[TNT89]

Code :

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

1
2
3
4
 
gl.glBegin(GL2.GL_QUADS);
[...]
gl.glEnd();

Le mode direct pour afficher une géométrie importante c'est pas ce qu'il y a de mieux (). Regarde du côté des VBO pour améliorer tes performances...

[math_lab]

C'est pas tout a fait du direct, vu que c'est sauvé dans une display list. Mais bon, les display list, c'est une vieille technologie qu'on est plus trop censé utiliser. Je conseille les Vertex Buffers, vu qu'ils peuvent être stockés directement sur le GPU si la géométrie est statique ou rarement mise a jour.

[forthx]

merci je vais me documenter la dessu.

[forthx]

bon j'ai tester avec les vbo, il me reste un mystère a résoudre, j'ai l'impression d’être limité par mon processeur (un core a 99%...)

Pour information avec la display list (sous linux) avec une carte nvidia (GeForce 9600 GT - 512MB) ca tourne a 59 fps, alors qu'avec ma ATI HD 5750 le même programme ne dépasse pas les 10-15 fps... étrange!

avec les vbo je suis a 22fps sur la GF9600GT (toujours avec mon million de quad indépendants dont chaque vertex possède sa couleur.) par contre je gagne une facilité de manipulation de mes objets. ce qui peu être pratique.

Je continue de voire ce que je peu optimiser, mais j'ai déjà idée que l'on puisse atteindre les 60 000 000 de polygones par seconde.


Merci pour vous pistes.

[math_lab]

Selon ce que tu veux faire avec ton mesh, tu peux surement désactiver quelques états d'OpenGL. Je pense surtout a la normalisation des normales qui doit bouffer un paquet). Le mieux est peut-être de passer par un shader qui ne fait que le strict minimum.