Здравей JOGL

От няколко години програмист, който искаше да създаде графично интензивна програма, която да може да се продава на потребители на различни операционни системи, имаше един избор - OpenGL. GL означава графична библиотека. OpenGL е регистрирана търговска марка на SGI. OpenGL се проявява като API за програмиране на различни платформи. В действителност обаче това е хардуерно независима спецификация за интерфейс за програмиране.

OpenGL е за създаване на графики. Това е бързо. В повечето случаи това е хардуерно ускорено. Изглежда OpenGL може да направи всичко визуално, което бихте искали да направите.

За съжаление OpenGL е написан за C. Нека си признаем, C не е най-популярният език за програмиране на сложни приложения. Един от най-големите недостатъци на OpenGL е, че не можете да го направите без прозорец, в който да поставите графиката си, но OpenGL не предоставя средства за създаване на прозорци. Това прави OpenGL трудно за научаване за начинаещи.

За щастие беше представен GLUT (OpenGL Utility Toolkit), който улесни работата с прозорци, бутони и събития, генерирани от потребители. И все пак, изучаването на OpenGL в C или дори C ++ може да бъде болезнено за нови програмисти или програмисти, които искат да използват истинско обектно-ориентирано програмиране.

След това дойде JOGL

Java е може би най-популярният истински обектно-ориентиран език за програмиране. Имаше много опити за сключване на брак с OpenGL с Java, но първият, който накара всички да се изправят и забележат, беше Java Bindings за OpenGL или JOGL. Причината за това е, че това усилие се подкрепя от Sun Microsystems (създателите на Java) и SGI (създателите на OpenGL).

В днешно време JOGL е разработен от групата за технологични игри в Sun. Той започна живота си като Jungle, разработен от Ken Russel и Chris Kline. Ръсел е служител на Sun, работещ върху виртуалната машина HotSpot с дългогодишен 3D опит. Kline работи за ирационални игри и също е много опитен с 3D графики.

Лично съм благодарен за техните усилия и усилията на всички, които работят по JOGL. Има няколко опита за предоставяне на достъп до OpenGL чрез приятелски Java API - сред тях са Java 3D, OpenGL за Java Technology (gl4java) и библиотека за леки Java игри (LWJGL). JOGL е първият, с който се чувствах комфортно.

JOGL е поддържаният от Sun набор от свързвания на Java клас за OpenGL. Еха! Това беше залък.

OpenGL се използва за показване на 3D модели. Той е мощен, бърз и може би най-великото нещо, което се случва на Java, откакто Swing беше представен. Използвайки OpenGL чрез JOGL, ще можете да правите страхотни игри или да моделирате ситуации, които може да са твърде скъпи за създаване. Написани са дебели томове, описващи OpenGL. Те ще бъдат полезни, след като се ориентирате, но все още не. Трябва да научите как всичко това се отнася за Java API, които излагат OpenGL за вас. Също така се нуждаете от някои основни въведения net.java.games.jogl.*и може би някои опреснители по математика.

Имате JOGL?

Ако искате да използвате JOGL, ще трябва да получите jogl.jarи придружаващия го роден код. Мечтая за деня, когато това е стандартно за инсталацията на Java, но засега това е просто добре поставена мечта.

Първият трик е намирането на двоичните файлове за вашата операционна система и тяхното извличане. Намерих ги на //games-binaries.dev.java.net/build/index.html. Всяка операционна система е различна, но има две части за инсталиране. Трябва jogl.jarда се постави в системния път на класа, а двоичната библиотека трябва да се постави навсякъде, където библиотеките отиват във вашата операционна система. Ако имате късмет, ще имате инсталатор, който да го направи вместо вас. Ако нямате инсталатор и не знаете къде да потърсите информация относно поставянето на всичко на вашия компютър, можете да започнете с връзките, които съм предоставил в Ресурси. Първият ни пример за код ще бъде написан специално, за да тествате дали сте инсталирали всичко правилно, така че не е нужно да наблягате на тестването на вашата инсталация дотогава.

Javadocs за JOGL

Javadocs може да се получи на същото място като бинарното разпределение на JOGL. Javadocs ще бъде наречен нещо подобно на jogl-1.0-usrdoc.tar.

Ако прегледате net.java.games.joglпакета, бързо ще забележите, че някои от класовете са огромни. GL е идеален пример за това. Не се стряскайте от това. Бързо ще разберете, че сте в състояние да свършите доста сложна работа, дори само с малко количество знания по JOGL. Класовете, които може да искате да погледнете сега, са:

  • GLDrawable
  • GLCanvas
  • GLJPanel
  • GLCapabilities
  • GLDrawableFactory

Това ще бъде вашият основен интерфейс в света на графиката. Ако си спомняте, по-рано споменах, че един от най-големите недостатъци за начинаещи, които учат OpenGL, е липсата на стандарт за прозоречна система. GLUT помага много в това отношение за нашите колеги от C, но ние имаме Swing и AWT (Abstract Window Toolkit). Много е вероятно вече да сте използвали AWT или Swing, така че няма да се чувствате така, сякаш научавате всичко от нулата. Това е хубаво нещо. След много кратко въведение за извеждането на компонент за JOGL на екрана, няма да имаме нужда от много работа, за да стартирате доста готини и модерни приложения!

GlueGen ... почти толкова готин като JOGL?

Както трябва да знаете, OpenGL е написан за програмисти на C. Това означава, че за да се възползва Java от него, трябва да има някакъв роден интерфейс. Това означава, че JNI (Java Native Interface), което не е забавно или красиво, трябва да бъде написано, за да се осъществи тази връзка. OpenGL е доста голям. Писането на всички тези връзки отнема време. За да направим нещата малко по-трудни, има много специфични за доставчика функции и OpenGL продължава да се подобрява, което означава, че има промени, които трябва да бъдат в крак. Накратко, за „никого“, който се опитва да се справи с OpenGL, е било доста трудно да напише Java в родния интерфейс, който е изчерпателен.

Въведете хората от JOGL. Те решиха да се възползват от заглавните файлове на C и да напишат код, който да свърши цялата работа на JNI за тях. Нарекоха го GlueGen. GlueGen анализира заглавните файлове на C и след това магически създава необходимия Java и JNI код, необходим за свързване с тези родни библиотеки. Това означава, че актуализации на OpenGL могат да се добавят бързо към JOGL.

Здравей свят!

Твърдо вярвам в традицията, така че, разбира се, ще започнем с „Hello World“. Този Hello World ще разгледа нашата инсталация и ще ни каже дали цялата или част е инсталирана правилно. Не забравяйте, че има две части в инсталацията на JOGL. Има библиотека Java в jar файл, а родният код в друга библиотека.

Ето нашата програма:

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.

Ето вашето следващо приложение. Уверете се, че сте въвели това и всички примери. Отстраняването на грешки и бъркотията с тях ще ви помогне бързо да ви научи как работят.