Discussion :

[gladek]

Bonjour,
J'ai mis en place le bumpMapping dot product issu du tutorial
Gestion Dynamique de la lumière.
Mon système ne supporte pas les extensions :
GL_EXT_texture3D, GL_ARB_texture_env_dot3 et GL_ARB_texture_cube_map.

Apres verification les 2 dernières sont tout de meme présentes.
Malgré l'absence de la première j'ai le rendu suivant :


Pouvez m'expliquez si ce rendu est du à l'absence de GL_EXT_texture3D ?
Existe t il une solution pour contourner cette absence et ainsi mettre en place cette technique ?
Pourquoi les 2 extensions ne sont pas trouvées par JOGL ?

D'avance merci

[LittleWhite]

Bonjour,

L'extension GL_EXT_texture3D doit servir pour faire du shadow mapping (je ne vois pas à quoi il servirai pour le bump mapping).

Sinon, l'implémentation des extensions dépend des constructeurs de cartes graphiques. Ils peuvent ou peuvent ne pas mettre les extensions. Du coup, il arrive que certaine machine n'ont pas les extensions nécessaires. La mise à jour des pilotes peut aider, quelque fois.

[gladek]

Ok ok pour l'extension GL_EXT_texture3D, j'ai suivi le tutoriel
http://mdeverdelhan.developpez.com/t.../dynamiclight/

Autrement comment expliquer pour les 2 autres extensions non détectées mais bien présentes ? Je ne comprend pas pourquoi j'obtiens le rendu en screenShot

Je post le code JOGL

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
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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
public class LessonDynamicLight5 {
 
	private static Logger logger = Logger.getLogger(LessonDynamicLight5.class
			.getName());
 
	boolean[] keys = new boolean[256];
 
	// private SolidForm form;
	Map<String, Mesh> meshs;
	private Renderer renderer;
 
	// TextureLoader textureLoader;
	// IDs of the textures
	int textureId;
	int normalMapId;
	int lightmap;
	int normalCubeMapId;
 
	// la couleur ambiante de l'affichage
	Color ambiant;
	Light redLight;
	Light blueLight;
	Light whiteLight;
 
	float angleRotationY = 0;
	float cameraHeight = 8;
	float whiteAngle = 0;
	float whiteHeight = 3;
	float whiteDistance = 4;
	boolean useWhiteLight = false;
	boolean drawLocalSpace = false;
 
	public void init() {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		gl.setSwapInterval(1);
		gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
		// gl.glColor3f(1.0f, 0.0f, 0.0f);
		gl.glHint(gl.GL_PERSPECTIVE_CORRECTION_HINT, gl.GL_NICEST);
		gl.glClearDepth(1.0);
		// gl.glLineWidth(2);
		gl.glEnable(gl.GL_DEPTH_TEST);
		gl.glDepthFunc(gl.GL_LEQUAL);
 
		initExtensions();
		initTextures();
		// initCallback();
		generateSphereMap(64);
 
		// form = FormFactory.getSolidForm("scene.obj");
		// form.init();
		try {
			this.meshs = DataAssemblerFactory
					.getMeshOBJ("objets/obj/scene.obj");
			for (Map.Entry<String, Mesh> entry : meshs.entrySet()) {
				Mesh mesh = entry.getValue();
				mesh.init();
			}
		} catch (FichierIntrouvableException e) {
			logger.error(e.getMessage(), e);
			System.exit(0);
		} catch (FileParserFormatNotSupportedException e) {
			logger.error(e.getMessage(), e);
			System.exit(0);
		} catch (Exception e) {
			logger.error(e.getMessage(), e);
		}
		renderer = new DirectRenderer();
		// render.init(meshs);
 
		ambiant = new Color(0.1f, 0.1f, 0.1f);
 
		try {
			redLight = LightManager.getLightManager().getNewLight();
			redLight.setPosition(5, 5, 0);
			redLight.setColorAmbient(Color.ROUGE);
			redLight.lightOn();
			// redLight.setRadius(15);
 
			blueLight = LightManager.getLightManager().getNewLight();
			blueLight.setPosition(-5, 5, 0);
			blueLight.setColorAmbient(Color.BLEU);
			// blueLight.setRadius(20);
 
			whiteLight = LightManager.getLightManager().getNewLight();
			whiteLight.setPosition((float) Math.cos(whiteAngle * (3.141 / 180))
					* whiteDistance, whiteHeight,
					(float) Math.sin(whiteAngle * (3.141 / 180))
							* whiteDistance);
			whiteLight.setColorAmbient(Color.BLANC);
			// whiteLight.setRadius(10);
		} catch (MaxNumberOfLightException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
 
	public void render() {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
		GLUgl2 glu = GLContextManager.getInstance().getOpenGLContext().getGlu();
 
		gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT);
		gl.glLoadIdentity();
		float posX = (float) (Math.cos(angleRotationY * (3.141 / 180)) * 8);
		float posZ = (float) (Math.sin(angleRotationY * (3.141 / 180)) * 8);
		glu.gluLookAt(posX, cameraHeight, posZ, 0, 0, 0, 0, 1, 0);
 
		// on configure la premiere unité de texture : elle contient la texture
		// de la scene
		gl.glActiveTexture(gl.GL_TEXTURE0);
		gl.glEnable(gl.GL_TEXTURE_2D);
		gl.glBindTexture(gl.GL_TEXTURE_2D, textureId);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
 
		// on effectue le rendu de la lumiere ambiante
		gl.glColor3f(ambiant.getR(), ambiant.getG(), ambiant.getB());
		// on dessine le model de base
		for (Map.Entry<String, Mesh> entry : meshs.entrySet()) {
			Mesh mesh = entry.getValue();
			renderer.init(mesh);
			renderer.render();
		}
 
		if (drawLocalSpace) {
			gl.glDisable(gl.GL_TEXTURE_2D);
			for (Map.Entry<String, Mesh> entry : meshs.entrySet()) {
				Mesh mesh = entry.getValue();
				mesh.drawLocalSpace();
				// model->drawLocalSpace();
			}
		}
 
		// on doit reconfigurer les unité de textures
		// la premiere unité contient la cube map de normalisation
		gl.glActiveTexture(gl.GL_TEXTURE0);
		gl.glEnable(gl.GL_TEXTURE_CUBE_MAP);
		gl.glBindTexture(gl.GL_TEXTURE_CUBE_MAP, normalCubeMapId);
		// on souhaite que la cube map remplace la couleur des vertex
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_REPLACE);
 
		// la deuxieme unite de texture contient la normal map
		gl.glActiveTexture(gl.GL_TEXTURE1);
		gl.glEnable(gl.GL_TEXTURE_2D);
		gl.glBindTexture(gl.GL_TEXTURE_2D, normalMapId);
		// on configure la normal map pour qu'elle effectue la passe de DOT3
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_COMBINE);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_RGB_SCALE, 1);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_COMBINE_RGB, gl.GL_DOT3_RGB);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_SOURCE0_RGB, gl.GL_PREVIOUS);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_SOURCE1_RGB, gl.GL_TEXTURE);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_OPERAND0_RGB, gl.GL_SRC_COLOR);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_OPERAND1_RGB, gl.GL_SRC_COLOR);
 
		// la troisieme contient la texture d'attenuation
		gl.glActiveTexture(gl.GL_TEXTURE2);
		gl.glEnable(gl.GL_TEXTURE_3D);
		gl.glBindTexture(gl.GL_TEXTURE_3D, lightmap);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
		// la troisieme contient la texture de diffuse
		gl.glActiveTexture(gl.GL_TEXTURE3);
		gl.glEnable(gl.GL_TEXTURE_2D);
		gl.glBindTexture(gl.GL_TEXTURE_2D, textureId);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
 
		// on doit activer le blending additif pour pouvoir utiliser ce mode
		// d'eclairage
		gl.glEnable(gl.GL_BLEND);
		gl.glBlendFunc(gl.GL_ONE, gl.GL_ONE);
		gl.glDepthMask(false);
 
		// on ajoute nos lumieres
		// addLightCubeMap(redLight);
		// addLightCubeMap(blueLight);
		// if (useWhiteLight) {
		// addLightCubeMap(whiteLight);
		// }
		for (Map.Entry<String, Mesh> entry : meshs.entrySet()) {
			Mesh mesh = entry.getValue();
			mesh.addLightCubeMap(redLight);
			mesh.addLightCubeMap(blueLight);
			if (useWhiteLight) {
				mesh.addLightCubeMap(whiteLight);
			}
		}
 
		// on desactive la quatrieme unité de texture
		gl.glActiveTexture(gl.GL_TEXTURE3);
		gl.glDisable(gl.GL_TEXTURE_2D);
		// on desactive la troisieme unité de texture
		gl.glActiveTexture(gl.GL_TEXTURE2);
		gl.glDisable(gl.GL_TEXTURE_3D);
		// on desactive la seconde unité de texture
		gl.glActiveTexture(gl.GL_TEXTURE1);
		gl.glDisable(gl.GL_TEXTURE_2D);
		// on desactive la premiere unité de texture
		gl.glActiveTexture(gl.GL_TEXTURE0);
		gl.glDisable(gl.GL_TEXTURE_CUBE_MAP);
 
		gl.glActiveTexture(gl.GL_TEXTURE0);
		gl.glEnable(gl.GL_TEXTURE_3D);
		gl.glBindTexture(gl.GL_TEXTURE_3D, lightmap);
		gl.glTexEnvf(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
 
		gl.glBlendFunc(gl.GL_DST_COLOR, gl.GL_ONE);
		// model->renderColor(redLight);
		// model->renderColor(blueLight);
		// if (useWhiteLight) {
		// model->renderColor(whiteLight);
		// }
		for (Map.Entry<String, Mesh> entry : meshs.entrySet()) {
			Mesh mesh = entry.getValue();
			mesh.renderColor(redLight);
			mesh.renderColor(blueLight);
			if (useWhiteLight) {
				mesh.renderColor(whiteLight);
			}
		}
 
		gl.glActiveTexture(gl.GL_TEXTURE0);
		gl.glDisable(gl.GL_TEXTURE_3D);
 
		gl.glDepthMask(true);
		gl.glDisable(gl.GL_BLEND);
 
		// on affiche les lumieres
		gl.glPointSize(5.0f);
		gl.glBegin(gl.GL_POINTS);
		gl.glColor3f(redLight.getColorAmbient().getR(), redLight
				.getColorAmbient().getG(), redLight.getColorAmbient().getB());
		gl.glVertex3f(redLight.getPosition().getX(), redLight.getPosition()
				.getY(), redLight.getPosition().getZ());
		gl.glColor3f(blueLight.getColorAmbient().getR(), blueLight
				.getColorAmbient().getG(), blueLight.getColorAmbient().getB());
		gl.glVertex3f(blueLight.getPosition().getX(), blueLight.getPosition()
				.getY(), blueLight.getPosition().getZ());
		gl.glColor3f(whiteLight.getColorAmbient().getR(), whiteLight
				.getColorAmbient().getG(), whiteLight.getColorAmbient().getB());
		gl.glVertex3f(whiteLight.getPosition().getX(), whiteLight.getPosition()
				.getY(), whiteLight.getPosition().getZ());
		gl.glEnd();
		gl.glPointSize(1.0f);
 
		// gl.glutSwapBuffers();
		gl.glFlush();
	}
 
	public boolean[] getKeys() {
		return this.keys;
	}
 
	public void setKeyValue(int key, boolean value) {
		this.keys[key] = value;
	}
 
	private void initExtensions() {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		if (!gl.isExtensionAvailable("GL_ARB_multitexture")) {
			logger.error("votre carte ne suporte pas l'extension GL_ARB_multitexture");
			System.exit(0);
		}
 
		boolean functionsOK = gl.isFunctionAvailable("glMultiTexCoord2fARB")
				&& gl.isFunctionAvailable("glMultiTexCoord3fARB")
				&& gl.isFunctionAvailable("glMultiTexCoord4fARB")
				&& gl.isFunctionAvailable("glActiveTextureARB")
				&& gl.isFunctionAvailable("glClientActiveTextureARB");
 
		if (!functionsOK) {
			logger.error("impossible d'initialiser l'entension GL_ARB_multitexture");
			System.exit(0);
		}
 
		if (!gl.isFunctionAvailable("GL_EXT_texture3D")) {
			logger.error("votre carte ne suporte pas l'extension GL_EXT_texture3D");
			// System.exit(0);
		}
 
		functionsOK = gl.isFunctionAvailable("glTexImage3DEXT")
				&& gl.isFunctionAvailable("glTexSubImage3DEXT");
 
		if (!functionsOK) {
			logger.error("impossible d'initialiser l'entension GL_EXT_texture3D");
			// System.exit(0);
		}
 
		if (!gl.isFunctionAvailable("GL_ARB_texture_env_dot3")) {
			logger.error("votre carte ne suporte pas l'extension GL_ARB_texture_env_dot3");
			// System.exit(0);
		}
		if (!gl.isFunctionAvailable("GL_ARB_texture_cube_map")) {
			logger.error("votre carte ne suporte pas l'extension GL_ARB_texture_cube_map");
			// System.exit(0);
		}
	}
 
	private void initTextures() {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
		GLUgl2 glu = GLContextManager.getInstance().getOpenGLContext().getGlu();
 
		// textureLoader = new TextureLoader();
		// textureLoader.init();
 
		gl.glEnable(gl.GL_TEXTURE_2D);
 
		Texture texture = null;
		try {
			texture = TextureManager.getInstance().getTexture("nehe/rock.tga",
					false);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		// textureLoader.getTexture(gl, "nehe/rock.tga");
 
		// TGA image;
		if (texture == null) {
			logger.error("impossible de charger l'image rock.tga");
			System.exit(0);
		}
		textureId = GLTextureManager.generateID();
		// gl.glGenTextures (1, textureId);
		gl.glBindTexture(gl.GL_TEXTURE_2D, textureId);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
				gl.GL_LINEAR);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
				gl.GL_LINEAR_MIPMAP_LINEAR);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT);
		if (texture.getBpp() == 24) {
			glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 3, texture.getWidth(),
					texture.getHeight(), gl.GL_RGB, gl.GL_UNSIGNED_BYTE,
					texture.getPixels());
		} else {
			glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 4, texture.getWidth(),
					texture.getHeight(), gl.GL_RGBA, gl.GL_UNSIGNED_BYTE,
					texture.getPixels());
		}
 
		try {
			texture = TextureManager.getInstance().getTexture(
					"nehe/normal.tga", false);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (texture == null) {
			logger.error("impossible de charger l'image normal.tga");
			System.exit(0);
		}
 
		normalMapId = GLTextureManager.generateID();
		// gl.glGenTextures (1, &normalMapId);
		gl.glBindTexture(gl.GL_TEXTURE_2D, normalMapId);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER,
				gl.GL_LINEAR);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER,
				gl.GL_LINEAR_MIPMAP_LINEAR);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_S, gl.GL_REPEAT);
		gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_WRAP_T, gl.GL_REPEAT);
		if (texture.getBpp() == 24) {
			glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 3, texture.getWidth(),
					texture.getHeight(), gl.GL_RGB, gl.GL_UNSIGNED_BYTE,
					texture.getPixels());
		} else {
			glu.gluBuild2DMipmaps(gl.GL_TEXTURE_2D, 4, texture.getWidth(),
					texture.getHeight(), gl.GL_RGBA, gl.GL_UNSIGNED_BYTE,
					texture.getPixels());
		}
 
		gl.glDisable(gl.GL_TEXTURE_2D);
	}
 
	private void generateSphereMap(int size) {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		gl.glEnable(GL2.GL_TEXTURE_3D);
		if (size < 1) {
			logger.error("la taille de la texture 3D doit etre superieur à 1\n");
			return;
		}
 
		float[] datas = new float[size * size * size * 3];
		// on remplie avec la couleur noir
		for (int i = 0; i < size * size * size * 3; i++) {
			datas[i] = 0.0f;
		}
 
		float length;
		// la demi largeur de la texture3d en texels
		float size2 = (float) size / 2.0f;
		for (float i = 0; i < size; i++) {
			for (float j = 0; j < size; j++) {
				for (float k = 0; k < size; k++) {
					// la demi-largeur moins la distance du centre au texel
					// courant de la texture.
					// size2-1 pour éviter l'élairage sur le bord de la texture
					// mais centre moins brillant
					length = (float) ((size2 - 1) - Math.sqrt((i - size2)
							* (i - size2) + (j - size2) * (j - size2)
							+ (k - size2) * (k - size2)));
					// normalisation dans la plage[0,1] (intensité de la
					// lumière)
					length /= size2;
 
					// on stocke la couleur avec son intensité dans le texel
					datas[(int) i * size * size * 3 + (int) j * size * 3
							+ (int) k * 3] = length;
					datas[(int) i * size * size * 3 + (int) j * size * 3
							+ (int) k * 3 + 1] = length;
					datas[(int) i * size * size * 3 + (int) j * size * 3
							+ (int) k * 3 + 2] = length;
				}
			}
		}
 
		// glGenTextures(1,&lightmap);
		lightmap = GLTextureManager.generateID();
		gl.glBindTexture(GL2.GL_TEXTURE_3D, lightmap);
		gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MAG_FILTER,
				gl.GL_LINEAR);
		gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_MIN_FILTER,
				gl.GL_LINEAR);
		gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_S,
				gl.GL_CLAMP_TO_EDGE);
		gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_T,
				gl.GL_CLAMP_TO_EDGE);
		gl.glTexParameteri(gl.GL_TEXTURE_3D, gl.GL_TEXTURE_WRAP_R,
				gl.GL_CLAMP_TO_EDGE);
		gl.glTexEnvi(gl.GL_TEXTURE_ENV, gl.GL_TEXTURE_ENV_MODE, gl.GL_MODULATE);
 
		FloatBuffer dataBuffer = FloatBuffer.wrap(datas);
		gl.glTexImage3D(gl.GL_TEXTURE_3D, 0, gl.GL_RGB, size, size, size, 0,
				gl.GL_RGB, gl.GL_FLOAT, dataBuffer);
 
		gl.glDisable(gl.GL_TEXTURE_3D);
		// delete[] datas;
		datas = null;
		dataBuffer = null;
	}
}

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
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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
public class Mesh {
 
	private static Logger logger = Logger.getLogger(Mesh.class.getName());
 
	private String name;
	private List<Face> faces;
	private Bounds bounds;
 
	private Renderer renderer;
	private GLTexture texture;
	private GLTexture textureMap;
 
	private GLBlending blending;
	private Material material;
 
	// VBO id
	// private int VBOID;
 
	public Mesh(String name) {
		this.name = name;
		this.faces = new ArrayList<Face>();
 
		this.texture = new GLTexture();
		this.material = new PlasticWhiteMaterial();
		this.blending = new GLBlending();
	}
 
	public void init() {
		this.renderer = RendererFactory.getStructureRenderer();
		this.renderer.init(this);
	}
 
	public void update() {
 
	}
 
	public void render() {
		GL2 gl2 = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		material.render(gl2);
		blending.enable();
		texture.enabled(gl2);
		renderer.render();
		texture.disable(gl2);
		blending.disable();
	}
 
	public void addLightCubeMap(Light light) {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		Point lightPos = light.getPosition();
		gl.glBegin(gl.GL_TRIANGLES);
		// for (int i = 0; i < nbFaces; i++) {
		for (Face face : faces) {
			for (int i = 0; i < 3; i++) {
				Point point = face.getPoint(i);
				// int vertexIndex = face.vertexIndex[i];
				// on calcule le vecteur lumiere->vertex
				// on calcule le vecteur vertex->lumiere normalise
				// Point tempVect = vertex[vertexIndex] - lightPos;
				Point tempVect = VectorUtil.sub(point, lightPos);
 
				Point t = face.getTangent(i);
				Point b = face.getBinormal(i);
				Point n = face.getNormal(i);
 
				Point lightToVertex = new Point();
				lightToVertex.setX(VectorUtil.mult(t, tempVect));
				lightToVertex.setY(VectorUtil.mult(b, tempVect));
				lightToVertex.setZ(VectorUtil.mult(n, tempVect));
				// nous avons donc maintenant le vecteur de la lumiere vers le
				// vertex transformer dans l'espace local du vertex.
				// on l'envoie en temps que coordonnée de texture pour la cube
				// map
				gl.glMultiTexCoord3f(gl.GL_TEXTURE0, lightToVertex.getX(),
						lightToVertex.getY(), lightToVertex.getZ());
				// maintenant, on envoie les coordonner de textures
				// la seconde unite de texture contient la normal map, ce sont
				// donc les même coordonnée de textures que
				// la scene
				// TexCoord tc = texCoords[face.texCoordIndex[i]];
				TexCoord tc = face.getUv(i);
				gl.glMultiTexCoord2f(gl.GL_TEXTURE1, tc.getU(), tc.getV());
				// la troisieme unite de texture contient la texture 3D
				// d'attenuation, on calcule donc l'eclairage
				// Point v = vertex[vertexIndex];
				Point lightTexCoord = light.computeLighting(point);
				gl.glMultiTexCoord3f(gl.GL_TEXTURE2, lightTexCoord.getX(),
						lightTexCoord.getY(), lightTexCoord.getZ());
				// la quatrieme unité de texture contient la texture de diffuse,
				// donc les coordonnée de texture de la scene
				gl.glMultiTexCoord2f(gl.GL_TEXTURE3, tc.getU(), tc.getV());
				gl.glVertex3f(point.getX(), point.getY(), point.getZ());
			}
		}
		gl.glEnd();
	}
 
	public void computeLocalSpace(Face face) {
		Point point0 = face.getPoint(0);
		Point point1 = face.getPoint(1);
		Point point2 = face.getPoint(2);
 
		// on calcule 2 vecteur formant les bord du triangle
		// le vecteur side0 est celui allant du vertex 0 au vertex 1
		// Point side0 = vertex[face.vertexIndex[1]] -
		// vertex[face.vertexIndex[0]];
		Point side0 = VectorUtil.sub(point1, point0);
		// le vecteur side1 est celui allant du vertex 0 au vertex 2
		// Point side1 = vertex[face.vertexIndex[2]] -
		// vertex[face.vertexIndex[0]];
		Point side1 = VectorUtil.sub(point2, point0);
 
		// ici on calcule la normale à la face
		// side0.cross(side1);
		Point normal = VectorUtil.cross(side0, side1);
		// normal.normalise();
		VectorUtil.normalise(normal);
 
		// maintenant on calcule les coefficient des tangentes
		// ces coefficient sont fonction des coordonnée de texture du polygone
		TexCoord textCoord0 = face.getUv(0);
		TexCoord textCoord1 = face.getUv(1);
		TexCoord textCoord2 = face.getUv(2);
 
		// float deltaT0 = texCoords[face.texCoordIndex[1]].v
		// - texCoords[face.texCoordIndex[0]].v;
		float deltaT0 = textCoord1.getV() - textCoord0.getV();
		// float deltaT1 = texCoords[face.texCoordIndex[2]].v
		// - texCoords[face.texCoordIndex[0]].v;
		float deltaT1 = textCoord2.getV() - textCoord0.getV();
		// // on effectue la même chose pour la binormal
		// float deltaB0 = texCoords[face.texCoordIndex[1]].u
		// - texCoords[face.texCoordIndex[0]].u;
		float deltaB0 = textCoord1.getU() - textCoord0.getU();
		// float deltaB1 = texCoords[face.texCoordIndex[2]].u
		// - texCoords[face.texCoordIndex[0]].u;
		float deltaB1 = textCoord2.getU() - textCoord0.getU();
 
		float scale = 1 / ((deltaB0 * deltaT1) - (deltaB1 * deltaT0));
 
		// on calcule la tangente temporaire
		// Point tmpTangente = ((side0 * deltaT1) - (side1 * deltaT0)) * scale;
		Point tmpTangente = VectorUtil.multPoint(
				VectorUtil.sub(VectorUtil.multPoint(side0, deltaT1),
						VectorUtil.multPoint(side1, deltaT0)), scale);
		// tmpTangente.normalise();
		VectorUtil.normalise(tmpTangente);
 
		// on calcule la binormal temporaire
		// Point tmpBinormal = ((side0 * (-deltaB1)) + (side1 * deltaB0)) *
		// scale;
		Point tmpBinormal = VectorUtil.multPoint(VectorUtil.add(
				VectorUtil.multPoint(side0, -deltaB1),
				VectorUtil.multPoint(side1, deltaB0)), scale);
		// tmpBinormal.normalise();
		VectorUtil.normalise(tmpBinormal);
 
		// nous avons donc maintenant les tangente, binormale et normale de la
		// face. on les additionne à celles deja presente
		// dans les tableau
		// tangents[face.vertexIndex[0]] += tmpTangente;
		// tangents[face.vertexIndex[1]] += tmpTangente;
		// tangents[face.vertexIndex[2]] += tmpTangente;
		Point tangent0 = face.getTangent(0);
		Point tangent1 = face.getTangent(1);
		Point tangent2 = face.getTangent(2);
		face.setTangent(0, VectorUtil.add(tangent0, tmpTangente));
		face.setTangent(1, VectorUtil.add(tangent1, tmpTangente));
		face.setTangent(2, VectorUtil.add(tangent2, tmpTangente));
 
		// binormals[face.vertexIndex[0]] += tmpBinormal;
		// binormals[face.vertexIndex[1]] += tmpBinormal;
		// binormals[face.vertexIndex[2]] += tmpBinormal;
		Point binormal0 = face.getBinormal(0);
		Point binormal1 = face.getBinormal(1);
		Point binormal2 = face.getBinormal(2);
		face.setBinormal(0, VectorUtil.add(binormal0, tmpBinormal));
		face.setBinormal(1, VectorUtil.add(binormal1, tmpBinormal));
		face.setBinormal(2, VectorUtil.add(binormal2, tmpBinormal));
 
		// normals[face.vertexIndex[0]] += normal;
		// normals[face.vertexIndex[1]] += normal;
		// normals[face.vertexIndex[2]] += normal;
		Point normal0 = face.getNormal(0);
		Point normal1 = face.getNormal(1);
		Point normal2 = face.getNormal(2);
		face.setNormal(0, VectorUtil.add(normal0, normal));
		face.setNormal(1, VectorUtil.add(normal1, normal));
		face.setNormal(2, VectorUtil.add(normal2, normal));
	}
 
	public void drawLocalSpace() {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		gl.glBegin(gl.GL_LINES);
		List<Face> faces = this.getFaces();
		for (Face face : faces) {
			for (int i = 0; i < 3; i++) {
				Point p = face.getPoint(i);
				Point t = face.getTangent(i);
				Point b = face.getBinormal(i);
				Point n = face.getNormal(i);
 
				// tangente en rouge
				Point tangent = VectorUtil.add(t, p);
				gl.glColor3f(1, 0, 0);
				gl.glVertex3f(p.getX(), p.getY(), p.getZ());
				gl.glVertex3f(tangent.getX(), tangent.getY(), tangent.getZ());
				// binormal en vert
				Point binormal = VectorUtil.add(b, p);
				gl.glColor3f(0, 1, 0);
				gl.glVertex3f(p.getX(), p.getY(), p.getZ());
				gl.glVertex3f(binormal.getX(), binormal.getY(), binormal.getZ());
				// normal en bleu
				Point normal = VectorUtil.add(n, p);
				gl.glColor3f(0, 0, 1);
				gl.glVertex3f(p.getX(), p.getY(), p.getZ());
				gl.glVertex3f(normal.getX(), normal.getY(), normal.getZ());
			}
		}
		gl.glEnd();
	}
 
	public void renderColor(Light light) {
		GL2 gl = GLContextManager.getInstance().getOpenGLContext().getGl();
 
		gl.glColor3f(light.getColorAmbient().getR(), light.getColorAmbient()
				.getG(), light.getColorAmbient().getB());
		Point lightPos = light.getPosition();
		gl.glBegin(gl.GL_TRIANGLES);
		// for (int i = 0; i < nbFaces; i++) {
		for (Face face : faces) {
			for (int i = 0; i < 3; i++) {
				Point v = face.getPoint(i);
				Point lightTexCoord = light.computeLighting(v);
				// la premiere unité de texture contient la texture
				// d'attenuation
				gl.glMultiTexCoord3f(gl.GL_TEXTURE0, lightTexCoord.getX(),
						lightTexCoord.getY(), lightTexCoord.getZ());
				gl.glVertex3f(v.getX(), v.getY(), v.getZ());
			}
		}
		gl.glEnd();
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public List<Face> getFaces() {
		return faces;
	}
 
	public void setFaces(List<Face> faces) {
		this.faces = faces;
	}
 
	public void addFace(Face face) {
		this.faces.add(face);
	}
 
	public Bounds getBounds() {
		return bounds;
	}
 
	public void setBounds(Bounds bounds) {
		this.bounds = bounds;
	}
 
	public GLBlending getBlending() {
		return blending;
	}
 
	public void setBlending(GLBlending blending) {
		this.blending = blending;
	}
 
	public Renderer getRenderer() {
		return renderer;
	}
 
	public void setRenderer(Renderer renderer) {
		this.renderer = renderer;
	}
 
	public GLTexture getTexture() {
		return texture;
	}
 
	public void setTexture(GLTexture texture) {
		this.texture = texture;
	}
 
	public Material getBasicMaterial() {
		return material;
	}
 
	public void setBasicMaterial(Material basicMaterial) {
		this.material = basicMaterial;
	}
 
	public GLTexture getTextureMap() {
		return textureMap;
	}
 
	public void setTextureMap(GLTexture textureMap) {
		this.textureMap = textureMap;
	}

[gladek]

j'ai corrigé une erreur de calcul dans mon code au niveau de l'application des lumieres, j'obtiens un rendu cohérent. Il reste encore beaucoup trop lumineux à mon gout mais c'est deja un bon point.

Par contre je n'ai pas l'impression d'avoir cet effet 3D...
Je n'arrive toujours pas à comprendre pourquoi 2 extensions ne sont pas détectés via gl.isFunctionsAvailable("...") :
GL_ARB_texture_env_dot3
GL_ARB_texture_cube_map

J'ai vérifier elles ont bien implémentés sur macarte graphique intel hd graphics 30000

[LittleWhite]

J'ai vérifier elles ont bien implémentés sur macarte graphique intel hd graphics 30000

Je crois que c'est 3000 et pas 30000

Sinon, il faut savoir que Intel ont des implémentations assez pauvres d'OpenGL (qui repose sur Mesa en plus ...). Plus précisément, ils ont du matos graphique limité et un pilote limité aussi, donc qu'une extension n'existe pas, il n'y a rien d'étonnant.


Je tiens à rappeler mon premier message :

Sinon, l'implémentation des extensions dépend des constructeurs de cartes graphiques. Ils peuvent ou peuvent ne pas mettre les extensions. Du coup, il arrive que certaine machine n'ont pas les extensions nécessaires. La mise à jour des pilotes peut aider, quelque fois.

Il faut bien comprendre que les extensions sont facultatives. Dans le sens, un constructeur peut décider de l'intégrer ou non, si cela lui chante. S'il ne l'intègre pas, il sera toujours "OpenGL compliant" (conforme à la norme) car il a suivit la spécification (et les extensions ne rentrent pas dans la spécifications, car ce sont comme des expérimentations et si par la suite, tout le monde utilise ou l'on remarque que c'est une bonne chose, alors l'extension peut être normalisée et être intégrée dans la prochaine version de la spécification).

Donc, oui, il arrive que certains matos / pilotes n'ont pas toutes les extensions requises pour faire tout ce que l'on veut.

Finalement, je vous conseille de mettre le pilote à jour, ne sait-on jamais (surtout qu'une toute récente nouvelle version de Mesa vient de sortir).

[gladek]

je suis sous macos et j'utlise l'application OpenGL Extensions Viewer 4.0.
Ce dernier me liste bien les 2 extensions.
Je n'ai peut etre pas besoin de cette mise à jour ?

En affichant la liste des extensions retournée par gl les 2 extensions sont bien listées...

[LittleWhite]

Dans ce cas, il y a un problème avec gl.isFunctionsAvailable("...").
Peut être parce que vous utilisez l'ARB, alors que cela a été mis en place dans la norme, ou alors que c'est appelé _EXT.
Sinon, peut être parce que le contexte que vous créez n'est pas le bon même si je crois que cela ne change pas grand chose.
Vous pouvez aussi essayez de voir avec glxinfo et puis de voir avec glGetString(GL_EXTENSIONS);

[gladek]

la fonction gl.isFunctionsAvailable("...") me retourne false
alors que glGetString(GL_EXTENSIONS); me liste les 2 extensions...

[gladek]

Voila le rendu


je n'ai pas l'impression que le BumpMap soit en place et l'image est beaucoup plus claire que celle sur le tutoriel...

[LittleWhite]

En effet, il n' ya pas de bump mapping et donc (surement lié) l'image est plus claire (car il n'y a pas les ombrages liées au relief)

[gladek]

je vais tester ma carte graphique et le bump mapping Dot3 avec l'exemple
http://www.paulsprojects.net/tutoria...implebump.html

Je suis en train de convertir tout ça en java/jogl. J'ai juste une question au niveau d'une syntaxe :

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
	unsigned char * data=new unsigned char[32*32*3];
unsigned char * bytePtr;
	//positive x
	bytePtr=data;
 
	for(int j=0; j<size; j++) {
		for(int i=0; i<size; i++) {
			tempVector.SetX(halfSize);
			tempVector.SetY(-(j+offset-halfSize));
			tempVector.SetZ(-(i+offset-halfSize));
			tempVector.Normalize();
			tempVector.PackTo01();
			bytePtr[0]=(unsigned char)(tempVector.GetX()*255);
			bytePtr[1]=(unsigned char)(tempVector.GetY()*255);
			bytePtr[2]=(unsigned char)(tempVector.GetZ()*255);
 
			bytePtr+=3;
		}
	}

Je ne comprend pas l'opertaion "bytePtr+=3"
Est ce que quelqu'un peut m'eclairer ?

(J'ai transformer ce tableau en byte[] sous java)

[LittleWhite]

Je vous conseille des article plus récent, qui utilise au minimum OpenGL 2 et les shaders.

Sinon, le bytePtr+=3 déplace le pointeur du tableau de 3 cases.
Au début, le bytePtr indique le début du tableau, puis on déplace, disons une tête de lecture, pour avancer dans le tableau.

Ici, on peut faire en sorte que bytePtr soit remplacer par un int, qui sera utilisé comme index et cela sera la même chose.

[gladek]

une solution pour tester, avez vous un lien vers une application ou demo bumpmap dot3 sur macosx ?

[gladek]

j'ai tester le code bumpmap dot3 C++ sous window7 et le rendu est correct...
je ne comprend plus rien...

[gladek]

j'ai reussi a obtenir le rendu souhaité
mon sol est enfin bien en "relief"

Il me reste un dernier soucis, mon sol est affiché correctement mais les colonnes sont transparentes...


Avez vous une idée pour corriger ce rendu ?

[gladek]

Résultat final