Hola JOGL

Desde hace algunos años, un programador que quería crear un programa con uso intensivo de gráficos que pudiera venderse a usuarios de diferentes sistemas operativos tenía una opción: OpenGL. GL significa biblioteca de gráficos. OpenGL es una marca registrada de SGI. OpenGL se manifiesta como una API de programación C multiplataforma. En realidad, sin embargo, es una especificación independiente del hardware para una interfaz de programación.

OpenGL es para hacer gráficos. Es rápido. La mayoría de las veces, se acelera por hardware. Parece que OpenGL puede hacer cualquier cosa visualmente que le gustaría hacer.

Desafortunadamente, OpenGL está escrito para C. Seamos realistas, C no es el lenguaje más popular para programar aplicaciones complejas. Uno de los mayores inconvenientes de OpenGL es que no puede hacer nada sin una ventana para colocar sus gráficos, pero OpenGL no le proporciona un medio para crear ventanas. Esto hace que OpenGL sea difícil de aprender para principiantes.

Afortunadamente, GLUT (OpenGL Utility Toolkit) se introdujo y facilitó el manejo de ventanas, botones y eventos generados por los usuarios. Aún así, aprender OpenGL en C o incluso C ++ puede resultar doloroso para los nuevos programadores o programadores que quieran utilizar una verdadera programación orientada a objetos.

Luego vino JOGL

Java es posiblemente el verdadero lenguaje de programación orientado a objetos más popular. Ha habido muchos intentos de unir OpenGL con Java, pero el primero que hizo que todos se pusieran de pie y se dieran cuenta fue Java Bindings for OpenGL, o JOGL. La razón de esto es que este esfuerzo cuenta con el apoyo de Sun Microsystems (los creadores de Java) y SGI (los creadores de OpenGL).

Hoy en día, JOGL es desarrollado por el grupo de tecnología de juegos de Sun. Comenzó su vida como Jungle desarrollado por Ken Russel y Chris Kline. Russell es un empleado de Sun que trabaja en la máquina virtual HotSpot con muchos años de experiencia en 3D. Kline trabaja para Irrational Games y también tiene mucha experiencia con gráficos 3D.

Personalmente estoy agradecido por sus esfuerzos y los esfuerzos de todos aquellos que están trabajando en JOGL. Ha habido varios intentos de proporcionar acceso a OpenGL a través de una API Java amigable; entre ellos se encuentran Java 3D, OpenGL para tecnología Java (gl4java) y Lightweight Java Game Library (LWJGL). JOGL es el primero con el que me sentí cómodo.

JOGL es el conjunto de enlaces de clases Java compatibles con Sun para OpenGL. ¡Guauu! Eso fue un bocado.

OpenGL se utiliza para mostrar modelos 3D. Es poderoso, rápido y quizás lo mejor que le ha pasado a Java desde que se introdujo Swing. Usando OpenGL a través de JOGL, podrá crear juegos geniales o situaciones modelo que podrían ser demasiado caras de crear. Se han escrito tomos gruesos que describen OpenGL. Serán útiles una vez que conozca el camino, pero todavía no. Debe aprender cómo se aplica todo esto a las API de Java que le exponen OpenGL. También necesita algunas introducciones básicas net.java.games.jogl.*y quizás algunos repaso en matemáticas.

¿Tienes JOGL?

Si desea utilizar JOGL, deberá obtener el jogl.jarcódigo nativo que lo acompaña. Sueño con el día en que sea estándar con la instalación de Java, pero por ahora es solo un sueño bien ubicado.

El primer truco consiste en encontrar los binarios de su sistema operativo y extraerlos. Los encontré en //games-binaries.dev.java.net/build/index.html. Cada sistema operativo es diferente, pero la instalación consta de dos partes. El jogl.jardebe colocarse en la ruta de clases del sistema y la biblioteca binaria debe colocarse dondequiera que vayan las bibliotecas en su sistema operativo. Si tiene suerte, tendrá un instalador que lo hará por usted. Si no tiene un instalador y no sabe dónde buscar información sobre cómo colocar todo en su computadora, puede comenzar con los enlaces que proporcioné en Recursos. Nuestro primer ejemplo de código se escribirá específicamente para probar si ha instalado todo correctamente, por lo que no necesita preocuparse por probar su instalación hasta entonces.

Javadocs para JOGL

Los Javadocs se pueden obtener en la misma ubicación que la distribución binaria de JOGL. Los Javadocs recibirán un nombre similar a jogl-1.0-usrdoc.tar.

Si examina el net.java.games.joglpaquete, notará rápidamente que algunas de las clases son enormes. GL es un ejemplo perfecto de esto. No se deje intimidar por esto. Descubrirá rápidamente que puede hacer un trabajo bastante sofisticado incluso con una pequeña cantidad de conocimientos de JOGL. Las clases a las que quizás desee echar un vistazo ahora son:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Ésta será su interfaz básica en el mundo de los gráficos. Si recuerdas, antes mencioné que uno de los mayores inconvenientes para los principiantes que aprenden OpenGL es la falta de un estándar de sistema de ventanas. GLUT ayuda mucho en ese sentido para nuestros homólogos de C, pero tenemos Swing y AWT (Abstract Window Toolkit). Es muy probable que ya hayas usado AWT o Swing, por lo que no sentirás que estás aprendiendo todo desde cero. Ésto es una cosa buena. Después de una breve introducción para obtener un componente para JOGL en la pantalla, ¡no necesitaremos mucho trabajo para que ejecute aplicaciones geniales y modernas!

GlueGen ... ¿casi tan genial como JOGL?

Como debe saber, OpenGL está escrito para programadores de C. Esto significa que para que Java lo aproveche, tiene que haber alguna interfaz nativa. Esto significa que JNI (Interfaz nativa de Java), que no es divertida ni bonita, debe escribirse para hacer esta conexión. OpenGL es bastante grande. Escribir todas esas conexiones lleva tiempo. Para hacer las cosas un poco más difíciles, hay muchas características específicas de los proveedores y OpenGL sigue mejorando, lo que significa que hay cambios que debe seguir. En resumen, ha sido bastante difícil para "cualquiera" que intente mantenerse al día con OpenGL escribir una interfaz Java a nativa que lo abarque todo.

Entra la gente de JOGL. Decidieron aprovechar los archivos de encabezado C y escribir un código que haría todo el trabajo de JNI por ellos. Lo llamaron GlueGen. GlueGen analiza los archivos de encabezado C y luego crea mágicamente el código Java y JNI necesario para conectarse a esas bibliotecas nativas. Esto significa que las actualizaciones de OpenGL se pueden agregar rápidamente a JOGL.

Hola Mundo!

Soy un firme creyente en la tradición, así que, por supuesto, comenzaremos con un "Hola mundo". Este Hello World examinará nuestra instalación y nos dirá si todo o parte está instalado correctamente. Recuerde que hay dos partes en la instalación de JOGL. Existe la biblioteca de Java en un archivo jar y el código nativo en otra biblioteca.

Aquí está nuestro programa:

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

Primero, este programa prueba para ver si las bibliotecas nativas y Java están instaladas correctamente. JOGL se instala correctamente solo cuando jogl.jary la biblioteca nativa, denominada algo como libjogl.jnilibo jogl.dll, están instaladas. Si no se puede acceder a la biblioteca nativa, este programa lanzará una java.lang.UnsatisfiedLinkErrorexcepción. Si el JAR no está instalado en la ruta de clases, el programa ni siquiera se compilará. El compilador javac dirá algo similar a "el paquete net.java.games.joglno existe". Cuando esta clase se compile y se ejecute sin excepciones, estará listo para continuar aprendiendo JOGL.

Una buena plantilla

Pasemos a un par de clases que puede resultarle útil para usar como plantilla mientras juega con JOGL. Los he usado como plantillas más de una vez. Siéntete libre de usarlos como quieras.

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.

Aquí está su próxima aplicación. Asegúrate de escribir esto y todos los ejemplos. Depurarlos y jugar con ellos te enseñará rápidamente cómo funcionan.