JOGL-OPENGL bugs/crash/vitesse reduite

J'essai de faire une petite classe de test pour me familiariser avec JOGL et opengl.
Donc j'ai repris des petits bouts de codes un peu partout pour faire une demo avec un cube en rotation et ses 6 faces coloriées avec une couleur différente.

La demo fonctionne mais j'ai 3 gros bugs :bug:

Le premier quand j'utilise plus les fonctions gl.glColor3f(); et gl.glVertex3f();
mais que je passe par la creation de 2 tableaux de floats (color et vertex) puis que je passe les données dans des buffers et qu'enfin j'affiche avec le mécanisme de gl.glDrawArrays (GL.GL_QUADS, 0, 24). La machine virtuel de java crash de maniere aleatoire.

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

# # An unexpected error has been detected by Java Runtime Environment: # # EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x0b89ff11, pid=224, tid=1800 # # Java VM: Java HotSpot(TM) Client VM (1.6.0-b105 mixed mode) # Problematic frame: # C 0x0b89ff11 # # If you would like to submit a bug report, please visit: # http://java.sun.com/webapps/bugreport/crash.jsp #   --------------- T H R E A D ---------------   Current thread (0x0adaa800): JavaThread "AWT-EventQueue-0" [_thread_in_native, id=1800]   siginfo: ExceptionCode=0xc0000005, reading address 0x0b9b2000   Registers: EAX=0x0c04485c, EBX=0x0b774180, ECX=0x00000000, EDX=0x00000008 ESP=0x0b19f210, EBP=0x3f800000, ESI=0x0b9b2000, EDI=0x00000000 EIP=0x0b89ff11, EFLAGS=0x00010206   Top of Stack: (sp=0x0b19f210) 0x0b19f210: 00000008 0b774180 00000000 0bd70f28 0x0b19f220: 697faf36 0b774180 0c044858 00000000 0x0b19f230: 00000008 0bd70480 00000000 00000007 0x0b19f240: 00000006 00000000 00000055 0b89fec0 0x0b19f250: 697fb020 00000007 00000000 00000008 0x0b19f260: 0b774180 695c2019 0b774180 00000007 0x0b19f270: 00000000 00000008 0adaa800 06e89f60 0x0b19f280: 02a54350 0b19f298 10003ff5 00000007   Instructions: (pc=0x0b89ff11) 0x0b89ff01: 08 8b 35 a0 04 78 0b 8b 76 64 8d 3c 49 8d 34 be 0x0b89ff11: 8b 3e 8b 6e 04 89 78 0c 89 68 10 8b 7e 08 89 78     Stack: [0x0b150000,0x0b1a0000), sp=0x0b19f210, free space=316k Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code) C 0x0b89ff11   [error occurred during error reporting, step 120, id 0xc0000005]   Java frames: (J=compiled Java code, j=interpreted, Vv=VM code) J com.sun.opengl.impl.GLImpl.glDrawArrays(III)V J TestJOGL.display(Ljavax/media/opengl/GLAutoDrawable;)V J com.sun.opengl.impl.GLDrawableHelper.display(Ljavax/media/opengl/GLAutoDrawable;)V J javax.media.opengl.GLJPanel$Updater.display(Ljavax/media/opengl/GLAutoDrawable;)V J com.sun.opengl.impl.GLDrawableHelper.display(Ljavax/media/opengl/GLAutoDrawable;)V J com.sun.opengl.impl.GLPbufferImpl$DisplayAction.run()V J com.sun.opengl.impl.GLDrawableHelper.invokeGL(Ljavax/media/opengl/GLDrawable;Ljavax/media/opengl/GLContext;Ljava/lang/Runnable;Ljava/lang/Runnable;)V J com.sun.opengl.impl.GLPbufferImpl.maybeDoSingleThreadedWorkaround(Ljava/lang/Runnable;Ljava/lang/Runnable;Z)V J com.sun.opengl.impl.GLPbufferImpl.display()V J javax.media.opengl.GLJPanel.paintComponent(Ljava/awt/Graphics;)V J javax.swing.JComponent.paint(Ljava/awt/Graphics;)V J javax.swing.JComponent.paintToOffscreen(Ljava/awt/Graphics;IIIIII)V J javax.swing.BufferStrategyPaintManager.paint(Ljavax/swing/JComponent;Ljavax/swing/JComponent;Ljava/awt/Graphics;IIII)Z J javax.swing.RepaintManager.paint(Ljavax/swing/JComponent;Ljavax/swing/JComponent;Ljava/awt/Graphics;IIII)V J javax.swing.JComponent._paintImmediately(IIII)V J javax.swing.JComponent.paintImmediately(IIII)V J javax.swing.RepaintManager.paintDirtyRegions(Ljava/util/Map;)V J javax.swing.RepaintManager.paintDirtyRegions()V J com.sun.opengl.util.Animator$1.run()V J java.awt.event.InvocationEvent.dispatch()V J java.awt.EventQueue.dispatchEvent(Ljava/awt/AWTEvent;)V J java.awt.EventDispatchThread.pumpOneEventForFilters(I)Z j java.awt.EventDispatchThread.pumpEventsForFilter(ILjava/awt/Conditional;Ljava/awt/EventFilter;)V+30 j java.awt.EventDispatchThread.pumpEventsForHierarchy(ILjava/awt/Conditional;Ljava/awt/Component;)V+11 j java.awt.EventDispatchThread.pumpEvents(ILjava/awt/Conditional;)V+4 j java.awt.EventDispatchThread.pumpEvents(Ljava/awt/Conditional;)V+3 j java.awt.EventDispatchThread.run()V+9 v ~StubRoutines::call_stub   --------------- P R O C E S S ---------------   Java Threads: ( => current thread ) 0x00386400 JavaThread "DestroyJavaVM" [_thread_blocked, id=2488] 0x0ade7000 JavaThread "Thread-2" [_thread_blocked, id=3492] =>0x0adaa800 JavaThread "AWT-EventQueue-0" [_thread_in_native, id=1800] 0x0ad9a000 JavaThread "AWT-Windows" daemon [_thread_in_native, id=2236] 0x0ad99400 JavaThread "AWT-Shutdown" [_thread_blocked, id=3228] 0x0aaed800 JavaThread "Java2D Disposer" daemon [_thread_blocked, id=1108] 0x0aa8b400 JavaThread "Low Memory Detector" daemon [_thread_blocked, id=3924] 0x0aa88400 JavaThread "CompilerThread0" daemon [_thread_blocked, id=3660] 0x0aa85800 JavaThread "Attach Listener" daemon [_thread_blocked, id=3856] 0x0aa84800 JavaThread "Signal Dispatcher" daemon [_thread_blocked, id=3252] 0x0aa76800 JavaThread "Finalizer" daemon [_thread_blocked, id=184] 0x0aa72400 JavaThread "Reference Handler" daemon [_thread_blocked, id=3600]   Other Threads: 0x0aa6f400 VMThread [id=1628] 0x0aa96000 WatcherThread [id=2424]   VM state:not at safepoint (normal execution)   VM Mutex/Monitor currently owned by a thread: None   Heap def new generation total 960K, used 295K [0x02960000, 0x02a60000, 0x02e40000) eden space 896K, 29% used [0x02960000, 0x029a31e0, 0x02a40000) from space 64K, 42% used [0x02a50000, 0x02a56d18, 0x02a60000) to space 64K, 0% used [0x02a40000, 0x02a40000, 0x02a50000) tenured generation total 4096K, used 2020K [0x02e40000, 0x03240000, 0x06960000) the space 4096K, 49% used [0x02e40000, 0x03039138, 0x03039200, 0x03240000) compacting perm gen total 12288K, used 8102K [0x06960000, 0x07560000, 0x0a960000) the space 12288K, 65% used [0x06960000, 0x07149a18, 0x07149c00, 0x07560000) No shared spaces configured.   Dynamic libraries: 0x00400000 - 0x00423000 C:\Program Files\Java\jre1.6.0\bin\javaw.exe 0x7c910000 - 0x7c9c7000 C:\WINDOWS\system32\ntdll.dll 0x7c800000 - 0x7c905000 C:\WINDOWS\system32\kernel32.dll 0x77da0000 - 0x77e4c000 C:\WINDOWS\system32\ADVAPI32.dll 0x77e50000 - 0x77ee1000 C:\WINDOWS\system32\RPCRT4.dll 0x7e390000 - 0x7e420000 C:\WINDOWS\system32\USER32.dll 0x77ef0000 - 0x77f37000 C:\WINDOWS\system32\GDI32.dll 0x7c340000 - 0x7c396000 C:\Program Files\Java\jre1.6.0\bin\msvcr71.dll 0x6d7c0000 - 0x6da07000 C:\Program Files\Java\jre1.6.0\bin\client\jvm.dll 0x76ae0000 - 0x76b0f000 C:\WINDOWS\system32\WINMM.dll 0x6d310000 - 0x6d318000 C:\Program Files\Java\jre1.6.0\bin\hpi.dll 0x76ba0000 - 0x76bab000 C:\WINDOWS\system32\PSAPI.DLL 0x6d770000 - 0x6d77c000 C:\Program Files\Java\jre1.6.0\bin\verify.dll 0x6d3b0000 - 0x6d3cf000 C:\Program Files\Java\jre1.6.0\bin\java.dll 0x6d7b0000 - 0x6d7bf000 C:\Program Files\Java\jre1.6.0\bin\zip.dll 0x6d000000 - 0x6d1c3000 C:\Program Files\Java\jre1.6.0\bin\awt.dll 0x72f50000 - 0x72f76000 C:\WINDOWS\system32\WINSPOOL.DRV 0x77be0000 - 0x77c38000 C:\WINDOWS\system32\msvcrt.dll 0x76320000 - 0x7633d000 C:\WINDOWS\system32\IMM32.dll 0x774a0000 - 0x775dd000 C:\WINDOWS\system32\ole32.dll 0x5b090000 - 0x5b0c8000 C:\WINDOWS\system32\uxtheme.dll 0x736b0000 - 0x736f9000 C:\WINDOWS\system32\ddraw.dll 0x73b10000 - 0x73b16000 C:\WINDOWS\system32\DCIMAN32.dll 0x6d2b0000 - 0x6d303000 C:\Program Files\Java\jre1.6.0\bin\fontmanager.dll 0x74690000 - 0x746db000 C:\WINDOWS\system32\MSCTF.dll 0x7c9d0000 - 0x7d1f3000 C:\WINDOWS\system32\shell32.dll 0x77f40000 - 0x77fb6000 C:\WINDOWS\system32\SHLWAPI.dll 0x77390000 - 0x77493000 C:\WINDOWS\WinSxS\x86_Microsoft.Windows.Common-Controls_6595b64144ccf1df_6.0.2600.2982_x-ww_ac3f9c03\comctl32.dll 0x58b50000 - 0x58bea000 C:\WINDOWS\system32\comctl32.dll 0x10000000 - 0x1004d000 C:\Program Files\Java\jogl\jogl-1.1.0-pre-20070307-windows-i586\lib\jogl.dll 0x5f070000 - 0x5f13c000 C:\WINDOWS\system32\OPENGL32.dll 0x6cef0000 - 0x6cf11000 C:\WINDOWS\system32\GLU32.dll 0x69500000 - 0x69b7f000 C:\WINDOWS\system32\nvoglnt.dll   VM Arguments: jvm_args: -Djava.library.path=C:\Program Files\Java\jogl\jogl-1.1.0-pre-20070307-windows-i586\lib;C:\Program Files\Java\jogl\jogl-1.1.0-pre-20070307-windows-i586\lib java_command: TestJOGL Launcher Type: SUN_STANDARD   Environment Variables: PATH=C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\Program Files\QuickTime\QTSystem\;C:\Program Files\Fichiers communs\Autodesk Shared\;C:\Program Files\Autodesk\backburner\;C:\Program Files\Fichiers communs\Adobe\AGL;C:\Program Files\Java\jdk1.6.0_01\bin\;C:\Program Files\NVIDIA Corporation\Cg\bin;C:\Program Files\GnuWin32\bin USERNAME=Christophe OS=Windows_NT PROCESSOR_IDENTIFIER=x86 Family 15 Model 4 Stepping 3, GenuineIntel       --------------- S Y S T E M ---------------   OS: Windows XP Build 2600 Service Pack 2   CPU:total 2 family 15, cmov, cx8, fxsr, mmx, sse, sse2, ht   Memory: 4k page, physical 1047916k(342968k free), swap 2521736k(1886696k free)   vm_info: Java HotSpot(TM) Client VM (1.6.0-b105) for windows-x86, built on Nov 29 2006 00:48:48 by "java_re" with unknown MS VC++:1310

---

Le deuxieme "bug" , si j'utilise awt pour faire une Frame et GLCanvas , l'animation du cube est bcp bcp plus lente , je dirais 2 fois moins rapide qu'avec les composants swing JFrame et GLJPanel.
Es ce normal car les composants awt sont plus "lourd" que ceux de swing ?
(j'utilise la version 1.6 de java et je suis sous windows)


Le troisième "bug" quand la demo ne plante pas au bout de quelques rotations un triangle d'une des faces du cube devient transparente.

Je vous met le code :

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 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

import java.awt.event.*; import javax.swing.*; import java.awt.*; import javax.media.opengl.*; import javax.media.opengl.glu.*; import com.sun.opengl.util.*; import java.nio.FloatBuffer;   /*  * Pour utiliser Opengl notre classe doit implémenter l'interface  * GLEventListener. Cela va nous permettre d'utiliser les fonctionalités  * d'OpenGl avec le JPanel.  * L'interface oblige a redefinir 4 méthodes:  * -- init() // Cette methode est appelée une fois ,elle va contenir l'initialisation  * -- display()  * // Cette methode sera appélé en boucle et contiendra  * // toute la partie affichage  * -- reshape()  * // Cette methode est appelé quand il ya un redimensionnement de la fenêtre  * // afin d'eviter un affichage diforme  * -- displayChanged()  */ public class TestJOGL implements GLEventListener {   private float rotateT = 0.0f; private static final GLU glu = new GLU();     public static void main(String[] args) {   /*Creation d'une fenetre * Utilisation d'un composant swing */ JFrame frame = new JFrame("Esssai de java openGl"); //Frame frame = new Frame("Esssai de java openGl");   /*Creation d'un paneau * Utilisation d'un composant swing plutot qu'awt(GLCanvas) * C'est le paneau sur lequel on dessine */ //GLJPanel panel = new GLJPanel(); GLCanvas panel = new GLCanvas();   /* On attache un "ecouteur" a la surface dessinable qui va capturer * les évenements de la classe TestJOGL */ panel.addGLEventListener(new TestJOGL());   /* * On ajoute le panneau a la fenetre * (layout par defaut (BorderLayout)) */ frame.add(panel);     /*Creation de l'animator * Il va gérer l'appel en boucle de la méthode display(), * qui s'occupe de la creation de l'image   * L'animator crée un thread dans lequel les appels a display()   * sont effectués.Il va aussi se charger de faire   * une pause entre chaque rafraichissement de l'image pour   * permettre aux autres threads ou processus de s'executer.   * On peut reduire la pause avec cette methode setRunAsFastAsPossible(true); * Il possède deux méthodes principales : start() et stop() * pour lancer et arreter l'animation. */ final Animator animator = new Animator(panel);   /* * Bout de code habituel qui permet de fermer * la fenetre.Voir cours sur les api Graphiques */ frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {     // Creation d'un thread que se charge d'arreter l'annimator // avant l'arret du programme new Thread(new Runnable(){ public void run() { animator.stop(); // stop l'affichage System.exit(0); // quite le programme } }).start(); } });   /* * Modifie la resolution de la fenetre */ frame.setSize(400, 400);   /* *Rend la fenetre visible */ frame.setVisible(true);   /* * Lance le thread qui se charge de l'affichage */ animator.start(); }   /**                  * GLEventListener renvoie un contexte (drawable)                  * Qui va nous permettre d'instancier un objet                  * de type GL à partir du quel on utilisera                  * les fonctions OpenGL.                  * */ public void init(GLAutoDrawable drawable) {   // Instanciation de l'objet GL final GL gl = drawable.getGL();   /* * Désactive la synchronisation verticale * indépendement de la plate forme utilisée */ gl.setSwapInterval(1);     //gl.glShadeModel(GL.GL_SMOOTH);   /* Methode qui etablit vers quel couleur la fenetre sera * vidé en l'occurence le blanc */ gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);     /* * indique la valeur de profondeur (entre 0.0 et 1.0) * utilisée par glClear pour effacer le tampon de profondeur */ gl.glClearDepth(1.0f);   gl.glEnable(GL.GL_DEPTH_TEST);   gl.glDepthFunc(GL.GL_LEQUAL);   //Tableau avec les coordonnées des sommets float vertices []= new float[] { 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,   0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,   0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,   1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,   1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,   0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f}; float couleurs []= new float[]{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,   0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,   1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,   0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,   1.5f, 0.5f, 0.0f, 1.5f, 0.5f, 0.0f, 1.5f, 0.5f, 0.0f, 1.5f, 0.5f, 0.0f};   FloatBuffer verticesBuff = BufferUtil.newFloatBuffer(24*3); FloatBuffer couleursBuff = BufferUtil.newFloatBuffer(24*3);   verticesBuff.put(vertices); couleursBuff.put(couleurs); verticesBuff.rewind(); couleursBuff.rewind();   gl.glEnableClientState(GL.GL_VERTEX_ARRAY); gl.glEnableClientState(GL.GL_COLOR_ARRAY);   gl.glVertexPointer(3, GL.GL_FLOAT,0,verticesBuff); gl.glColorPointer(3, GL.GL_FLOAT,0,couleursBuff); }   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { final GL gl = drawable.getGL(); if(height <= 0) { height = 1; } final float h = (float)width / (float)height;   gl.glMatrixMode(GL.GL_PROJECTION); gl.glLoadIdentity(); glu.gluPerspective(50.0f, h, 2.0, 1000.0); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glLoadIdentity(); }   public void display(GLAutoDrawable drawable) {   GL gl = drawable.getGL();   /* glClear() * efface les tampons à l'intérieur du "viewport * glClear prend un seul argument qui est * un masque de bits de plusieurs valeurs, * chacune indiquant un tampon à effacer. * * GL_COLOR_BUFFER_BIT ==> Indique les tampons de couleurs * actuellement utilisés en écriture. * * GL_DEPTH_BUFFER_BIT ==> Indique le tampon de profondeur */ gl.glClear(GL.GL_COLOR_BUFFER_BIT |GL.GL_DEPTH_BUFFER_BIT);     // remplace la matrice courante par la matrice d'identité gl.glLoadIdentity();   /* *Déplace l'origine du système de coordonnées au point spécifié * La matrice courante est multipliée par cette matrice de translation * Si la matrice courante est soit GL_MODELVIEW soit GL_PROJECTION, tous * les objets dessinés après l'appel à glTranslate subissent * cette translation. */ gl.glTranslatef(0.0f, 0.0f, -5.0f);   /* * calcule une matrice qui réalise la rotation d'angle degrés * dans le sens trigonométrique autour du vecteur (x, y, z). * Meme principe que glTranslate */ gl.glRotatef(300.0f, 250.0f, -155.0f, 115.0f);   gl.glRotatef(rotateT, 1.0f, 0.0f, 0.0f); gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f); gl.glRotatef(rotateT, 0.0f, 0.0f, 1.0f); gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f);     // La ligne magique gl.glDrawArrays (GL.GL_QUADS, 0, 24);   /* * Force l'execution des commandes non encore achevées */ gl.glFlush ();   rotateT += 0.2f;   /* gl.glBegin(GL.GL_QUADS);   gl.glColor3f(1.0f, 0.0f, 0.0f);   gl.glVertex3f(0.0f, 1.0f, 0.0f); gl.glVertex3f(1.0f, 1.0f, 0.0f); gl.glVertex3f(1.0f, 0.0f, 0.0f); gl.glVertex3f(0.0f, 0.0f, 0.0f);   gl.glColor3f(0.0f, 1.0f, 0.0f); gl.glVertex3f(0.0f, 1.0f, 0.0f); gl.glVertex3f(0.0f, 1.0f, 1.0f); gl.glVertex3f(1.0f, 1.0f, 1.0f); gl.glVertex3f(1.0f, 1.0f, 0.0f);   gl.glColor3f(0.0f, 0.0f, 1.0f); gl.glVertex3f(0.0f, 1.0f, 0.0f); gl.glVertex3f(0.0f, 1.0f, 1.0f); gl.glVertex3f(0.0f, 0.0f, 1.0f); gl.glVertex3f(0.0f, 0.0f, 0.0f);   gl.glColor3f(1.0f, 1.0f, 0.0f); gl.glVertex3f(1.0f, 1.0f, 0.0f); gl.glVertex3f(1.0f, 1.0f, 1.0f); gl.glVertex3f(1.0f, 0.0f, 1.0f); gl.glVertex3f(1.0f, 0.0f, 0.0f);   gl.glColor3f(0.0f, 1.0f, 1.0f); gl.glVertex3f(1.0f, 0.0f, 1.0f); gl.glVertex3f(1.0f, 0.0f, 0.0f); gl.glVertex3f(0.0f, 0.0f, 0.0f); gl.glVertex3f(0.0f, 0.0f, 1.0f);   gl.glColor3f(1.5f, 0.5f, 0.0f); gl.glVertex3f(0.0f, 1.0f, 1.0f); gl.glVertex3f(1.0f, 1.0f, 1.0f); gl.glVertex3f(1.0f, 0.0f, 1.0f); gl.glVertex3f(0.0f, 0.0f, 1.0f);   gl.glEnd();*/   } public void displayChanged(GLAutoDrawable drawable, boolean modeChanged,boolean deviceChanged) { } }

---

En esperant qu'une âme charitable est deja rencontré ce type de problème.

ouai moi :-)
essaye:

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 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

/*  * Pour utiliser Opengl notre classe doit implémenter l'interface  * GLEventListener. Cela va nous permettre d'utiliser les fonctionalités  * d'OpenGl avec le JPanel.  * L'interface oblige a redefinir 4 méthodes:  * -- init() // Cette methode est appelée une fois ,elle va contenir l'initialisation  * -- display()  * // Cette methode sera appélé en boucle et contiendra  * // toute la partie affichage  * -- reshape()  * // Cette methode est appelé quand il ya un redimensionnement de la fenêtre  * // afin d'eviter un affichage diforme  * -- displayChanged()  */ public class TestJOGL2 implements GLEventListener { private int large; private float rotateT = 0.0f; private static final GLU glu = new GLU(); /*pour resoudre le probleme du buffer*/ private float vertices []; private float couleurs []; private FloatBuffer verticesBuff = BufferUtil.newFloatBuffer(24*3); private FloatBuffer couleursBuff = BufferUtil.newFloatBuffer(24*3);   /**      * GLEventListener renvoie un contexte (drawable)      * Qui va nous permettre d'instancier un objet      * de type GL à partir du quel on utilisera      * les fonctions OpenGL.      * */ public void init(GLAutoDrawable drawable) { // Instanciation de l'objet GL final GL gl = drawable.getGL();   /*   * Désactive la synchronisation verticale   * indépendement de la plate forme utilisée   */ gl.setSwapInterval(1);     //gl.glShadeModel(GL.GL_SMOOTH);   /* Methode qui etablit vers quel couleur la fenetre sera   * vidé en l'occurence le noir   */ gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);     /*   * indique la valeur de profondeur (entre 0.0 et 1.0)   * utilisée par glClear pour effacer le tampon de profondeur   */ gl.glClearDepth(1.0f);   gl.glEnable(GL.GL_DEPTH_TEST);   gl.glDepthFunc(GL.GL_LEQUAL); /*Really Nice Perspective Calculations*/ gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);   //Tableau avec les coordonnées des sommets vertices = new float[]{ 0.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,   0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,   0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f,   1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f,   1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,   0.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f }; couleurs = new float[]{ 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,   0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f,   0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f,   1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,   0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f,   1.5f, 0.5f, 0.0f, 1.5f, 0.5f, 0.0f, 1.5f, 0.5f, 0.0f, 1.5f, 0.5f, 0.0f };   gl.glEnableClientState(GL.GL_VERTEX_ARRAY); gl.glEnableClientState(GL.GL_COLOR_ARRAY);     gl.glVertexPointer(3, GL.GL_FLOAT, 0,verticesBuff); gl.glColorPointer(3, GL.GL_FLOAT, 0,couleursBuff);       }   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { final GL gl = drawable.getGL(); if(height <= 0) { height = 1; } final float h = (float)width / (float)height;   gl.glMatrixMode(GL.GL_PROJECTION); gl.glLoadIdentity(); glu.gluPerspective(50.0f, h, 2.0, 1000.0); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glLoadIdentity(); }   public void display(GLAutoDrawable drawable) {   GL gl = drawable.getGL();   /* glClear()   * efface les tampons à l'intérieur du "viewport   * glClear prend un seul argument qui est   * un masque de bits de plusieurs valeurs,   * chacune indiquant un tampon à effacer.   *   * GL_COLOR_BUFFER_BIT ==> Indique les tampons de couleurs   * actuellement utilisés en écriture.   *   * GL_DEPTH_BUFFER_BIT ==> Indique le tampon de profondeur   */ gl.glClear(GL.GL_COLOR_BUFFER_BIT |GL.GL_DEPTH_BUFFER_BIT);   // remplace la matrice courante par la matrice d'identité gl.glLoadIdentity();   /*   *Déplace l'origine du système de coordonnées au point spécifié   * La matrice courante est multipliée par cette matrice de translation   * Si la matrice courante est soit GL_MODELVIEW soit GL_PROJECTION, tous   * les objets dessinés après l'appel à glTranslate subissent   * cette translation.   */ gl.glTranslatef(0.0f, 0.0f, -5.0f);   /*   * calcule une matrice qui réalise la rotation d'angle degrés   * dans le sens trigonométrique autour du vecteur (x, y, z).   * Meme principe que glTranslate   */ gl.glRotatef(300.0f, 250.0f, -155.0f, 115.0f); gl.glRotatef(rotateT, 1.0f, 0.0f, 0.0f); gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f); gl.glRotatef(rotateT, 0.0f, 0.0f, 1.0f); gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f);     /*forcé sinon les buffer sont vide*/ verticesBuff.put(vertices); couleursBuff.put(couleurs); verticesBuff.rewind(); couleursBuff.rewind(); // La ligne magique gl.glDrawArrays (GL.GL_QUADS, 0, 24); /*   * Force l'execution des commandes non encore achevées   */ gl.glFlush (); rotateT += 0.4f*large/300;       } public void displayChanged(GLAutoDrawable drawable, boolean modeChanged,boolean deviceChanged) { } public static void main(String[] args) {   /*Creation d'une fenetre   * Utilisation d'un composant swing   */ JFrame frame = new JFrame("Esssai de java openGl");     /*Creation d'un paneau   * Utilisation d'un composant swing plutot qu'awt(GLCanvas)   * C'est le paneau sur lequel on dessine   */ GLJPanel panel = new GLJPanel();   /* On attache un "ecouteur" a la surface dessinable qui va capturer   * les évenements de la classe TestJOGL   */ TestJOGL2 tmp = new TestJOGL2(); tmp.setLarge(400); panel.addGLEventListener(tmp); panel.repaint();   /*   * On ajoute le panneau a la fenetre   * (layout par defaut (BorderLayout))   */ frame.add(panel);     /*Creation de l'animator   * Il va gérer l'appel en boucle de la méthode display(),   * qui s'occupe de la creation de l'image   * L'animator crée un thread dans lequel les appels a display()   * sont effectués.Il va aussi se charger de faire   * une pause entre chaque rafraichissement de l'image pour   * permettre aux autres threads ou processus de s'executer.   * On peut reduire la pause avec cette methode setRunAsFastAsPossible(true);   * Il possède deux méthodes principales : start() et stop()   * pour lancer et arreter l'animation.   */ final Animator animator = new Animator(panel);   /*   * Bout de code habituel qui permet de fermer   * la fenetre.Voir cours sur les api Graphiques   */ frame.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) {     // Creation d'un thread que se charge d'arreter l'annimator // avant l'arret du programme new Thread(new Runnable(){ public void run() { animator.stop(); // stop l'affichage System.exit(0); // quite le programme } }).start(); } });   /*   * Modifie la resolution de la fenetre   */ frame.setSize(400, 400);   /*   *Rend la fenetre visible   */ frame.setVisible(true);   /*   * Lance le thread qui se charge de l'affichage   */ animator.start(); }   public void setLarge(int large) { this.large = large; }   }

---

C'est génial !! Ca marche bcp mieux , merci :)) :yaisse2:

Ah oui sinon avec les dernieres versions de JOGL et JAVA vaut mieux utilisé swing ou awt a ton avis ?


Et une dernière petite question tant que tu es dans les parrages.

Quand j'utilise glDrawArrays , je suis obligé d'utiliser 24 couleurs et 24 sommets pour dessiner mon cube ? ou il ya moyen d'avoir seulement 8 sommets et 6 couleurs dans les tableaux ?

Je pense que non mais je demande on sait jamais ^^

Hello,

Bien sur que si c'est possible. Utilise les tableaux d'indices!
Pour cela, regarde du coté des glDrawElements.

Bon coding, bye!

Sauf qu'avec les tableaux d'indices, on ne peut définir qu'une couleur par sommet. Donc pas possible d'avoir une couleur différente sur chaque face d'un cube, à ma connaissance... Même problème avec les normales et les coordonnées de textures.

Biensûr que non, c'est tout à fait possible. :P
Quand tu veux dessiner ta premiere face, tu pointes vers tes sommets et une couleur (de même que les normales). Quand tu veux dessiner une autre face, tu pointes vers tes nouveaux sommets dans ton tableau (même s'il y en a qui sont identiques) et une nouvelle couleur (et nouvelles normales par la même).
Ainsi, tu dessines tes faces avec des couleurs et des normales différentes avec un tableau de 8 sommets, un tableau de 6 couleurs, un tableau de 24 normales et ton tableau d'indices!
C'est assez simple à mettre en place, fonctionne très bien et est beaucoup plus optimisé car il y a moins d'informations à envoyer à la carte graphique.
Parce qu'il faut savoir que lors de l'utilisation des glDrawElements et cie, les sommets sont dupliqués pour le traitement.

Par exemple, prends l'exemple des VBOs! Ca fonctionne très bien pour les couleurs, normales et coords de textures.

Allez, sur ce, bonne continuation.

Citation:

---

Envoyé par kaliban

Ainsi, tu dessines tes faces avec des couleurs et des normales différentes avec un tableau de 8 sommets, un tableau de 6 couleurs, un tableau de 24 normales et ton tableau d'indices!

---

Bon alors je dois être un peu stupide, parce que je viens de re-regarder dans le Blue Book, et de faire un petit test vite fait, et je comprends pas comment je peut avoir un tableau de 8 sommets, un autre de 24 normales, et obtenir les bons couples sommets/normales à partir d'un seul tableau d'indices!

Les indices que je passe à glDrawElements, ils sont utilisés à la fois pour trouver le sommet, la couleur et la normale (enfin tout ce que j'ai passé à glEnableClientState). Donc tous ces tableaux doivent avoir la même "forme", çàd que les infos pour chaque sommet doivent se trouver aux mêmes positions dans chacun d'eux, non? En tout cas dans le test que je viens de faire c'est bien ce qui se passe:

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

static GLint vertices[] = { 0.0, 0.0, // Point n°0, utilisé par les 2 triangles 1.0, 0.0, // Point n°1, utilisé par les 2 triangles 1.0, 1.0, // Point n°2, utilisé par le premier triangle 0.0, 1.0 // Point n°3, utilisé par le second triangle };   static GLfloat colors[] = { 0, 0.5, 1, // Bleu pour le premier triangle 0, 0.5, 1, 0, 0.5, 1,   1, 0.5, 0, // Orange pour le second 1, 0.5, 0, 1, 0.5, 0 };   static GLubyte indices[] = { 0, 1, 2, // Premier triangle 0, 2, 3 // Second triangle };   void Main::Paint() { glClearColor(0.0, 0.0, 0.0, 1.0); glClear(GL_COLOR_BUFFER_BIT);   glEnableClientState (GL_COLOR_ARRAY); glEnableClientState (GL_VERTEX_ARRAY);   glColorPointer (3, GL_FLOAT, 0, colors); glVertexPointer (2, GL_INT, 0, vertices);   glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_BYTE, indices); }

---

Avec ce code, j'obtiens un triangle entièrement bleu et l'autre dans un joli dégradé du bleu à l'orange... Et je vois pas comment je peux arriver à tracer chaque triangle d'une couleur distincte en gardant le tableau de sommet "compacté" (sans redoublement de sommets).

En ce qui concerne les VBOs, ils peuvent très bien se faire avec un glDrawArrays, donc sans passer par un tableau d'indices, ou bien encore avec glDrawElements mais en dupliquant certains sommets.

PS: désolé Elendhil de squatter ton thread avec mes propres interrogations! :mrgreen:

PPS: je me rend bien compte que sur un "vrai" modèle avec des centaines de triangles, il peut-être intéressant d'utiliser un tableau d'indices vu que de nombreuses faces partageront la même couleur et la même courbure; mais à partir du moment où deux faces adjacentes ont une couleur ou des normales différentes, je pense qu'il est nécessaire de dupliquer les sommets communs.

oulala, mais qu'est-ce que je peux en raconter des conneries! mdrrr :P
Je viens de relire mon post et j'halucine de mes conneries tout seul! ahahah.
Je devais être pété quand j'ai écrit ca parce que c'est totalement faux.
Entre ce que j'écrivais et ce qu'on me racontait à côté (des conneries toujours d'ailleurs lol), j'ai fini par écrire n'importe quoi, sans même y réfléchir.
M'enfin, je suis fautif à 100%, vous pouvez me blâmer :lol:

D'ailleur le pire c'est que je dis 6 couleurs, et dans la même logique j'écris 24 normales 8O , va savoir pourquoi.

Ecoutez plutôt lorannt qui à tout à fait raison, il faut dupliquer les sommets qui ont des couleurs différentes.
Je suis impardonnable, et du coup je sais pu quoi dire moa :roll:

Allez, a la prochaine, pour peut-être d'autres anneries venant de moi, qui sait... :mouarf: