Discussion :

[martini_bird]

Bonjour,

comme indiqué dans le titre, je ne parviens pas à activer le multisampling avec JOGL (2.0, version beta10 du 15/09/2009, trouvée ici). Le code ci-dessous, adapté d'un exemple trouvé sur la toile, affiche deux figures identiques, alors que celle de gauche devrait être lissée.

Par ailleurs, les versions plus récentes de JOGL (comme par exemple celle-ci) semblent incomplètes (absence des fichiers libnativewindow_jvm.so et libjogl_gl2.so) : j'ai sûrement dû manqué une étape.

Comme j'ai parcouru en vain des dizaines de pages en quête d'une réponse, je vous soumets mon problème, et toute aide ou suggestion sera donc la bienvenue.

Cordialement.

Note : je travaille avec Eclipse sous Ubuntu 9.10.

PS : le problème est le même avec un GLJPanel en lieu et place du GLCanvas.

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
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.glu.GLU;
import javax.swing.JFrame;
 
public class Test extends JFrame implements GLEventListener {
 
	public static void main(String[] args) {
		new Test().run();
	}
 
	/*
	 * Affiche la JFrame
	 */
	public void run() {
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(600, 300);
		setLocationRelativeTo(null);
		setVisible(true);
	}
 
	/*
	 * La fenêtre contenant le GLCanvas
	 */
	public Test() {
		super("MultiSampling Test");
 
		GLCapabilities caps = new GLCapabilities(GLProfile.getDefault());
		caps.setSampleBuffers(true); 	// Active le multisampling
		caps.setNumSamples(8);			// Active le multisampling
		GLCanvas canvas = new GLCanvas(caps);
		canvas.addGLEventListener(this);
 
		add(canvas);
	}
 
	/*
	 * Initialise la figure à afficher
	 * 
	 */
	public void init(GLAutoDrawable drawable) {
		GL2 gl = drawable.getGL().getGL2();
 
		//
		int buf[] = new int[1];
		int sbuf[] = new int[1];
 
		gl.glClearColor(1f, 1f, 1f, 1f);
		gl.glGetIntegerv(GL.GL_SAMPLE_BUFFERS, buf, 0);
		System.out.println("number of sample buffers is " + buf[0]);
		gl.glGetIntegerv(GL.GL_SAMPLES, sbuf, 0);
		System.out.println("number of samples is " + sbuf[0]);
 
		gl.glNewList(1, GL2.GL_COMPILE);
		for (int i = 0; i < 19; i++) {
			gl.glColor3f(0f, 0f, 0f);
			gl.glPushMatrix();
			gl.glRotatef(360.0f * (float) i / 19.0f, 0.0f, 0.0f, 1.0f);
			gl.glBegin(GL.GL_LINES);
			gl.glVertex2f(0.25f, 0.05f);
			gl.glVertex2f(0.9f, 0.2f);
			gl.glEnd();
			gl.glPopMatrix();
		}
		gl.glEndList();
 
	}
 
	/*
	 * Affiche deux figures
	 * 
	 */
	public void display(GLAutoDrawable drawable) {
		GL2 gl = drawable.getGL().getGL2();
		gl.glClear(GL.GL_COLOR_BUFFER_BIT);
 
		gl.glEnable(GL.GL_MULTISAMPLE); // première figure lissé
		gl.glPushMatrix();
		gl.glTranslatef(-1.0f, 0.0f, 0.0f);
		gl.glCallList(1);
		gl.glPopMatrix();
 
		gl.glDisable(GL.GL_MULTISAMPLE); // seconde figure sans traitement
		gl.glPushMatrix();
		gl.glTranslatef(1.0f, 0.0f, 0.0f);
		gl.glCallList(1);
		gl.glPopMatrix();
 
		gl.glFlush();
	}
 
	/*
	 * Au cas où la fenêtre est redimensionnée
	 * 
	 */
	public void reshape(GLAutoDrawable drawable, int x, int y, int w, int h) {
		GL2 gl = drawable.getGL().getGL2();
		GLU glu = new GLU();
		//
		gl.glViewport(0, 0, w, h);
		gl.glMatrixMode(GL2.GL_PROJECTION);
		gl.glLoadIdentity();
		if (w <= (2 * h))
			glu.gluOrtho2D(-2.0, 2.0, //
					-2.0 * (float) h / (float) w, 2.0 * (float) h / (float) w);
		else
			glu.gluOrtho2D(-2.0 * (float) w / (float) h, //
					2.0 * (float) w / (float) h, -2.0, 2.0);
		gl.glMatrixMode(GL2.GL_MODELVIEW);
		gl.glLoadIdentity();
	}
 
	@Override
	public void dispose(GLAutoDrawable drawable) {
	}
}

[wax78]

Cela fonctionne sous un autre programme opengl que le tiens ?

Si non, alors as tu bien mis l'option "controle par l'application" ou quelque choses dans le gout, dans l'anticrenelage de ton driver ? (si elle existe)

[martini_bird]

Salut,

pardonne-moi, mais je ne comprends pas bien ce que tu me demandes.

Cela fonctionne sous un autre programme opengl que le tiens ?

Ma question concernait JOGL, et je ne vois pas ce que entends par "un autre programme opengl". En revanche, je n'ai pas la possibilité de tester le code ci-dessus sur une autre machine, et si quelqu'un a deux minutes à perdre, ça m'aiderait à cerner le problème.

Si non, alors as tu bien mis l'option "controle par l'application" ou quelque choses dans le gout, dans l'anticrenelage de ton driver ? (si elle existe)

Je ne vois pas du tout de quoi tu parles.

Merci pour ta réponse néanmoins.

[martini_bird]

Salut,

autre bizarrerie rencontrée à l'instant : le code suivant

Code :

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

1
2
3
4
5
6
7
8
9
10
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
 
double[] buf = new double[16];
gl.glGetDoublev(GL2.GL_MODELVIEW, buf, 0);
 
System.out.println(buf[0]+" "+buf[4]+" "+ buf[8]+" "+buf[12]);
System.out.println(buf[1]+" "+buf[5]+" "+ buf[9]+" "+buf[13]);
System.out.println(buf[2]+" "+buf[6]+" "+buf[10]+" "+buf[14]);
System.out.println(buf[3]+" "+buf[7]+" "+buf[11]+" "+buf[15]);

me donne la sortie suivante, que j'ai bien du mal à appeler matrice identité :

8.0320372085262E-268 6.365987374E-314 1.0609978955E-313 8.4879831653E-314
2.0028889041184325E-268 2.0E-323 1.06099789573E-313 1.0609978955E-313
8.132485733192058E-268 1.06099789573E-313 2.5E-323 1.06099789573E-313
2.121995791E-314 1.06099789573E-313 4.2439915824E-314 2.5E-323

Je pense que le problème vient de la version de JOGL utilisée.

Cordialement.

[wax78]

- Un autre programme opengl, je ne sais pas comment te traduire ca mieux ^^,

Ton programme utilise OPENGL (JOGL etant une surcouche, si je puis m'exprimer ainsi, permettant de faire de l'opengl dans java, comme il existe encore LWGL et surement d'autres). voila pourquoi je parle d'opengl.

Par autre programme opengl j'entendais, un jeu, un programme 3D quelquonques (sous linux tu va certainement en trouver plus facilement que sous windows vu que y'a pas directx). Si le pogramme gere l'antialising (ou que tu force celui ci dans les param du drivers graphique) alors tu verras si oui ou non ton code peut etre en cause.

Pour l'option d'antialising, sous windows (et sous linux dans mes anciens souvenirs) sont disponible dans les parametres du driver de ta carte graphique.

soit elle est mise a "Controlled by application" (ce qui est en general la valeur par defaut), soit forcée a une valeur, soit Disabled.

Si evidement c'est mis sur disabled, tu peux a mon avis toujours essayer avec ton code tu n'auras pas de full antialising (je parle pas LINE_SMOOTH et POLYGON_SMOOTH qui fonctionnent quand meme malgré ce parametres).

Ton code je l'ai essayé mais je ne sais pas le compiler avec mes versions de jogl et j'ai la flemme de chercher

J'espere que je n'ai pas dit trop de connerie ^^

[martini_bird]

Ok, je n'avais pas saisi : je vais tâcher de trouver quelque chose qui me confirme que l'antialiasing est disponible.

Ton code je l'ai essayé mais je ne sais pas le compiler avec mes versions de jogl et j'ai la flemme de chercher

J'ai l'impression que la version de JOGL que j'ai récupérée n'est pas aboutie (cf. le message précédent) : quelle version utilises-tu ?

Merci pour ton aide.

[wax78]

Nous nous somme bien compris

Je dirais JSR-231 dans mes souvenirs. Mais c'etait avant que http://jogamp.org ne semble reprendre la main... et en effet mon fichier date de 2008 donc jsuis un peu en retard et peut etre pas de bon conseil alors.

Je vais un peu regarder avec les dernies version de JOGL pour voir un peu (et me mettre a jour).

[martini_bird]

Salut,

j'ai réussi à compiler jogl à l'aide de cette page. Malheureusement, et bien que tout semble s'être bien passé, le fichier libnativewindow_jvm.so n'a pas été généré, et le premier appel à GLProfile.getDefault() me renvoie logiquement une java.lang.UnsatisfiedLinkError: no nativewindow_jvm in java.library.path.

Je commence à perdre patience... Quelqu'un a-t-il seulement réussi à faire fonctionner JOGL2 ?

Cordialement.

[wax78]

En fait si je comprens bien y'a eu pas mal de changements.

Je n'arrive meme plus a rien afficher ni quoi que ce soit ^^.

Sinon pour de l'opengl 3.1 avec jogl2 y'a moyen avec ce bout de code glaner sur le net. Mais il ne fait rien donc le programme s'arrete desuite mais il n'affiche pas d'erreur...

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
import javax.media.opengl.GL;
import javax.media.opengl.GL3;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
 
 
public class testGL implements GLEventListener {
 
 
	public static void main(String args[])
	{
		GLProfile profile = GLProfile.get(GLProfile.GL3); 
 
		//configure context 
		GLCapabilities capabilities = new GLCapabilities(profile); 
		capabilities.setNumSamples(2); // enable anti aliasing - just as a example 
		capabilities.setSampleBuffers(true); 
 
		//initialize a GLDrawable of your choice 
		GLCanvas canvas = new GLCanvas(capabilities); 
 
		//register GLEventListener 
		testGL testGL2 = new testGL();
		canvas.addGLEventListener(testGL2); 
		//... (start rendering thread -> start rendering...)
                      JFrame frame = new JFrame();
		frame.add(canvas);
		frame.setVisible(true);
	}
	@Override
	public void display(GLAutoDrawable drawable) {
		GL3 gl = drawable.getGL().getGL3(); 
		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT); 
 
	}
 
	@Override
	public void dispose(GLAutoDrawable arg0) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void init(GLAutoDrawable arg0) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void reshape(GLAutoDrawable arg0, int arg1, int arg2, int arg3, int arg4) {
		// TODO Auto-generated method stub
 
	}
 
 
}

Si quelqu'un a des tutos pour du GL3 ... qu'il n'hésite surtout pas.

Edit :

Sinon voici le code modifié qui affiche les roues dentées bien connues :

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
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GL3;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.awt.GLJPanel;
import javax.swing.JFrame;
 
import com.jogamp.opengl.util.Animator;
 
public class testGL implements GLEventListener {
 
	public static void main(String args[]) {
		GLProfile profile = GLProfile.get(GLProfile.GL2);
 
		// configure context
		GLCapabilities capabilities = new GLCapabilities(profile);
		capabilities.setNumSamples(2); // enable anti aliasing - just as a
										// example
		capabilities.setSampleBuffers(true);
 
		// initialize a GLDrawable of your choice
		GLCanvas canvas = new GLCanvas(capabilities);
 
		// register GLEventListener
		testGL testGL2 = new testGL();
		canvas.addGLEventListener(testGL2);
		Animator a = new Animator(canvas);
		a.start();
		// ... (start rendering thread -> start rendering...)
		JFrame frame = new JFrame();
		frame.add(canvas);
		frame.setVisible(true);
	}
 
	private float angle;
	private float view_rotx = 20.0f, view_roty = 30.0f, view_rotz = 0.0f;
 
	@Override
	public void display(GLAutoDrawable drawable) {
		GL2 gl = drawable.getGL().getGL2();
		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
		// Turn the gears' teeth
		angle += 2.0f;
 
		// Special handling for the case where the GLJPanel is translucent
		// and wants to be composited with other Java 2D content
		if ((drawable instanceof GLJPanel) && !((GLJPanel) drawable).isOpaque() && ((GLJPanel) drawable).shouldPreserveColorBufferIfTranslucent()) {
			gl.glClear(GL2.GL_DEPTH_BUFFER_BIT);
		} else {
			gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
		}
 
		// Rotate the entire assembly of gears based on how the user
		// dragged the mouse around
 
		float pos[] = { 5.0f, 5.0f, 10.0f, 0.0f };
		float red[] = { 0.8f, 0.1f, 0.0f, 1.0f };
		float green[] = { 0.0f, 0.8f, 0.2f, 1.0f };
		float blue[] = { 0.2f, 0.2f, 1.0f, 1.0f };
 
		gl.glPushMatrix();
		gl.glRotatef(view_rotx, 1.0f, 0.0f, 0.0f);
		gl.glRotatef(view_roty, 0.0f, 1.0f, 0.0f);
		gl.glRotatef(view_rotz, 0.0f, 0.0f, 1.0f);
 
		// Place the first gear and call its display list
		gl.glPushMatrix();
		gl.glTranslatef(-3.0f, -2.0f, 0.0f);
		gl.glRotatef(angle, 0.0f, 0.0f, 1.0f);
		gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, blue, 0);
 
		gear(gl, 1.0f, 4.0f, 1.0f, 20, 0.7f);
		gl.glPopMatrix();
 
		// Place the second gear and call its display list
		gl.glPushMatrix();
		gl.glTranslatef(3.1f, -2.0f, 0.0f);
		gl.glRotatef(-2.0f * angle - 9.0f, 0.0f, 0.0f, 1.0f);
		gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, green, 0);
 
		gear(gl, 0.5f, 2.0f, 2.0f, 10, 0.7f);
		gl.glPopMatrix();
 
		// Place the third gear and call its display list
		gl.glPushMatrix();
		gl.glTranslatef(-3.1f, 4.2f, 0.0f);
		gl.glRotatef(-2.0f * angle - 25.0f, 0.0f, 0.0f, 1.0f);
		gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, red, 0);
 
		gear(gl, 1.3f, 2.0f, 0.5f, 10, 0.7f);
		gl.glPopMatrix();
 
		// Remember that every push needs a pop; this one is paired with
		// rotating the entire gear assembly
		gl.glPopMatrix();
	}
 
	@Override
	public void dispose(GLAutoDrawable arg0) {
		// TODO Auto-generated method stub
 
	}
 
	@Override
	public void init(GLAutoDrawable drawable) {
		GL3 gl = drawable.getGL().getGL3();
 
		System.err.println("INIT GL IS: " + gl.getClass().getName());
 
		System.err.println("Chosen GLCapabilities: " + drawable.getChosenGLCapabilities());
 
		gl.setSwapInterval(1);
 
		// gl.glLightfv(GL3.GL_LIGHT0, GL3.GL_POSITION, pos, 0);
		gl.glEnable(GL3.GL_CULL_FACE);
		// gl.glEnable(GL3.GL_LIGHTING);
		// gl.glEnable(GL3.GL_LIGHT0);
		gl.glEnable(GL3.GL_DEPTH_TEST);
 
		/* make the gears */
		// int gear1 = gl.glGenLists(1);
		// gl.glNewList(gear1, GL2.GL_COMPILE);
		// gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, red, 0);
		// gl.glEndList();
		// int gear2 = gl.glGenLists(1);
		// // gl.glNewList(gear2, GL2.GL_COMPILE);
		// gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, green, 0);
		// gl.glEndList();
 
		// int gear3 = gl.glGenLists(1);
		// gl.glNewList(gear3, GL2.GL_COMPILE);
		// gl.glMaterialfv(GL2.GL_FRONT, GL2.GL_AMBIENT_AND_DIFFUSE, blue, 0);
		// gl.glEndList();
		gl.glEnable(GL2.GL_NORMALIZE);
 
		/*
		 * if (drawable instanceof AWTGLAutoDrawable) { AWTGLAutoDrawable
		 * awtDrawable = (AWTGLAutoDrawable) drawable;
		 * awtDrawable.addMouseListener(this);
		 * awtDrawable.addMouseMotionListener(this); }
		 */
	}
 
	@Override
	public void reshape(GLAutoDrawable drawable, int arg1, int arg2, int arg3, int arg4) {
		GL2 gl = drawable.getGL().getGL2();
 
		float h = (float) 600 / (float) 800;
 
		gl.glMatrixMode(GL2.GL_PROJECTION);
 
		System.err.println("GL_VENDOR: " + gl.glGetString(GL2.GL_VENDOR));
		System.err.println("GL_RENDERER: " + gl.glGetString(GL2.GL_RENDERER));
		System.err.println("GL_VERSION: " + gl.glGetString(GL2.GL_VERSION));
		gl.glLoadIdentity();
		gl.glFrustum(-1.0f, 1.0f, -h, h, 5.0f, 60.0f);
		gl.glMatrixMode(GL2.GL_MODELVIEW);
		gl.glLoadIdentity();
		gl.glTranslatef(0.0f, 0.0f, -40.0f);
 
	}
 
	public static void gear(GL2 gl, float inner_radius, float outer_radius, float width, int teeth, float tooth_depth) {
		int i;
		float r0, r1, r2;
		float angle, da;
		float u, v, len;
 
		r0 = inner_radius;
		r1 = outer_radius - tooth_depth / 2.0f;
		r2 = outer_radius + tooth_depth / 2.0f;
 
		da = 2.0f * (float) Math.PI / teeth / 4.0f;
 
		gl.glShadeModel(GL2.GL_FLAT);
 
		gl.glNormal3f(0.0f, 0.0f, 1.0f);
 
		/* draw front face */
		gl.glBegin(GL2.GL_QUAD_STRIP);
		for (i = 0; i <= teeth; i++) {
			angle = i * 2.0f * (float) Math.PI / teeth;
			gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), width * 0.5f);
			gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), width * 0.5f);
			if (i < teeth) {
				gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), width * 0.5f);
				gl.glVertex3f(r1 * (float) Math.cos(angle + 3.0f * da), r1 * (float) Math.sin(angle + 3.0f * da), width * 0.5f);
			}
		}
		gl.glEnd();
 
		/* draw front sides of teeth */
		gl.glBegin(GL2.GL_QUADS);
		for (i = 0; i < teeth; i++) {
			angle = i * 2.0f * (float) Math.PI / teeth;
			gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), width * 0.5f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), width * 0.5f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + 2.0f * da), r2 * (float) Math.sin(angle + 2.0f * da), width * 0.5f);
			gl.glVertex3f(r1 * (float) Math.cos(angle + 3.0f * da), r1 * (float) Math.sin(angle + 3.0f * da), width * 0.5f);
		}
		gl.glEnd();
 
		/* draw back face */
		gl.glBegin(GL2.GL_QUAD_STRIP);
		for (i = 0; i <= teeth; i++) {
			angle = i * 2.0f * (float) Math.PI / teeth;
			gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), -width * 0.5f);
			gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), -width * 0.5f);
			gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), -width * 0.5f);
			gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), -width * 0.5f);
		}
		gl.glEnd();
 
		/* draw back sides of teeth */
		gl.glBegin(GL2.GL_QUADS);
		for (i = 0; i < teeth; i++) {
			angle = i * 2.0f * (float) Math.PI / teeth;
			gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), -width * 0.5f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + 2 * da), r2 * (float) Math.sin(angle + 2 * da), -width * 0.5f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), -width * 0.5f);
			gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), -width * 0.5f);
		}
		gl.glEnd();
 
		/* draw outward faces of teeth */
		gl.glBegin(GL2.GL_QUAD_STRIP);
		for (i = 0; i < teeth; i++) {
			angle = i * 2.0f * (float) Math.PI / teeth;
			gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), width * 0.5f);
			gl.glVertex3f(r1 * (float) Math.cos(angle), r1 * (float) Math.sin(angle), -width * 0.5f);
			u = r2 * (float) Math.cos(angle + da) - r1 * (float) Math.cos(angle);
			v = r2 * (float) Math.sin(angle + da) - r1 * (float) Math.sin(angle);
			len = (float) Math.sqrt(u * u + v * v);
			u /= len;
			v /= len;
			gl.glNormal3f(v, -u, 0.0f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), width * 0.5f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + da), r2 * (float) Math.sin(angle + da), -width * 0.5f);
			gl.glNormal3f((float) Math.cos(angle), (float) Math.sin(angle), 0.0f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + 2 * da), r2 * (float) Math.sin(angle + 2 * da), width * 0.5f);
			gl.glVertex3f(r2 * (float) Math.cos(angle + 2 * da), r2 * (float) Math.sin(angle + 2 * da), -width * 0.5f);
			u = r1 * (float) Math.cos(angle + 3 * da) - r2 * (float) Math.cos(angle + 2 * da);
			v = r1 * (float) Math.sin(angle + 3 * da) - r2 * (float) Math.sin(angle + 2 * da);
			gl.glNormal3f(v, -u, 0.0f);
			gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), width * 0.5f);
			gl.glVertex3f(r1 * (float) Math.cos(angle + 3 * da), r1 * (float) Math.sin(angle + 3 * da), -width * 0.5f);
			gl.glNormal3f((float) Math.cos(angle), (float) Math.sin(angle), 0.0f);
		}
		gl.glVertex3f(r1 * (float) Math.cos(0), r1 * (float) Math.sin(0), width * 0.5f);
		gl.glVertex3f(r1 * (float) Math.cos(0), r1 * (float) Math.sin(0), -width * 0.5f);
		gl.glEnd();
 
		gl.glShadeModel(GL2.GL_SMOOTH);
 
		/* draw inside radius cylinder */
		gl.glBegin(GL2.GL_QUAD_STRIP);
		for (i = 0; i <= teeth; i++) {
			angle = i * 2.0f * (float) Math.PI / teeth;
			gl.glNormal3f(-(float) Math.cos(angle), -(float) Math.sin(angle), 0.0f);
			gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), -width * 0.5f);
			gl.glVertex3f(r0 * (float) Math.cos(angle), r0 * (float) Math.sin(angle), width * 0.5f);
		}
		gl.glEnd();
	}
}

[martini_bird]

Salut,

GL3 n'est pas disponible chez moi (ça me semble assez normal car c'est un ordinateur de bureau avec une carte graphique on peut plus ordinaire).

Sinon, le test avec les roues dentées tournent bien, mais avec l'ancienne version de JOGL dont j'ai parlée au début.

Cordialement.

[plegat]

Bonjour

J'avais essayé de filer un coup de main sur cet autre post, ça s'est terminé par un retour à une ancienne vesion de JOGL...

Il faut aller fouiller dans les autres jar disponibles sur le site pour trouver lequel contient la classe ou la lib nécessaire.

Va falloir qu'ils améliorent leur procédure d'installation, ce n'est pas hyper clair de prime abord...

[martini_bird]

Salut,

Il faut aller fouiller dans les autres jar disponibles sur le site pour trouver lequel contient la classe ou la lib nécessaire.

J'ai testé pour vous : si l'on intègre une copie des librairies manquantes (libnativewindow_jvm et libjogl_gl2), jogl ne parvient pas à trouver un profil disponible :

Code :

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

1
2
3
4
Exception in thread "main" java.lang.ExceptionInInitializerError
	at geometry.renderer.gl.Test.<init>(Test.java:34)
	at geometry.renderer.gl.Test.main(Test.java:16)
Caused by: javax.media.opengl.GLException: No profile available: [GL2, GL2ES2, GL2ES1, GLES2, GLES1, GL2GL3, GL3]

Cela semble fonctionner en utilisant les anciennes librairies, mais le code suivant me renvoie une matrice nulle, d'où ma méfiance :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void display(GLAutoDrawable drawable) {
	GL2 gl = drawable.getGL().getGL2();
	gl.glMatrixMode(GL2.GL_MODELVIEW);
	gl.glLoadIdentity();
 
	double[] buf = new double[16];
	gl.glGetDoublev(GL2.GL_MODELVIEW, buf, 0);
 
	System.out.println("___________________________");
	System.out.println(buf[0]+" "+buf[4]+" "+ buf[8]+" "+buf[12]);
	System.out.println(buf[1]+" "+buf[5]+" "+ buf[9]+" "+buf[13]);
	System.out.println(buf[2]+" "+buf[6]+" "+buf[10]+" "+buf[14]);
	System.out.println(buf[3]+" "+buf[7]+" "+buf[11]+" "+buf[15]);	
}

Va falloir qu'ils améliorent leur procédure d'installation, ce n'est pas hyper clair de prime abord...

+1

Merci pour ton attention.

[martini_bird]

Salut,

bon, en fait l'erreur provenait d'une confusion dans mes imports : les fichiers sus-mentionnés ne sont donc plus nécessaires visiblement.

Je fais le bilan : j'ai compilé la dernière version de jogl et les tests sont réussis.

Par contre, je ne peux toujours pas activer le multisampling (ma carte graphique ne le supporte peut-être pas) et je ne comprends pas pourquoi je récupère une matrice nulle quand j'attends une matrice identité.

Cordialement.

[martini_bird]

J'ai fini par trouver : l'appel devait se faire sur le champ GL_MODELVIEW_MATRIX :

Code :

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

gl.glGetDoublev(GL2.GL_MODELVIEW_MATRIX, buf, 0);

Je découvre l'OPENGL et c'est ma joie...

En tout cas, merci pour votre aide.

Si un modo passe par là, il pourra marquer la discussion comme résolue.

Cordialement.