[LWJGL] Performance avec Java/LWJGL

Version imprimable

Bonjour à tous,

Je viens de découvrir LWJGL permettant de faire de l'OpenGL en Java. J'ai lu quelques tutoriels et commencer à programmer un ch'tit programme me permettant de me déplacer sur un damier en 3D (un truc un peu moche).

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
 
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.util.glu.GLU;
 
import static org.lwjgl.opengl.GL11.*;
 
public class Test extends Thread {
 
 
	public static void main(String[] args){
		// Creation de la fenetre d'affichage
		int width=800;
		int height=600;
		int depth=16;
		try {
			DisplayMode modes[] = Display.getAvailableDisplayModes();
			for(DisplayMode currentMode : modes) {
				if(currentMode.getWidth() == width &&
						currentMode.getHeight() == height &&
						currentMode.getBitsPerPixel() == depth) {
					Display.setDisplayMode(currentMode);
					break;
				}
			}
			Display.setTitle("GameTest");
			Display.setLocation(10, 10);
			Display.create();
			Display.sync(100);
			GLU.gluPerspective(45,16/9,0,10);
		}
		catch(Exception e) {
			Sys.alert("Erreur","Une erreur est survenue lors de la création de l'affichage : " + e);
			System.exit(1);
		}
 
		float posX = 0;
		float posY = 0;
		float posZ = 0;
		float yAngleRad = 0;
		float yAngleDeg = 0;
		int caseMax = 10;
		// Boucle tant que la fenetre n'est pas fermee
		while(!Display.isCloseRequested()){
			glClear(GL_COLOR_BUFFER_BIT);
			glLoadIdentity();
			GLU.gluPerspective(45,16/9,0,100);
 
			// Affichage d'un triangle (a gauche)
			glBegin(GL_TRIANGLES);
				glVertex3f(-0.39f, 0f, -1f);
				glVertex3f(-0.41f, 0f, -1f);
				glVertex3f(-0.41f, 0.1f, -1f);
			glEnd();
 
			yAngleRad = (float)Math.toRadians(yAngleDeg);
			if(Keyboard.isKeyDown(Keyboard.KEY_UP)) {
				posZ += 0.001f*Math.cos(yAngleRad);
				posX -= 0.001f*Math.sin(yAngleRad);
			}
			if(Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
				posZ -= 0.001f*Math.cos(yAngleRad);
				posX += 0.001f*Math.sin(yAngleRad);
			}
			if(Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
				yAngleDeg -= 1f;
			}
			if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
				yAngleDeg += 1f;
			}
			if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
				yAngleDeg += 1f;
			}
			if(Keyboard.isKeyDown(Keyboard.KEY_ADD)) {
				caseMax += 1;
			}
			if(Keyboard.isKeyDown(Keyboard.KEY_DIVIDE)) {
				caseMax -= 1;
			}
			// Rotation puis translation suivant le deplacement
			glRotatef(yAngleDeg,0,1,0);
			glTranslatef(posX, posY, posZ);
 
			// Affichage du damier
			float size = 0.01f;
			for(int i=-caseMax;i<caseMax;i++) {
				for(int j=-caseMax;j<caseMax;j++) {
					glBegin(GL_LINES);
						glVertex3f(
								0f+i*size,
								-0.005f,
								-0.01f+size*j);
						glVertex3f(size+i*size,
								-0.005f,
								-0.01f+size*j);
						glVertex3f(0f+i*size,
								-0.005f,
								-0.01f+size*j);
						glVertex3f(0f+i*size,
								-0.005f,
								-0.01f+size+size*j);
					glEnd();
				}
			}
			Display.update();
 
			// Affichage du nombre de case
			Display.setTitle("GameSample - NbCases : "+(caseMax*caseMax));
		}
	}
 
}

Sur le programme que j'ai fournit, il faut appuyer sur la touche + du pavé numérique pour augmenter le nombre de carré du damier. Le titre de la fenêtre se met à jour indiquant le nombre de carré composant le damier. Les flèches permettent de se déplacer.

Quelque chose m'inquiète...
Les performances dégringolent excessivement rapidement. A partir de 10.000 carrés, le ralentissement est énorme.

Ce qui me fait dire que...
Soit Java n'est pas très performant pour la 3D.
Soit j'ai codé comme un crado.

Etant donné les démo que j'ai pu voir sur LWJGL, je pencherais plutôt pour la 2eme solution :)

Quelqu'un a-t-il une idée de la manière dont il faut procéder pour améliorer le programme fournit ?

Merci d'avance pour vos réponses :)

24/06/2009, 19h37
plegat

Salut

Citation:

Envoyé par Mike Reason

Quelque chose m'inquiète...
Les performances dégringolent excessivement rapidement. A partir de 10.000 carrés, le ralentissement est énorme.

Ce qui me fait dire que...
Soit Java n'est pas très performant pour la 3D.
Soit j'ai codé comme un crado.

Etant donné les démo que j'ai pu voir sur LWJGL, je pencherais plutôt pour la 2eme solution :)

Affichage direct + calculs en pagaille dans la boucle d'affichage, faut pas chercher plus loin...

Regarde les tutos opengGL, tu auras toutes les techniques pour accélérer l'affichage (à commencer par arrêter de coder comme un crado :aie: ): display list, arrays, VBO, etc etc
25/06/2009, 08h56
Mike Reason

Salut,

Merci pour ta réponse.

Justement, me suis inspiré de ce qu'on peut trouver sur le site de LWJGL :
http://lwjgl.org/wiki/doku.php/lwjgl...gl/basicopengl

Les appels aux fonctions sont de manière séquentielle. J'ai tenté de modifier le programme en fonction, mais en fait, ça revient au même (niveau perf.) :!:

Je me doute bien qu'il y ait des techniques pour améliorer et accélérer l'exécution du code. Seulement, je n'ai pas trouver de tuto qui parle de ça.

En fait, dans les différents tutoriels, on passe d'un code simple, comme celui que j'ai écrit, à un code qui fait des millions de lignes. Je n'ai pas trouvé de tuto qui explique étape par étape...

As tu un lien à me proposer (mis à part Google :D ) :question:
25/06/2009, 12h32
plegat

Citation:

Envoyé par Mike Reason

Les appels aux fonctions sont de manière séquentielle. J'ai tenté de modifier le programme en fonction, mais en fait, ça revient au même (niveau perf.) :!:

Tu auras beau découper en fonctions, si tu continues à les appeler dans la boucle d'affichage, ça ne change rien. La boucle d'affichage sert à afficher, pas à calculer ce que tu vas afficher. Ca, ça doit être fait avant. Tu penses bien que le temps passé à calculer, c'est du temps à attendre entre l'affichage de deux points...

Citation:

Envoyé par Mike Reason

En fait, dans les différents tutoriels, on passe d'un code simple, comme celui que j'ai écrit, à un code qui fait des millions de lignes. Je n'ai pas trouvé de tuto qui explique étape par étape...

Un tutoriel sert à expliquer une technique, pas à décrire comment coder une appli d'un million de lignes. C'est à toi de construire ton code en assemblant les briques.
D'un autre côté, utiliser les VBO pour afficher un quad, c'est un peu sortir la pelleteuse pour ramasser une déjection de chihuahua. Mais les tutos simples sur les VBO existent.

Citation:

Envoyé par Mike Reason

As tu un lien à me proposer (mis à part Google :D ) :question:

Google regorge de liens pourtant...
Sinon, tu as regardé la section OpenGL du site?

Ok, j'ai suivi un tutoriel Java (très bon tutos d'ailleurs). Ce qui est dommage, c'est que je n'en ai pas trouvé pour LWJGL.

Une question qui me tracasse tout de même... Si j'ai bien compris :
- Display List = RAM du PC -> Carte Graphique -> Ecran
- VBO = RAM de la carte graphique -> Ecran

Pourtant... que j'utilise des display list ou des VBO, je n'ai aucune différences au niveau des performances... Est ce normal ... :question:

Je mets mon code au cas où quelqu'un pourrait voir ce qui ne va pas :question:

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
 
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.ARBVertexBufferObject;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.DisplayMode;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.Timer;
import org.lwjgl.util.glu.GLU;
 
import static org.lwjgl.opengl.GL11.*;
 
public class TestVBO extends Thread {
 
	static float posX = 0;
	static float posY = 0;
	static float posZ = 0;
	static float yAngleRad = 0;
	static float yAngleDeg = 0;
	static int useDisplay = 0;
	static float totalTime = 0;
	static float lastTime = 0;
	static int iteration = 1;
 
	static int caseMax = 200;
 
	public static void keyBoard() {
		yAngleRad = (float)Math.toRadians(yAngleDeg);
		if(Keyboard.isKeyDown(Keyboard.KEY_UP)) {
			posZ += 0.001f*Math.cos(yAngleRad);
			posX -= 0.001f*Math.sin(yAngleRad);
		}
		if(Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
			posZ -= 0.001f*Math.cos(yAngleRad);
			posX += 0.001f*Math.sin(yAngleRad);
		}
		if(Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
			yAngleDeg -= 1f;
		}
		if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
			yAngleDeg += 1f;
		}
		if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
			yAngleDeg += 1f;
		}
		if(Keyboard.isKeyDown(Keyboard.KEY_DIVIDE)) {
			useDisplay++;
			useDisplay = useDisplay%3;
			iteration = 0;
			totalTime = 0;
			try { sleep(500); } catch(Exception e) { }
		}
	}
 
	public static void main(String[] args){
		int width=800;
		int height=600;
		int depth=16;
		try {
			DisplayMode modes[] = Display.getAvailableDisplayModes();
			for(DisplayMode currentMode : modes) {
				if(currentMode.getWidth() == width &&
						currentMode.getHeight() == height &&
						currentMode.getBitsPerPixel() == depth) {
					Display.setDisplayMode(currentMode);
					break;
				}
			}
			Display.setTitle("GameTest");
			Display.setLocation(10, 10);
			Display.create();
			Display.sync(100);
	        glLoadIdentity(); // Reset The Projection Matrix
			GLU.gluPerspective(45,16/9,0,10);
		}
		catch(Exception e) {
			Sys.alert("Erreur","Une erreur est survenue lors de la création de l'affichage : " + e);
			System.exit(1);
		}
		initVBO();
		Timer t = new Timer();
		while(!Display.isCloseRequested()){
			glClear(GL_COLOR_BUFFER_BIT);
			glLoadIdentity();
			GLU.gluPerspective(45,16/9,0,100);
			glBegin(GL_TRIANGLES);
				glVertex3f(-0.39f, 0f, -1f);
				glVertex3f(-0.41f, 0f, -1f);
				glVertex3f(-0.41f, 0.1f, -1f);
			glEnd();
			keyBoard();
			iteration++;
			glRotatef(yAngleDeg,0,1,0);
			glTranslatef(posX, posY, posZ);
			drawVBO();
			Display.setTitle("VBO");
			glColor3f(1,1,1);
			glBegin(GL_TRIANGLES);
				glVertex3f(-0.015f, -0.01f, -0.01f);
				glVertex3f(-0.01f, -0.01f, -0.01f);
				glVertex3f(-0.01f, 0.01f, -0.01f);
			glEnd();
			Timer.tick();
			totalTime += (t.getTime()-lastTime)*1000;
			lastTime = t.getTime();
			Display.setTitle(Display.getTitle()+" - AVG : "+
					Math.round(totalTime/iteration));
			Display.update();
		}
	}
 
	public static FloatBuffer vertices = null;
	public static FloatBuffer colors = null;
	public static int vertexBufferID = 0;
	public static int colorBufferID = 0;
 
	public static void initVBO() {
		float[] verticesFloat = new float[caseMax*caseMax*6*4*3];
		float[] colorsFloat = new float[caseMax*caseMax*6*4*3];
		float size = 0.01f;
		for(int i=-caseMax+1;i<caseMax+1;i++) {
			for(int j=-caseMax+1;j<caseMax+1;j++) {
 
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+0] = 0f+i*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+0] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+1] = -0.005f;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+1] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+2] = -0.01f+j*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+2] = 1;
 
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+3] = (i-1)*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+3] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+4] = -0.005f;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+4] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+5] = -0.01f+j*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+5] = 1;
 
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+6] = 0f+i*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+6] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+7] = -0.005f;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+7] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+8] = -0.01f+(j-1)*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+8] = 1;
 
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+9] = 0f+(i-1)*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+9] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+10] = -0.005f;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+10] = 1;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+11] = -0.01f+(j-1)*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+11] = 0;
 
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+12] = (i-1)*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+12] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+13] = -0.005f;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+13] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+14] = -0.01f+j*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+14] = 1;
 
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+15] = 0f+i*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+15] = 1;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+16] = -0.005f;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+16] = 0;
				verticesFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+17] = -0.01f+(j-1)*size;
				colorsFloat[(i+caseMax-1)*caseMax*2*6*3+(j+caseMax-1)*6*3+17] = 0;
 
			}
		}
        vertices = BufferUtils.createFloatBuffer(caseMax*caseMax*6*3*4);
        vertices.put(verticesFloat);
        colors = BufferUtils.createFloatBuffer(caseMax*caseMax*6*3*4);
        colors.put(colorsFloat);
 
        vertices.rewind();
		IntBuffer buffer = BufferUtils.createIntBuffer(1);
		ARBVertexBufferObject.glGenBuffersARB(buffer);
        vertexBufferID = buffer.get(0);
		ARBVertexBufferObject.glBindBufferARB(
				ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
				vertexBufferID);
		ARBVertexBufferObject.glBufferDataARB(
				ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, vertices,
				ARBVertexBufferObject.GL_STATIC_DRAW_ARB);
 
		colors.rewind();
		buffer = BufferUtils.createIntBuffer(1);
		ARBVertexBufferObject.glGenBuffersARB(buffer);
		colorBufferID = buffer.get(0);
		ARBVertexBufferObject.glBindBufferARB(
				ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
				colorBufferID);
		ARBVertexBufferObject.glBufferDataARB(
				ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB, colors,
				ARBVertexBufferObject.GL_STATIC_DRAW_ARB);
    }
 
    public static void drawVBO() {
        vertices.rewind();
		colors.rewind();
        GL11.glEnableClientState(GL11.GL_VERTEX_ARRAY);
        ARBVertexBufferObject.glBindBufferARB(
        		ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
        		vertexBufferID);
        GL11.glVertexPointer(3, GL11.GL_FLOAT, 0, 0);
        GL11.glEnableClientState(GL11.GL_COLOR_ARRAY);
        ARBVertexBufferObject.glBindBufferARB(
        		ARBVertexBufferObject.GL_ARRAY_BUFFER_ARB,
        		colorBufferID);
        GL11.glColorPointer(3, GL11.GL_FLOAT, 0, 0);
        GL11.glDrawArrays(GL11.GL_TRIANGLES,0,caseMax*caseMax*6*4);
        GL11.glDisableClientState(GL11.GL_VERTEX_ARRAY);
 
	}
 
}

Je voudrais savoir, si j'utilise correctement les VBO :question:
(je suis pas assez bon ou pas assez intelligent pour savoir si ce que j'ai écrit est correct... désolé !)

28/06/2009, 12h32
Mike Reason

Nan...?

Personne sait utiliser les VBO en Java avec LWJGL :question: