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.