Bonjour,

Je viens de commencer à utiliser JOGL avec JAVA.

Ce code de base marche. Il m'affiche une fenêtre toute noir

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
import java.awt.*;
import java.awt.event.*;
 
import javax.media.opengl.*;
import javax.media.opengl.awt.GLCanvas;
 
import com.sun.opengl.util.*;
 
/**
 * Article1.java
 * author: InfoRital
 * 
 * Code source du premier article.
 * Article1 implémente {@link GLEventListener} pour obtenir le méchanisme de callback
 *
 */
 
public class Article1 implements GLEventListener {
 
	public static void main(String[] args) {
		/**
                 * Création d'une fenêtre 
                 * Nous utilisons la classe Frame de AWT
                 * plutôt que la classe JFrame de Swing
                 * pour une question de performance
                 */
		Frame frame = new Frame("Article1");
 
		/**
                 * Création du Canvas OpenGL
                 * pour pouvoir dessiner dessus
                 */
		GLCanvas canvas = new GLCanvas();
 
		/**
                 * Nous attachons ensuite le méchanisme de callback
                 * à notre surface dessinable
                 */
		canvas.addGLEventListener(new Article1());
 
		/**
                 * Nous attachons maintenant notre 
                 * surface dessinable à notre fenêtre 
                 */
		frame.add(canvas);
 
		/** 
                 * Création de l'Animator
                 * comme expliqué dans l'article
                 */
		final Animator animator = new Animator(canvas);
 
		/**
                 * Le code qui suit permet de gérer la fermeture
                 * de la fenêtre par l'utilisateur
                 */
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				/**
                                 * Nous créons un nouveau thread autre
                                 * que la queue d'évenements AWT
                                 * pour être d'arrêter l'Animator avant
                                 * de quitter complétement
                                 */
				new Thread(new Runnable() {
					public void run() {
						animator.stop();
						System.exit(0);
					}
				}).start();
			}
		});
 
		/**
                 * Nous donnons une taille à la fenêtre 
                 * et nous l'affichons
                 */
		frame.setSize(300, 300);
		frame.setVisible(true);
 
		/**
                 * Nous démarrons l'Animator qui
                 * va se charger de faire des appels
                 * à la méthode display();
                 */
		animator.start();
	}
 
	/**
         * init() sera appelée une fois au début de l'animation
         * C'est dans cette méthode que nous nous chargerons de toute
         * les opérations d'initialisation
         */
	public void init(GLAutoDrawable drawable) {
 
		/**
                 * GLEventListener renvoie un contexte (drawable)
                 * que nous allons utiliser pour instancier un objet
                 * de type GL, qui nous permettra d'utiliser
                 * les fonctions OpenGL, bien que dans cet article
                 * cela reste encore inutile
                 */
		GL gl = drawable.getGL();
 
		/**
                 * Cette fonction permet de désactiver
                 * la syncronisation verticale, indépendement
                 * de la plateforme utilisée
                 */
		gl.setSwapInterval(1);
 
	}
 
	/**
         * reshape() sera appelée si la fenêtre d'affichage est redimensionnée
         */
	public void reshape(GLAutoDrawable drawable, int x, int y, int width,
			int height) {
		GL gl = drawable.getGL();
 
	}
	/**
         * display() sera appelée en boucle tout au long de l'application
         * par la classe Animator. C'est dans cette fonction qu'on fera
         * tout ce qui doit être affiché
         */
	public void display(GLAutoDrawable drawable) {
 
		GL gl = drawable.getGL();
 
	}
 
	/**
         * displayChanged() est appelée si le mode d'affichage par exemple
         * est modifié. Cependant nous n'implémenterons pas cette méthode.
         */
	public void displayChanged(GLAutoDrawable drawable, boolean modeChanged,
			boolean deviceChanged) {
	}
 
	@Override
	public void dispose(GLAutoDrawable arg0) {
		// TODO Auto-generated method stub
 
	}
 
}
Je voudrais maintenant dessiner un carré. Pour cela, je dois mettre mon code dans la méthode "display". Pour dessiner mon carré voici mon code

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
      	gl.glBegin(GL.GL_QUADS);		        // Draw a quad
		gl.glVertex3f(-1.0f, 1.0f, 0.0f);  // Top left
		gl.gl.glVertex3f( 1.0f, 1.0f, 0.0f);  // Top right
		gl.glVertex3f( 1.0f,-1.0f, 0.0f);  // Bottom right
		gl.glVertex3f(-1.0f,-1.0f, 0.0f);	// Bottom left
	glEnd();
Quand je lance la compile, voici les erreurs

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
Exception in thread "AWT-EventQueue-0" java.lang.Error: Unresolved compilation problems: 
	GL.GL_QUADS cannot be resolved
	The method glVertex3f(float, float, float) is undefined for the type GL
	The method glVertex3f(float, float, float) is undefined for the type GL
	The method glVertex3f(float, float, float) is undefined for the type GL
	The method glVertex3f(float, float, float) is undefined for the type GLGL
Et c'est comme ça pour toutes les methodes que j'appele. D'ou vient le problème ?