Java OpenGL

Java OpenGL (JOGL) est une bibliothèque qui permet d'utiliser OpenGL avec le langage de programmation Java^[1]^,^[2]. Elle était développée à l'origine par Kenneth Bradley Russell et Christopher John Kline, et fut développée par la suite par le Sun Microsystems Game Technology Group. Depuis 2010, c'est un projet open source indépendant sous BSD license. C'est l'implémentation de référence de Java Bindings for OpenGL (JSR-231).

JOGL permet d'accéder à la plupart des fonctionnalités disponibles en C, à l'exception notable des appels OpenGL utility toolkit (GLUT) relatifs au système de fenêtrage, comme Java a les siens, Abstract Window Toolkit (AWT), Swing, et quelques extensions.

Architecture

L'API de base en OpenGL C API, ainsi que son API de fenêtrage associée^[3], sont accédées en JOGL via des appels Java Native Interface (JNI). Pour cette raison, le système sousjacent doit supporter OpenGL pour que JOGL fonctionne.

JOGL diffère des quelques autres bibliothèques en Java enveloppant OpenGL en cela qu'il expose plus ou moins l'API procédurale d'OpenGL via des méthodes dans peu de classes, plutôt que d'essayer d'appliquer le paradigme de la programmation orientée objet à OpenGL. Ainsi, une grande partie du code de JOGL est auto-générée à partir des fichiers d'entête d'OpenGL en C via un outil de conversion appelé GlueGen, qui avait été programmé spécialement pour faciliter la création de JOGL.

Cette décision d'architecture a à la fois ses avantages et ses inconvénients. La nature procédurale et sous forme de machine à états d'OpenGL se marie mal avec la manière typique de programmer en Java, ce qui est fastidieux pour beaucoup de programmeurs. Cependant, la correspondance directe entre l'API OpenGL en C et les méthodes Java rend le portage d'applications existantes écrites en C et des exemples de code bien plus simple. La fine couche d'abstraction fournie par JOGL rend l'exécution efficace, mais elle est plus difficile à coder en comparaison à des bibliothèques d'abstraction de haut niveau tel que Java3D. Comme la plupart du code est auto-générée, les changements d'OpenGL peuvent être rapidement ajoutés à JOGL.

Statut et standardisation

À partir de 2007, JOGL fournit un accès complet à la spécification OpenGL 2.0. La dernière version 1.1.0 est l'implémentation de référence pour JSR-231 (Java Bindings for OpenGL)^[4]. La version 1.1.1 donne un accès limité aux GLU NURBS, permettant le rendu de courbes et de surfaces par le biais des APIs traditionnelles de GLU.

La version 2.0 est en développement à l'heure actuelle, laquelle inclut une modification mineure de l'API et le support des profils OpenGL GL 1.3 - 3.0, GL 3.1 - 3.3, GL ≥ 4.0, ES 1.x et ES 2.x.

Java2D-OpenGL inter-operabilité

Depuis la version Java SE 6 du langage Java, Java2D (l'API pour dessiner en 2D en Java) et JOGL sont devenus inter-opérables, ce qui permet :

Superposer Swing composants (menus légers, bulles, et d'autres widgets) au-dessus du rendu OpenGL.
Dessiner des graphismes 3D en OpenGL au-dessus du rendu Java2D (voir ici pour un bouton avec une icône en OpenGL).
Utiliser des graphismes 3D n'importe où ordinairement un widget Swing pourrait être utilisé. (À l'intérieur d'une JTable, JTree, ...)
Dessiner des graphismes Java2D au-dessus du rendu 3D en OpenGL.

Exemple de quad

Ce programme affiche un simple rendu 3D d'un polygone avec JOGL.

classe JoglExample—Cette classe utilise l'API JOGL (version 2.0) pour afficher un quad.

import java.awt.Component;
import java.awt.EventQueue;
import java.awt.Frame;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GL2ES1;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.awt.GLCanvas;
import javax.media.opengl.fixedfunc.GLLightingFunc;
import javax.media.opengl.fixedfunc.GLMatrixFunc;
import javax.media.opengl.glu.GLU;
import com.jogamp.opengl.util.Animator;

/**
 * Exemple rudimentaire (dans une seule classe pour faire simple) qui affiche un quad tournant
 */
public class JoglExample {
    
    private static final class JoglExampleKeyListener extends KeyAdapter {
        
        private final JoglExample joglExample;
        
        private JoglExampleKeyListener(JoglExample joglExample) {
            this.joglExample = joglExample;
        }
        
        @Override
        public void keyPressed(KeyEvent e) {
            if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
                joglExample.exit();
            }
        }
    }
    
    private static final class JoglExampleGLEventListener implements GLEventListener {
        
        private final JoglExample joglExample;

        private float rotateT = 0.0f;
        
        private GLU glu;
        
        private JoglExampleGLEventListener(JoglExample joglExample) {
            this.joglExample = joglExample;
        }

        @Override
        public void display(GLAutoDrawable gLDrawable) {
            final GL2 gl = gLDrawable.getGL().getGL2();
            gl.glClear(GL.GL_COLOR_BUFFER_BIT);
            gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
            gl.glLoadIdentity();
            gl.glTranslatef(0.0f, 0.0f, -5.0f);

            // rotate on the three axis
            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);

            // dessine un quad
            gl.glBegin(GL2.GL_QUADS);       
            gl.glColor3f(0.0f, 1.0f, 1.0f);   // set the color of the quad
            gl.glVertex3f(-1.0f, 1.0f, 0.0f);   // Top Left
            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
            // fini de dessiner le quad
            gl.glEnd();                                                     

            // augmente l'angle de rotation pour la prochaine iteration                   
            rotateT += 0.2f; 
        }

        @Override
        public void init(GLAutoDrawable glDrawable) {
            GL2 gl = glDrawable.getGL().getGL2();
            glu = GLU.createGLU(gl);
            gl.glShadeModel(GLLightingFunc.GL_SMOOTH);
            gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            gl.glClearDepth(1.0f);
            gl.glEnable(GL.GL_DEPTH_TEST);
            gl.glDepthFunc(GL.GL_LEQUAL);
            gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
            ((Component) glDrawable).addKeyListener(new JoglExampleKeyListener(joglExample));
        }

        @Override
        public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width, int height) {
            GL2 gl = gLDrawable.getGL().getGL2();
            if (height <= 0) {
                height = 1;
            }
            float h = (float) width / (float) height;
            gl.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
            gl.glLoadIdentity();
            glu.gluPerspective(50.0f, h, 1.0, 1000.0);
            gl.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
            gl.glLoadIdentity();
        }

        @Override
        public void dispose(GLAutoDrawable gLDrawable) {
            // ne fait rien du tout
        }
    }
    
    private final GLCanvas canvas;

    private final Frame frame;

    private final Animator animator;
    
    public JoglExample() {
        canvas = new GLCanvas();
        frame = new Frame("Jogl Quad drawing");
        animator = new Animator(canvas);
        canvas.addGLEventListener(new JoglExampleGLEventListener(this));
        frame.add(canvas);
        frame.setSize(640, 480);
        frame.setUndecorated(true);
        frame.setExtendedState(Frame.MAXIMIZED_BOTH);
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                exit();
            }
        });
        frame.setVisible(true);
        animator.start();
        canvas.requestFocus();
    }
    
    public void exit() {
        animator.stop();
        frame.dispose();
        System.exit(0);
    }

    public static void main(String[] args) {
        // Les méthodes AWT doivent être invoquées depuis l'EDT d'AWT
        EventQueue.invokeLater(new Runnable() {
            
            @Override
            public void run() {
                new JoglExample();
            }
        });
    }
}

Voir aussi

Java Bindings for OpenGL, The Java Community Specification Request for which JOGL provides an implementation
Ardor3D, un scénographe très performant, professionnel utilisant JOGL
Xith3D, un scénographe utilisant JOGL
Elflight Engine, un moteur de jeu très performant optimisé pour le Web
JMonkey Engine, un scénographe très performant, professionnel utilisant JOGL (uniquement dans JMonkeyEngine 2.0, support non officiel dans JMonkeyEngine 3)
Wakfu, un jeu de rôle multijoueur en ligne utilisant JOGL
Poxnora, un jeu multi-joueur en ligne utilisant JOGL
Wurm Online, un MMORPG dans un univers fantastique utilisant JOGL
RuneScape, un MMORPG utilisant JOGL
Jake2, le portage Java de Quake II utilisant JOGL comme API graphique de bas niveau
Scilab, un programme de calcul numérique utilisant JOGL pour le rendu 2D et 3D
Jreality, un paquetage de visualisation scientifique utilisant JOGL

Références

↑ « Open source Java projects: Java Binding for OpenGL (JOGL) », JavaWorld, 18 septembre 2008 (consulté le 6 février 2011) : « JOGL originated as a project named Jungle, which was created by 3D graphics experts Ken Russell (of Sun Microsystems) and Chris Kline (of Irrational Games). »
↑ « Hello JOGL », JavaWorld, 21 février 2005 (consulté le 6 février 2011)
↑ « 3D & Multimedia Across Platforms and Devices Using JOGL », SIGGRAPH, 27 juillet 2010 (consulté le 6 février 2011)
↑ « JSR-000231 Java Bindings for the OpenGL API », Java Community Process (consulté le 6 février 2011) : « In order to facilitate maximum community participation for the Java Binding for the OpenGL API, we use the JOGL project on java.net found at https://jogl.dev.java.net. The JOGL source code can be found there, licensed under a liberal source code license (mostly licensed as BSD except where we use other parties' licensed code). We take a snapshot of the code from this project every few months, run the Technology Compatibility Kit on the source code, and then officially make it the Reference Implementation for each formal Java Binding for the OpenGL API release. »

Liens externes

Site officiel
Spécification de JOGL 2.x
Spécification de la JSR 231 (draft)
JSR-231 Java Bindings for OpenGL site web
tool kiet, Le guide de la programmation OpenGL avec des exemples utilisant JOGL
Tutoriels de Nehe et exemples de code
Paramétrer JOGL dans Eclipse
Paramétrer JOGL dans une JFrame Swing
NetBeans OpenGL Pack, plug-in de développement en OpenGL pour l'EDI NetBeans
Viewer3D, une applet qui affiche du contenu interactif en 3D avec JOGL
Eclipse OpenGL Pack plug-in OpenGL pour l'EDI Eclipse

Portail de la programmation informatique

[1] « Open source Java projects: Java Binding for OpenGL (JOGL) », JavaWorld, 18 septembre 2008 (consulté le 6 février 2011) : « JOGL originated as a project named Jungle, which was created by 3D graphics experts Ken Russell (of Sun Microsystems) and Chris Kline (of Irrational Games). »

[2] « Hello JOGL », JavaWorld, 21 février 2005 (consulté le 6 février 2011)

[3] « 3D & Multimedia Across Platforms and Devices Using JOGL », SIGGRAPH, 27 juillet 2010 (consulté le 6 février 2011)

[4] « JSR-000231 Java Bindings for the OpenGL API », Java Community Process (consulté le 6 février 2011) : « In order to facilitate maximum community participation for the Java Binding for the OpenGL API, we use the JOGL project on java.net found at https://jogl.dev.java.net. The JOGL source code can be found there, licensed under a liberal source code license (mostly licensed as BSD except where we use other parties' licensed code). We take a snapshot of the code from this project every few months, run the Technology Compatibility Kit on the source code, and then officially make it the Reference Implementation for each formal Java Binding for the OpenGL API release. »

[1]

[2]

[3]

[4]