Hallo JOGL

Seit einigen Jahren hatte ein Programmierer, der ein grafikintensives Programm erstellen wollte, das an Benutzer verschiedener Betriebssysteme verkauft werden konnte, eine Wahl: OpenGL. Der GL steht für Grafikbibliothek. OpenGL ist eine eingetragene Marke von SGI. OpenGL manifestiert sich als plattformübergreifende C-Programmier-API. In Wirklichkeit handelt es sich jedoch um eine hardwareunabhängige Spezifikation für eine Programmierschnittstelle.

OpenGL dient zum Erstellen von Grafiken. Es ist schnell. Meistens ist es hardwarebeschleunigt. Es scheint, dass OpenGL alles visuell tun kann, was Sie möchten.

Leider ist OpenGL für C geschrieben. Seien wir ehrlich, C ist nicht die beliebteste Sprache für die Programmierung komplexer Anwendungen. Einer der größten Nachteile von OpenGL ist, dass Sie ohne ein Fenster zum Einfügen Ihrer Grafiken nichts tun können, aber OpenGL bietet Ihnen keine Möglichkeit, Fenster zu erstellen. Dies macht OpenGL für Anfänger schwer zu lernen.

Glücklicherweise wurde GLUT (OpenGL Utility Toolkit) eingeführt und der Umgang mit Fenstern, Schaltflächen und Ereignissen, die von Benutzern generiert wurden, vereinfacht. Dennoch kann das Erlernen von OpenGL in C oder sogar C ++ für neue Programmierer oder Programmierer, die echte objektorientierte Programmierung verwenden möchten, schmerzhaft sein.

Dann kam JOGL

Java ist möglicherweise die beliebteste echte objektorientierte Programmiersprache. Es gab viele Versuche, OpenGL mit Java zu heiraten, aber der erste, der alle dazu brachte, aufzustehen und auf sich aufmerksam zu machen, war Java Bindings for OpenGL oder JOGL. Der Grund dafür ist, dass diese Bemühungen von Sun Microsystems (den Entwicklern von Java) und SGI (den Entwicklern von OpenGL) unterstützt werden.

Heutzutage wird JOGL von der Spieltechnologiegruppe bei Sun entwickelt. Es begann als Jungle, entwickelt von Ken Russel und Chris Kline. Russell ist ein Sun-Mitarbeiter, der an der virtuellen HotSpot-Maschine arbeitet und über langjährige 3D-Erfahrung verfügt. Kline arbeitet für Irrational Games und ist auch sehr erfahren mit 3D-Grafiken.

Ich bin persönlich dankbar für ihre Bemühungen und die Bemühungen aller, die an JOGL arbeiten. Es gab mehrere Versuche, den Zugriff auf OpenGL über eine benutzerfreundliche Java-API bereitzustellen - darunter Java 3D, OpenGL für Java-Technologie (gl4java) und Lightweight Java Game Library (LWJGL). JOGL ist das erste, mit dem ich mich wohl gefühlt habe.

JOGL ist der von Sun unterstützte Satz von Java-Klassenbindungen für OpenGL. Beeindruckend! Das war ein Schluck.

OpenGL wird zur Anzeige von 3D-Modellen verwendet. Es ist leistungsstark, schnell und vielleicht das Beste, was Java seit der Einführung von Swing passieren kann. Mit OpenGL über JOGL können Sie coole Spiele oder Modellsituationen erstellen, deren Erstellung zu teuer sein kann. Es wurden dicke Bücher geschrieben, die OpenGL beschreiben. Sie werden nützlich sein, sobald Sie sich auskennen, aber noch nicht. Sie müssen lernen, wie dies alles auf die Java-APIs zutrifft, die OpenGL für Sie verfügbar machen. Sie benötigen auch einige grundlegende Einführungen in net.java.games.jogl.*und vielleicht einige Auffrischungen in Mathematik.

Hast du JOGL?

Wenn Sie JOGL verwenden möchten, müssen Sie jogl.jarden zugehörigen nativen Code abrufen. Ich träume von dem Tag, an dem es bei der Java-Installation Standard ist, aber im Moment ist das nur ein gut platzierter Traum.

Der erste Trick besteht darin, die Binärdateien für Ihr Betriebssystem zu finden und zu extrahieren. Ich habe sie unter //games-binaries.dev.java.net/build/index.html gefunden. Jedes Betriebssystem ist anders, aber die Installation besteht aus zwei Teilen. Das jogl.jarmuss im Systemklassenpfad platziert werden, und die Binärbibliothek muss überall dort platziert werden, wo sich Bibliotheken in Ihrem Betriebssystem befinden. Wenn Sie Glück haben, haben Sie einen Installer, der dies für Sie erledigt. Wenn Sie kein Installationsprogramm haben und nicht wissen, wo Sie nach Informationen zum Platzieren von allem auf Ihrem Computer suchen sollen, können Sie mit den Links beginnen, die ich in Ressourcen bereitgestellt habe. Unser erstes Codebeispiel wurde speziell geschrieben, um zu testen, ob Sie alles korrekt installiert haben, sodass Sie sich bis dahin nicht um das Testen Ihrer Installation kümmern müssen.

Javadocs für JOGL

Die Javadocs können an derselben Stelle wie die binäre Verteilung von JOGL erhalten werden. Die Javadocs werden ähnlich benannt jogl-1.0-usrdoc.tar.

Wenn Sie das net.java.games.joglPaket durchsuchen , werden Sie schnell feststellen, dass einige der Klassen sehr groß sind. Der GL ist ein perfektes Beispiel dafür. Lassen Sie sich davon nicht abschrecken. Sie werden schnell feststellen, dass Sie selbst mit nur wenig JOGL-Wissen ziemlich anspruchsvolle Arbeiten ausführen können. Die Klassen, die Sie jetzt vielleicht ansehen möchten, sind:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Dies wird Ihre grundlegende Schnittstelle in die Welt der Grafiken sein. Wenn Sie sich erinnern, habe ich bereits erwähnt, dass einer der größten Nachteile für Anfänger, die OpenGL lernen, das Fehlen eines Fenstersystemstandards ist. GLUT hilft in dieser Hinsicht bei unseren C-Kollegen sehr, aber wir haben Swing und das AWT (Abstract Window Toolkit). Es ist sehr wahrscheinlich, dass Sie bereits AWT oder Swing verwendet haben, sodass Sie nicht das Gefühl haben, alles von Grund auf neu zu lernen. Das ist eine gute Sache. Nach einer sehr kurzen Einführung in das Anzeigen einer Komponente für JOGL auf dem Bildschirm benötigen wir nicht viel Arbeit, damit Sie ziemlich coole und angesagte Apps ausführen können!

GlueGen ... fast so cool wie JOGL?

As you should be aware, OpenGL is written for C programmers. This means that for Java to take advantage of it, there has to be some native interface. This means JNI (Java Native Interface), which isn't fun or pretty, must be written to make this connection. OpenGL is pretty big. Writing all those connections takes time. To make things just a little more difficult, there are plenty of vendor-specific features and OpenGL keeps improving, which means there are changes to keep up with. In short, it has been pretty hard for the "anyone" trying to keep up with OpenGL to write a Java to native interface that is all encompassing.

Enter the JOGL folks. They decided to take advantage of the C header files and write some code that would do all the JNI work for them. They called it GlueGen. GlueGen parses the C header files and then magically creates the needed Java and JNI code necessary to connect to those native libraries. This means that updates to OpenGL can be added quickly to JOGL.

Hello World!

I'm a firm believer in tradition, so of course we will start with a "Hello World." This Hello World will examine our installation and tell us whether all or part is installed correctly. Remember there are two parts to the JOGL installation. There is the Java library in a jar file and the native code in another library.

Here is our program:

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); } } }

First, this program tests to see if the native and Java libraries are installed correctly. JOGL is installed properly only when the jogl.jar and the native library, named something like libjogl.jnilib or jogl.dll, are both installed. If the native library is not accessible, this program will throw a java.lang.UnsatisfiedLinkError exception. If the JAR is not installed in the classpath, then the program will not even compile. The javac compiler will say something similar to "package net.java.games.jogl does not exist." When this class compiles and runs without exceptions, you are ready to continue learning JOGL.

A good template

Let's move on to a couple of classes that you may find useful to use as a template while messing around with JOGL. I've used them as templates more than once. Feel free to use them however you like.

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.

Hier ist deine nächste App. Stellen Sie sicher, dass Sie dies und alle Beispiele eingeben. Das Debuggen und Herumspielen mit ihnen dient dazu, Ihnen schnell beizubringen, wie sie funktionieren.