Bonjour JOGL

Depuis quelques années maintenant, un programmeur souhaitant créer un programme à forte intensité graphique pouvant être vendu aux utilisateurs de différents systèmes d'exploitation n'avait qu'un seul choix: OpenGL. Le GL signifie bibliothèque graphique. OpenGL est une marque déposée de SGI. OpenGL se manifeste comme une API de programmation C multiplateforme. En réalité, il s'agit d'une spécification indépendante du matériel pour une interface de programmation.

OpenGL sert à créer des graphiques. C'est rapide. La plupart du temps, il s'agit d'une accélération matérielle. Il semble qu'OpenGL puisse faire visuellement tout ce que vous voudriez faire.

Malheureusement, OpenGL est écrit pour C. Avouons-le, C n'est pas le langage le plus populaire pour la programmation d'applications complexes. L'un des plus gros inconvénients d'OpenGL est que vous ne pouvez pas lui faire faire quoi que ce soit sans une fenêtre pour insérer vos graphiques, mais OpenGL ne vous permet pas de créer des fenêtres. Cela rend OpenGL difficile à apprendre pour les débutants.

Heureusement, GLUT (OpenGL Utility Toolkit) a été introduit et a facilité la gestion des fenêtres, des boutons et des événements générés par les utilisateurs. Pourtant, apprendre OpenGL en C ou même C ++ peut être pénible pour les nouveaux programmeurs ou programmeurs qui souhaitent utiliser une véritable programmation orientée objet.

Puis vint JOGL

Java est probablement le vrai langage de programmation orienté objet le plus populaire. Il y a eu de nombreuses tentatives pour marier OpenGL avec Java, mais la première qui a incité tout le monde à se lever et à prendre note était les liaisons Java pour OpenGL, ou JOGL. La raison en est que cet effort est soutenu par Sun Microsystems (les créateurs de Java) et SGI (les créateurs d'OpenGL).

De nos jours, JOGL est développé par le groupe de technologie de jeu de Sun. Il a commencé sa vie sous le nom de Jungle développé par Ken Russel et Chris Kline. Russell est un employé de Sun travaillant sur la machine virtuelle HotSpot avec de nombreuses années d'expérience en 3D. Kline travaille pour Irrational Games et est également très expérimenté avec les graphismes 3D.

Je suis personnellement reconnaissant pour leurs efforts et les efforts de tous ceux qui travaillent sur JOGL. Il y a eu plusieurs tentatives pour donner accès à OpenGL via une API Java conviviale, parmi lesquelles Java 3D, OpenGL pour la technologie Java (gl4java) et Lightweight Java Game Library (LWJGL). JOGL est le premier avec lequel je me suis senti à l'aise.

JOGL est l'ensemble de liaisons de classe Java pris en charge par Sun pour OpenGL. Hou la la! C'était une bouchée.

OpenGL est utilisé pour afficher des modèles 3D. Il est puissant, rapide et peut-être la meilleure chose qui soit arrivée à Java depuis l'introduction de Swing. En utilisant OpenGL via JOGL, vous serez en mesure de créer des jeux sympas ou des modèles de situations qui pourraient être trop coûteux à créer. Des tomes épais ont été écrits décrivant OpenGL. Ils vous seront utiles une fois que vous vous y retrouverez, mais pas encore. Vous devez apprendre comment tout cela s'applique aux API Java qui vous exposent OpenGL. Vous avez également besoin de quelques introductions de base net.java.games.jogl.*et peut-être de quelques rafraîchissements sur les mathématiques.

Vous avez JOGL?

Si vous souhaitez utiliser JOGL, vous devrez obtenir le jogl.jarcode natif qui l'accompagne. Je rêve du jour où il est standard avec l'installation de Java, mais pour l'instant c'est juste un rêve bien placé.

La première astuce consiste à trouver les binaires de votre système d'exploitation et à les extraire. Je les ai trouvés sur //games-binaries.dev.java.net/build/index.html. Chaque système d'exploitation est différent, mais l'installation se fait en deux parties. Le jogl.jardoit être placé dans le chemin de classe du système, et la bibliothèque binaire doit être placée partout où les bibliothèques vont dans votre système d'exploitation. Si vous avez de la chance, vous aurez un installateur pour le faire pour vous. Si vous ne disposez pas d'un programme d'installation et ne savez pas où chercher des informations sur le placement de tout sur votre ordinateur, vous pouvez commencer par les liens que j'ai fournis dans Ressources. Notre premier exemple de code sera écrit spécifiquement pour tester si vous avez tout installé correctement, vous n'avez donc pas à vous soucier de tester votre installation jusque-là.

Javadocs pour JOGL

Les Javadocs peuvent être obtenus au même endroit que la distribution binaire de JOGL. Les Javadocs porteront un nom similaire à jogl-1.0-usrdoc.tar.

Si vous parcourez le net.java.games.joglpackage, vous remarquerez rapidement que certaines classes sont énormes. GL en est un parfait exemple. Ne soyez pas rebuté par ça. Vous découvrirez rapidement que vous êtes capable de faire un travail assez sophistiqué même avec juste une petite quantité de connaissances JOGL. Les cours sur lesquels vous voudrez peut-être jeter un coup d'œil sont:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Ce seront votre interface de base dans le monde des graphiques. Si vous vous en souvenez, j'ai mentionné plus tôt que l'un des plus grands inconvénients pour les débutants qui apprennent OpenGL est l'absence d'une norme de système de fenêtrage. GLUT aide beaucoup à cet égard pour nos homologues C, mais nous avons Swing et l'AWT (Abstract Window Toolkit). Il est très probable que vous ayez déjà utilisé AWT ou Swing, vous n'aurez donc pas l'impression d'apprendre tout à partir de zéro. C'est une bonne chose. Après une très brève introduction à la création d'un composant pour JOGL à l'écran, nous n'aurons pas besoin de beaucoup de travail pour vous faire exécuter des applications plutôt cool et branchées!

GlueGen ... presque aussi cool que JOGL?

Comme vous devez le savoir, OpenGL est écrit pour les programmeurs C. Cela signifie que pour que Java en profite, il doit y avoir une interface native. Cela signifie que JNI (Java Native Interface), qui n'est ni amusant ni joli, doit être écrit pour établir cette connexion. OpenGL est assez gros. L'écriture de toutes ces connexions prend du temps. Pour rendre les choses un peu plus difficiles, il existe de nombreuses fonctionnalités spécifiques aux fournisseurs et OpenGL ne cesse de s'améliorer, ce qui signifie qu'il y a des changements à suivre. En bref, il a été assez difficile pour "quiconque" essayant de suivre OpenGL d'écrire une interface Java vers native qui englobe tout.

Entrez les gens de JOGL. Ils ont décidé de tirer parti des fichiers d'en-tête C et d'écrire du code qui ferait tout le travail JNI pour eux. Ils l'ont appelé GlueGen. GlueGen analyse les fichiers d'en-tête C puis crée comme par magie le code Java et JNI nécessaire pour se connecter à ces bibliothèques natives. Cela signifie que les mises à jour d'OpenGL peuvent être ajoutées rapidement à JOGL.

Bonjour le monde!

Je suis un fervent partisan de la tradition, alors nous allons bien sûr commencer par un "Hello World". Ce Hello World examinera notre installation et nous dira si tout ou partie est correctement installé. N'oubliez pas que l'installation de JOGL comprend deux parties. Il y a la bibliothèque Java dans un fichier jar et le code natif dans une autre bibliothèque.

Voici notre programme:

import net.java.games.jogl.*;

public class HelloWorld { public static void main (String args[]) { try { System.loadLibrary("jogl"); System.out.println( "Hello World! (The native libraries are installed.)" ); GLCapabilities caps = new GLCapabilities(); System.out.println( "Hello JOGL! (The jar appears to be available.)" ); } catch (Exception e) { System.out.println(e); } } }

Tout d'abord, ce programme teste pour voir si les bibliothèques natives et Java sont correctement installées. JOGL est installé correctement uniquement lorsque la jogl.jaret la bibliothèque native, nommée quelque chose comme libjogl.jnilibou jogl.dll, sont toutes deux installées. Si la bibliothèque native n'est pas accessible, ce programme lèvera une java.lang.UnsatisfiedLinkErrorexception. Si le JAR n'est pas installé dans le chemin de classe, le programme ne sera même pas compilé. Le compilateur javac dira quelque chose de similaire à "le paquet net.java.games.jogln'existe pas". Lorsque cette classe se compile et s'exécute sans exception, vous êtes prêt à continuer à apprendre JOGL.

Un bon modèle

Passons à quelques classes que vous pourriez trouver utiles à utiliser comme modèle tout en jouant avec JOGL. Je les ai utilisés comme modèles plus d'une fois. N'hésitez pas à les utiliser comme vous le souhaitez.

This template is made up of two classes. The first is SimpleJoglApp shown below, and the second is SimpleGLEventListener shown after a brief description. You will need to type both in to compile the template. The main app:

import java.awt.*; import java.awt.event.*; import javax.swing.*; import net.java.games.jogl.*;

/** * This is a basic JOGL app. Feel free to * reuse this code or modify it. */ public class SimpleJoglApp extends JFrame { public static void main(String[] args) { final SimpleJoglApp app = new SimpleJoglApp();

// show what we've done SwingUtilities.invokeLater ( new Runnable() { public void run() { app.setVisible(true); } } ); }

public SimpleJoglApp() { //set the JFrame title super("Simple JOGL Application");

//kill the process when the JFrame is closed setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//only three JOGL lines of code ... and here they are GLCapabilities glcaps = new GLCapabilities(); GLCanvas glcanvas = GLDrawableFactory.getFactory().createGLCanvas(glcaps); glcanvas.addGLEventListener(new SimpleGLEventListener());

//add the GLCanvas just like we would any Component getContentPane().add(glcanvas, BorderLayout.CENTER); setSize(500, 300);

//center the JFrame on the screen centerWindow(this); }

public void centerWindow(Component frame) { Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Dimension frameSize = frame.getSize();

if (frameSize.width > screenSize.width ) frameSize.width = screenSize.width; if (frameSize.height > screenSize.height) frameSize.height = screenSize.height;

frame.setLocation ( (screenSize.width - frameSize.width ) >> 1, (screenSize.height - frameSize.height) >> 1 ); } }

That is it. Let's focus on the three lines of JOGL-specific code in this first class. To start:

GLCapabilities glcaps = new GLCapabilities();

This determines what OpenGL/graphics features are available to our JOGL libraries and the JVM.

Next:

GLCanvas glcanvas = GLDrawableFactory.getFactory().createGLCanvas(glcaps);

We cannot create GLCanvases or GLJPanels. We need to have them created for us by a GLDrawableFactory. So, we retrieve a GLDrawableFactory using GLDrawableFactory's static method, getFactory().

Now we have a GLDrawableFactory, so we use its createGLCanvas() method to create a GLCanvas to draw on. We could have used the createGLJPanel() method instead if we had wanted a Swing component instead of an AWT component.

Notice that we passed in the GLCapabilities object we created earlier. This allows the GLDrawable we're having created to be created properly.

Finally, we are ready to add a GLEventListener to the GLCanvas:

glcanvas.addGLEventListener(new SimpleGLEventListener());

Our implementation of GLEventListener is SimpleGLEventListener. It will take care of any drawing that needs to be done when it receives a call from the GLDrawable and our one and only GLCanvas. As you will see, I decided not to draw anything in this program. Now for the GLEventListener:

import java.awt.*; import java.awt.event.*; import net.java.games.jogl.*;

/** * For our purposes only two of the * GLEventListeners matter. Those would * be init() and display(). */ public class SimpleGLEventListener implements GLEventListener {

/** * Take care of initialization here. */ public void init(GLDrawable drawable) {

}

/** * Take care of drawing here. */ public void display(GLDrawable drawable) {

}

/** * Called when the GLDrawable (GLCanvas * or GLJPanel) has changed in size. We * won't need this, but you may eventually * need it -- just not yet. */ public void reshape( GLDrawable drawable, int x, int y, int width, int height ) {}

/** * If the display depth is changed while the * program is running this method is called. * Nowadays this doesn't happen much, unless * a programmer has his program do it. */ public void displayChanged( GLDrawable drawable, boolean modeChanged, boolean deviceChanged ) {} }

That is the heart of the JOGL work we will do. Notice the UML graphic below. SimpleJoglApp is a JFrame. It contains our GLDrawable, which is actually a GLCanvas, but don't tell him that. We add the SimpleGLEventListener, which implements GLEventListener to the GLCanvas so the GLCanvas knows we care if he wants any OpenGL work done. GLDrawables can talk your ear off, so you'll want to make sure your GLEventListener is optimized…for real.

This app may look a bit scrambled depending on your OS. This is to be expected because you are just displaying random bits of memory at this point. So congratulations on your new-found graphics talents.

You're ready for the real thing

After you've familiarized yourself with the previous example, make a pretty picture.

Voici votre prochaine application. Assurez-vous de saisir ceci et tous les exemples. Les déboguer et les manipuler vous permettront de vous apprendre rapidement comment ils fonctionnent.