JOGL problème Z-Buffer

Bonjour à tous,

Je suis en tain de porter un programme d’affichage de blocs (en 3D) de C++ vers Java.
La représentation des blocs se fait à la façon de l’exemple NeHe lesson27 : http://nehe.gamedev.net/data/lessons....asp?lesson=27
C'est-à-dire avec une variation de l’intensité de la couleur de chaque face en fonction de leurs orientation par rapport la source de lumière. Par contre j’ai retiré le mécanisme de représentation des ombres portées de l’exemple 27.
Tout ceci fonctionne très bien dans mon programme C++.
Par contre j’ai de gros problèmes avec Jogl. Comme si le z-buffer ne fonctionnait pas bien : je me retrouve avec de surface en transparence de l’ordre de construction des six faces d’un bloc.

Ma configuration :
- Windows Vista
- Eclipse.
- Jogl

J’ai téléchargé Jogl ici : http://jogamp.org/deployment/archive/jogl-20100511/
Et j’utilise les fichiers suivants :
- gluegen-rt.jar
- jogl.all.jar
- nativewindow.all.jar
- gluegen-rt.dll
- jogl_desktop.dll
- jogl_es1.dll
- jogl_es2.dll
- jogl_gl2es12.dll
- nativewindow_awt.dll

Voici le code de la fonction init (de GLEventListener)

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
	@Override
	public void init(GLAutoDrawable glDrawable) {
		final GL2 gl = glDrawable.getGL().getGL2();
		gl.glShadeModel(GL2.GL_SMOOTH); // Enable Smooth Shading
		gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
		gl.glClearDepth(1.0f); // Depth Buffer Setup
		gl.glClearStencil(0); // Stencil Buffer Setup
		gl.glEnable(GL2.GL_DEPTH_TEST); // Enables Depth Testing
		gl.glDepthFunc(GL2.GL_LEQUAL); // The Type Of Depth Testing To Do
		gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST); // Really
		// Nice
		// Perspective
		// Calculations
 
		final float LIGHT_POS[] = { 50.0f, 100.0f, 50.0f, 1.0f }; // Light
		// Position
		FloatBuffer lightPos = FloatBuffer.wrap(LIGHT_POS);
		gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, lightPos); // Set Light1
		// Position
		final float LIGHT_AMB[] = { 0.4f, 0.4f, 0.4f, 1.0f }; // Ambient Light
		// Values
		FloatBuffer lightAmb = FloatBuffer.wrap(LIGHT_AMB);
		gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, lightAmb); // Set Light1
		// Ambience
		final float LIGHT_DIF[] = { 0.5f, 0.5f, 0.5f, 1.0f };
		FloatBuffer lightDif = FloatBuffer.wrap(LIGHT_DIF);
		gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, lightDif); // Set Light1
		// Diffuse
 
		final float LIGHT_SPC[] = { 0.8f, 0.8f, 0.8f, 1.0f };
		FloatBuffer lightSpc = FloatBuffer.wrap(LIGHT_SPC);
		gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, lightSpc); // Set Light1 Specular
		gl.glEnable(GL2.GL_LIGHT0); // Enable Light0
		gl.glEnable(GL2.GL_LIGHTING); // Enable Lighting
 
		final float AMBIENT[] = { 0.15f, 0.15f, 0.15f, 1.0f }; // différents paramètres
		FloatBuffer ambient = FloatBuffer.wrap(AMBIENT);
		final float DIFFUSE[] = { 0.5f, 0.5f, 0.5f, 1.0f };
		FloatBuffer diffuse = FloatBuffer.wrap(DIFFUSE);
		final float SPECULAR_REFLEXION[] = { 0.8f, 0.8f, 0.8f, 1.0f };
		FloatBuffer specular_reflexion = FloatBuffer.wrap(SPECULAR_REFLEXION);
		int shiny_obj = 128;
 
 
		gl.glEnable(GL2.GL_COLOR_MATERIAL); // spécification de la réflexion sur les matériaux
		gl.glColorMaterial(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE);
		gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT, ambient);
		gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE, diffuse); // on peut le faire avant chaque objet
		gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR,
				specular_reflexion);
		gl.glMateriali(GL2.GL_FRONT_AND_BACK, GL2.GL_SHININESS, shiny_obj);// si on veut qu'ils aient des caractéristiques
 
		gl.glEnable(GL2.GL_BLEND);
		gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
 
	}

Puis la fonction reshape :

Code:

1
2
3
4
5
6
7
8
9
	@Override
	public void reshape(GLAutoDrawable glDrawable, int x, int y, int width,
			int height) {
		final GL2 gl = glDrawable.getGL().getGL2();
		gl.glViewport(0, 0, width, height);
		gl.glMatrixMode(GL2.GL_PROJECTION);
		gl.glLoadIdentity();
		glu.gluPerspective(45.0f, (float) width / (float) height, 0.1f, 100.0f);
	}

et enfin de la fonction display :

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
	@Override
	public void display(GLAutoDrawable glDrawable) {
		final GL2 gl = glDrawable.getGL().getGL2();
 
		gl.glMatrixMode(GL2.GL_MODELVIEW);
		// Set background color
		gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
		gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
 
		gl.glLoadIdentity();
 
		gl.glTranslatef(0.0f, 0.0f, zoomValue);
 
		gl.glRotatef(alphaOX, 1.0f, 0.0f, 0.0f);
		gl.glRotatef(alphaOY, 0.0f, 1.0f, 0.0f);
 
		float red = 1.0f;
		float green = 0.8f;
		float blue = 0.0f;
		float alpha = 1.0f;
 
		gl.glColor4f(red, green, blue, alpha);
 
		final Point p0 = bl.getPoint(0);
		final Point p1 = bl.getPoint(1);
		final Point p2 = bl.getPoint(2);
		final Point p3 = bl.getPoint(3);
		final Point p4 = bl.getPoint(4);
		final Point p5 = bl.getPoint(5);
		final Point p6 = bl.getPoint(6);
		final Point p7 = bl.getPoint(7);
 
		gl.glBegin(GL2.GL_QUADS);
 
		// Bottom face
		{
			Point bottom = bl.getNormalVectorBottomFace();
			gl.glNormal3f(bottom.getX(), bottom.getY(), bottom.getZ());
			gl.glVertex3f(p0.getX(), p0.getY(), p0.getZ());
			gl.glVertex3f(p1.getX(), p1.getY(), p1.getZ());
			gl.glVertex3f(p2.getX(), p2.getY(), p2.getZ());
			gl.glVertex3f(p3.getX(), p3.getY(), p3.getZ());
		}
 
		// Top face
		{
			Point top = bl.getNormalVectorTopFace();
			gl.glNormal3f(top.getX(), top.getY(), top.getZ());
			gl.glVertex3f(p4.getX(), p4.getY(), p4.getZ());
			gl.glVertex3f(p7.getX(), p7.getY(), p7.getZ());
			gl.glVertex3f(p6.getX(), p6.getY(), p6.getZ());
			gl.glVertex3f(p5.getX(), p5.getY(), p5.getZ());
		}
 
		// Left face
		{
			Point left = bl.getNormalVectorLeftFace();
			gl.glNormal3f(left.getX(), left.getY(), left.getZ());
			gl.glVertex3f(p0.getX(), p0.getY(), p0.getZ());
			gl.glVertex3f(p3.getX(), p3.getY(), p3.getZ());
			gl.glVertex3f(p7.getX(), p7.getY(), p7.getZ());
			gl.glVertex3f(p4.getX(), p4.getY(), p4.getZ());
		}
 
		// Right face
		{
			Point right = bl.getNormalVectorRightFace();
			gl.glNormal3f(right.getX(), right.getY(), right.getZ());
			gl.glVertex3f(p1.getX(), p1.getY(), p1.getZ());
			gl.glVertex3f(p5.getX(), p5.getY(), p5.getZ());
			gl.glVertex3f(p6.getX(), p6.getY(), p6.getZ());
			gl.glVertex3f(p2.getX(), p2.getY(), p2.getZ());
		}
 
		// Front face
		{
			Point front = bl.getNormalVectorFrontFace();
			gl.glNormal3f(front.getX(), front.getY(), front.getZ());
			gl.glVertex3f(p3.getX(), p3.getY(), p3.getZ());
			gl.glVertex3f(p2.getX(), p2.getY(), p2.getZ());
			gl.glVertex3f(p6.getX(), p6.getY(), p6.getZ());
			gl.glVertex3f(p7.getX(), p7.getY(), p7.getZ());
		}
 
		// Back face
		{
			Point back = bl.getNormalVectorBackFace();
			gl.glNormal3f(back.getX(), back.getY(), back.getZ());
			gl.glVertex3f(p0.getX(), p0.getY(), p0.getZ());
			gl.glVertex3f(p4.getX(), p4.getY(), p4.getZ());
			gl.glVertex3f(p5.getX(), p5.getY(), p5.getZ());
			gl.glVertex3f(p1.getX(), p1.getY(), p1.getZ());
		}
 
		gl.glEnd();
	}

Je n’ai aucune maitrise de Jogl, ni en terme de librairie à choisir ni de développement.
Alors si vous avez un exemple permettant d’afficher des volumes avec une source de lumière qui ne pose pas de PB de z-buffer avec la liste des fichiers Jogl à utiliser, je suis preneur.

Merci.

Nassa.