Ciao JOGL

Da alcuni anni, un programmatore che desiderava creare un programma ad alta intensità di grafica che potesse essere venduto a utenti di diversi sistemi operativi aveva una scelta: OpenGL. Il GL sta per libreria grafica. OpenGL è un marchio registrato di SGI. OpenGL si manifesta come un'API di programmazione C multipiattaforma. In realtà, però, è una specifica indipendente dall'hardware per un'interfaccia di programmazione.

OpenGL serve per creare grafica. È veloce. Il più delle volte è accelerato dall'hardware. Sembra che OpenGL possa fare visivamente qualsiasi cosa tu voglia fare.

Sfortunatamente, OpenGL è scritto per C. Ammettiamolo, il C non è il linguaggio più popolare per la programmazione di applicazioni complesse. Uno dei maggiori svantaggi di OpenGL è che non puoi fargli fare nulla senza una finestra in cui inserire la tua grafica, ma OpenGL non fornisce un mezzo per creare finestre. Questo rende OpenGL difficile da imparare per i principianti.

Fortunatamente, è stato introdotto GLUT (OpenGL Utility Toolkit) e ha reso più semplice la gestione di finestre, pulsanti ed eventi generati dagli utenti. Tuttavia, l'apprendimento di OpenGL in C o anche C ++ può essere doloroso per i nuovi programmatori o programmatori che desiderano utilizzare una vera programmazione orientata agli oggetti.

Poi è arrivato JOGL

Java è forse il vero linguaggio di programmazione orientato agli oggetti più popolare. Ci sono stati molti tentativi di sposare OpenGL con Java, ma il primo che ha fatto alzare la testa a tutti è stato Java Bindings for OpenGL o JOGL. La ragione di ciò è che questo sforzo è supportato da Sun Microsystems (i creatori di Java) e SGI (i creatori di OpenGL).

Al giorno d'oggi, JOGL è sviluppato dal gruppo di tecnologia dei giochi di Sun. È iniziato come Jungle sviluppato da Ken Russel e Chris Kline. Russell è un dipendente Sun che lavora sulla macchina virtuale HotSpot con molti anni di esperienza 3D. Kline lavora per Irrational Games ed è anche molto esperto con la grafica 3D.

Sono personalmente grato per i loro sforzi e gli sforzi di tutti coloro che stanno lavorando su JOGL. Ci sono stati diversi tentativi di fornire accesso a OpenGL tramite un'amichevole API Java, tra cui Java 3D, OpenGL per Java Technology (gl4java) e Lightweight Java Game Library (LWJGL). JOGL è il primo con cui mi sono sentito a mio agio.

JOGL è il set supportato da Sun di associazioni di classi Java per OpenGL. Wow! Quello era un boccone.

OpenGL viene utilizzato per visualizzare i modelli 3D. È potente, veloce e forse la cosa più bella che sia successa a Java da quando è stato introdotto Swing. Usando OpenGL tramite JOGL, sarai in grado di creare fantastici giochi o situazioni modello che potrebbero essere troppo costose da creare. Sono stati scritti tomi spessi che descrivono OpenGL. Saranno utili una volta che saprai come muoverti, ma non ancora. Devi imparare come tutto questo si applica alle API Java che ti espongono OpenGL. Hai anche bisogno di alcune introduzioni di base net.java.games.jogl.*e forse di qualche aggiornamento sulla matematica.

Hai JOGL?

Se vuoi usare JOGL, dovrai ottenere jogl.jare il relativo codice nativo. Sogno il giorno in cui è standard con l'installazione di Java, ma per ora è solo un sogno ben posizionato.

Il primo trucco è trovare i binari per il tuo sistema operativo ed estrarli. Li ho trovati su //games-binaries.dev.java.net/build/index.html. Ogni sistema operativo è diverso, ma l'installazione prevede due parti. Il jogl.jardeve essere posizionato nel classpath del sistema e la libreria binaria deve essere posizionata ovunque vadano le librerie nel sistema operativo. Se sei fortunato, avrai un programma di installazione che lo farà per te. Se non hai un programma di installazione e non sai dove cercare informazioni su come posizionare tutto sul tuo computer, puoi iniziare con i collegamenti che ho fornito in Risorse. Il nostro primo esempio di codice verrà scritto specificamente per verificare se hai installato tutto correttamente, quindi non devi preoccuparti di testare la tua installazione fino ad allora.

Javadocs per JOGL

I Javadoc possono essere ottenuti nella stessa posizione della distribuzione binaria di JOGL. I Javadoc avranno un nome simile a jogl-1.0-usrdoc.tar.

Se sfogli il net.java.games.joglpacchetto, noterai subito che alcune delle classi sono enormi. GL ne è un perfetto esempio. Non lasciarti scoraggiare da questo. Scoprirai rapidamente che sei in grado di fare un lavoro piuttosto sofisticato anche con solo una piccola quantità di conoscenza JOGL. Le classi che potresti voler dare un'occhiata ora sono:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Questi saranno la tua interfaccia di base nel mondo della grafica. Se ricordi, prima ho detto che uno dei maggiori svantaggi per i principianti che imparano OpenGL è la mancanza di uno standard di sistema a finestre. GLUT aiuta molto in questo senso per le nostre controparti C, ma abbiamo Swing e AWT (Abstract Window Toolkit). È molto probabile che tu abbia già utilizzato AWT o Swing, quindi non ti sentirai come se stessi imparando tutto da zero. Questa è una buona cosa. Dopo una breve introduzione su come ottenere un componente per JOGL sullo schermo, non avremo bisogno di molto lavoro per farti eseguire app fantastiche e alla moda!

GlueGen ... fico quasi quanto JOGL?

Come dovresti sapere, OpenGL è scritto per i programmatori C. Ciò significa che affinché Java possa trarne vantaggio, deve esserci un'interfaccia nativa. Ciò significa che JNI (Java Native Interface), che non è divertente o carino, deve essere scritto per creare questa connessione. OpenGL è piuttosto grande. Scrivere tutte queste connessioni richiede tempo. Per rendere le cose solo un po 'più difficili, ci sono molte funzionalità specifiche del fornitore e OpenGL continua a migliorare, il che significa che ci sono cambiamenti con cui stare al passo. In breve, è stato piuttosto difficile per "chiunque" cercasse di stare al passo con OpenGL scrivere un'interfaccia da Java a nativa che comprendesse tutto.

Entrano i ragazzi di JOGL. Hanno deciso di sfruttare i file di intestazione C e scrivere del codice che avrebbe fatto tutto il lavoro JNI per loro. Lo chiamavano GlueGen. GlueGen analizza i file di intestazione C e quindi crea magicamente il codice Java e JNI necessario per connettersi a quelle librerie native. Ciò significa che gli aggiornamenti a OpenGL possono essere aggiunti rapidamente a JOGL.

Ciao mondo!

Credo fermamente nella tradizione, quindi ovviamente inizieremo con un "Hello World". Questo Hello World esaminerà la nostra installazione e ci dirà se tutto o parte è installato correttamente. Ricorda che ci sono due parti nell'installazione di JOGL. C'è la libreria Java in un file jar e il codice nativo in un'altra libreria.

Ecco il nostro programma:

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

Innanzitutto, questo programma verifica se le librerie native e Java sono installate correttamente. JOGL viene installato correttamente solo quando sono installate sia jogl.jarla libreria nativa, denominata qualcosa come libjogl.jnilibo jogl.dll. Se la libreria nativa non è accessibile, questo programma genererà java.lang.UnsatisfiedLinkErrorun'eccezione. Se il JAR non è installato nel classpath, il programma non verrà nemmeno compilato. Il compilatore javac dirà qualcosa di simile a "il pacchetto net.java.games.joglnon esiste". Quando questa classe viene compilata ed eseguita senza eccezioni, sei pronto per continuare ad imparare JOGL.

Un buon modello

Passiamo a un paio di classi che potresti trovare utile da usare come modello mentre giochi con JOGL. Li ho usati come modelli più di una volta. Sentiti libero di usarli come preferisci.

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.

Ecco la tua prossima app. Assicurati di digitare questo e tutti gli esempi. Il debug e la manipolazione di essi serviranno per insegnarti rapidamente come funzionano.