• Beispiele und Erklärung der For- und ForEach Schleife
• Was ist mit For bzw. ForEach Loop gemeint?
• Was sind Java Laufvariablen und wie benutze ich sie?

Es werden erst die klassische For-Schleifen besprochen, bevor wir uns den moderneren For-Each Schleifen widmen.

Einführung und Definition

Die For-Schleife dient zum wiederholten ausführen eines Code-Blocks, wobei in jeder Iteration ein Schritt-Operation (zB. Hochzählen einer Variable) ausgeführt wird. Etwas weniger allgemein formuliert kann man sagen, dass sie zum Hoch- oder Runterzählen von Variablen verwendet werden kann. Der englische Begriffe der Schleife ist Loop, daher sind beide Begriffe synonym zu verstehen.

Das folgende Beispiel zählt die variable i von 5 bis 10 hoch:

int i; // die Laufvariable
for(i = 5; i <= 10; i = i + 1)
{
    // ausgeführter Code der die Laufvariable i verwenden kann, zB.
    System.out.println("i = "+i);
}

Wir sehen, dass in dem eingeklammerten Teil vor dem for etwas kryptisches stehts, was offensichtlich zum Verwenden der For-Schleife nötig ist. Dieser Teil läßt sich in drei Teile zerlegen, die jeweils mit einem Semmikolon getrennt sind:

for( Start ; Ende ; In-/Dekrementieren )

Im obigen Beispiel ist besteht der erste Teil (Start) aus dem setzen des Startwertes i = 5, also dass die Schleife bei 5 anfangen soll zu zählen. Häufig wird an dieser Stelle die Deklaration der Variable Der zweite Teil ist das Abbruchkriterium, nämlich i <= 10, was so viel heißt wie, dass i solange hochgezählt wird, bis i kleiner-gleich 10 ist. Der dritte Teil besagt was nach jeder Iteration passieren soll. In diesem Fall wird i um 1 erhöht. Eine häufige Notation die man an dieser Stelle sieht ist i++, was einfach nur eine Kurzform von i = i + 1 ist. Entsprechend ist übrigens i-- nur die Kurzform von i = i - 1. Ein weiteres Beispiel einer For-Schleife sie wie folgt aus:

for(int i = 10; i >= 5; i--)
{
    // ausgeführter Code der die Laufvariable i verwenden kann, zB.
    System.out.println("i = "+i);
}

Diese Schleife zählt ganz offensichtlich runter von 10 auf 5. In diesem Beispiel deklarieren wir i “inline” gleich mit in der Start-Definition der For-Schleife. Das spart uns eine Zeile vorher und es ist klar, dass i nur im Scope des Schleifen-Blocks liegt. Die Definition der Abbruchbedingung ist entsprechend abgewandelt zum ersten Beispiel. Der letzte Teil ist die dekrementierung von i.

Generell kann man also den eingeklammerten Teil der Schleifendefinition wie folgt lesen:

for( Starte bei i=10 und führe ; solange wie i>=5 gilt, ; den Code i-- aus )

Der Unterschied zu einer while-Schleife liegt also darin, dass im eingeklammerten Teil nicht nur die Abbruchbedingung festgelegt wird.

Schleifen können auch verschachtelt werden und so ist es nicht unüblich, dass man zum iterieren über Bilder oder Matrizen zwei For-Schleifen anwendet um mit zwei Laufvariablen einen 2-Dimensionalen Raum abzuwandern. Im folgenden Beispiel iterieren wir über das Google Logo und geben dabei Pixelweise die Farbe aus:

// lade Google Logo
BufferedImage image = ImageIO.read(new URL("http://www.google.de/images/srpr/logo3w.png"));
 
// x iteriert über die Breite des Bildes
for( int x = 0; x < image.getWidth(); x++ )
{
	// y iteriert über die Höhe des Bildes
	for( int y = 0; y < image.getHeight(); y++ )
	{
		// Gib Pixelfarben als Red, Green, Blue, alpha Komponenten auf der Konsole aus.
		int red   = image.getColorModel().getRed(image.getRGB(x, y));
		int green = image.getColorModel().getGreen(image.getRGB(x, y));
		int blue  = image.getColorModel().getBlue(image.getRGB(x, y));
		int alpha = image.getColorModel().getBlue(image.getRGB(x, y));
		System.out.println("Position ("+x+", "+y+"): ["+red+","+green+","+blue+","+alpha+"]");
	}
}

Natürlich können auch andere Werte als Zahlen als Laufvariabe und zur Iteration verwendet werden. So war es früher beispielsweise üblich, dass man Iterator-Objekte verwendete, die den aktuellen Status der Laufvariable wiederspiegelte und mit denen über unterschiedliche Datenstrukturen iteriert werden konnte. Im Prinzip speichern solche Iterator Objekte intern auch nur einen index ab, an welcher Stelle man sich aktuell in der Datenstruktur befindet. Ein Beispiel macht deutlich, was gemeint ist:

// dynamische Liste, so wie sie früher häufig verwendet wurde
Vector<String> vector = new Vector<String>();
 
// wir hängen ein paar Namen an die Liste an
vector.add("Peter");
vector.add("Klaus");
vector.add("Frieda");
vector.add("Manfred");
 
// Vector.iterator() gibt ein Objekt vom Type Iterator zurück
for( Iterator<String> it = vector.iterator(); it.hasNext(); )
{
	// it.next() holt den nächsten Wert aus dem Vector ab
	System.out.println(it.next());
}

Die Ausgabe ist erwartungsgemäß:

Peter
Klaus
Frieda
Manfred

Das interessant an diesem Beispiel ist, dass der letzte Part des in Klammern eingeschlossenen Teils leer bleibt. Das heißt es gibt keinen Iterationsteil. Dieser wird nämlich im For-Block selbst ausgeführt (it.next()).

So weit, so gut. Wollen wir nun zum nächsten Level vordringen.

ForEach Schleifen mit Beispielen

For-Each Schleifen funktionieren ganz ähnlich wie die gewöhnlichen For-Schleifen und sind quasi eine Weiterentwicklung. Im Gegensatz zu den normalen, verwenden ForEach Schleifen aber keine nach außen sichtbare Laufvariable oder Iterator-Objekt, sondern gibt in jeder Iteration immer direkt den Wert zurück. Das heißt aber auch, dass immer über eine entsprechende Datenstruktur iteriert werden muss die das ermöglicht. Schauen wir uns ein Beispiel an:

// definition eine Datenstruktur, hier ein Array mit 9 Werten
int[] array = new int[]{4, 8, 4, 2, 2, 1, 1, 5, 9};
 
// ForEach Schleife
for( int k: array )
{
	System.out.println("k = "+k);
}

Die Ausgabe ist

k = 4
k = 8
k = 4
k = 2
k = 2
k = 1
k = 1
k = 5
k = 9

Man sieht also, dass k nicht die Laufvariable hält, sondern den direkten Wert. ForEarch iteriert also über alle Elemente und ruf den Block auf. Daher kann auch der Name abgeleitet werden: For Each element, do this and that. Intern wird dennoch ein Iterator-Objekt gehalten in dem der State der Iteration festgehalten wird. Da man als Entwickler aber quasi nie am Index der Laufvariable interessiert ist, sondern eigentlich nur an den Werten, macht ForEach jede Menge Sinn. Ein paar Beispiele für weitere Verwendungen von ForEach-Schleifen:

Set<String> set = new HashSet<String>();
set.add("Peter");
set.add("Frieda");
set.add("Manfred");
 
for(String name: set) System.out.println(name);

In diesem Beispiel ist die Reihenfolge der Ausgabe nicht definiert, da es sich um eine Menge (Set) handelt und nicht um eine Liste oder andere order-preserving Datenstruktur. Das Gegenbeispiel dazu ist die Verwendung der ArrayList:

List<String> list = new ArrayList<String>();
list.add("Peter");
list.add("Frieda");
list.add("Manfred");
 
for(String name: list) System.out.println(name);

Und das wars Ich denke Ihr habt nun eine sehr gute Vorstellung davon wie diese Schleifen zu verwenden sind. Wenn ich etwas vergessen habe oder einen Fehler eingebaut habt, laßt es mich bitte wissen. Wenn Euch der Post gefallen, dann laßt auch gern einen Kommentar da.

• Java Arrays mit Beispielen
• Arrays in Java in mehreren Dimensionen

Arrays sind die niedrigsts (low-level) aber auch performanteste Datenstruktur in Java. Sie folgen sehr nah der Hardwarefunktionalität im Speicher des Rechners und sind somit eigentlich ein Überbleibsel aus der C/C++ Welt. Dennoch kann man Arrays in vielen Java-Anwendungen heutzutage noch finden.

Grundlagen

Das klassische Array ist eine Folge von Zahlen fester Länge. Diese Folge von Zahlen liegt als Block im Speicher. Schauen wir uns die folgenden zwei Arrays an.

// Definition eines Arrays das 24 Integerwerte halten kann. Zu beginn sind die alle 0.
int[] array = new int[24];
 
// Definition eines Arrays das 8 Integerwerte halten kann
// und dessen Werte vorinitialisiert werden
int[] test = new int[]{33,452,6,23,-5,32,5,-1};
 
// die eckigen Klammern können auch an die Variable geschrieben werden
int someOtherArray[] = new int[4];

Man definiert die Länge des Arrays, also wie viele Zahlen in das Array passen, wenn man das Array erstellt. Dabei wird der benötigte Speicher reserviert. Der Speicherblock kann nicht ohne weiteres wachsen, was wiederum die Länge des Array. Da die Zahlenarten in dem Array immer nur von einem Typ sind, ist zu beginn klar, wieviel Speicher reserviert werden muss. Für int-Arrays müssen zum Beispiel immer 4 bytes pro Wert vorgehalten werden. Das heißt ein int-Array das 24 Werte halten kann, benötigt 24*4=96 bytes. Streng genommen kommen da sogar nochmal 4 Bytes dazu, weil die Länges des Arrays im selben Speicherblock liegt (Backreferenzen für den Garbage Collector werden kurz mal ausgeblendet).

Die Zahl der Werte eines Arrays (oder eben die “Länge” eines Arrays), kann mit der Konstanten length abgefragt werden:

// Definition eines Arrays das 8 Integerwerte halten kann
// und dessen Werte vorinitialisiert werden
int[] test = new int[]{33,452,6,23,-5,32,5,-1};
System.out.println(test.length); // Ausgabe: 7

Um auf die Werte des Arrays zuzugreifen, muss lediglich der Speicherindex angegeben werden:

// Definition eines Arrays das 8 Integerwerte halten kann
// und dessen Werte vorinitialisiert werden
int[] test = new int[]{33,452,6,23,-5,32,5,-1};
 
System.out.println(test[5]); // Ausgabe 32
System.out.println(test[4]); // Ausgabe -5
 
// Um Werte zuzuweisen, wird genauso verfahren
test[5] = 78;
test[4] = 98;
 
System.out.println(test[5]); // Ausgabe 78
System.out.println(test[4]); // Ausgabe 98

Als wichtiger Sonderfall sein bemerkt, dass bei jedem Zugriff auf das Array geprüft wird, ob der Index noch innerhalb der Länge des Arrays liegt. Wenn der Index kleiner 0 oder größer als length ist, wird eine IndexOutOfBoundsException geworfen. Siehe zB:

int[] test = new int[]{33,452,6,23,-5,32,5,-1};
 
// schmeisst IndexOutOfBoundsExcpetion!!!
System.out.println(test[5423]);

Arrays aus verschiedenen Datentypen

In den Grundlagen haben wir auf Arrays aus natürlichen Zahlen gearbeitet. Prinzipiell sind natürlich auch andere Datentypen möglich. Schauen wir uns als erstes Beispiele mit primitiven Datentypen an.

int[] intArray = new int[]{33,452,6,23,-5,32,5,-1};
float[] floatArray = new float[3];
double[] doubleArray = new double[521];

Es können auch Arrays aus Objekten gebaut werden. Dabei sei zu beachten, dass beim erstellen des Arrays nicht die Objekte selbst erstellt werden, sondern nur die Pointer auf mögliche Objektinstanzen.

// erstelle 10 Pointer auf Object. Die Pointer sind
// erstmal alle NullPointer.
Object[] objectArray = new Object[10];
 
// wir instatitieren ein neues Objekt mit "new" und lassen den Pointer an 
// Index 0 und 3 auf das neue Objekt zeigen.
objectArray[0] = new Object();
objectArray[3] = new Object();
 
// es wird die toString() Methode des gerade instatitierten 
// Objektes ausgegeben
System.out.println(objectArray[0]);
 
// NullPointerException, weil an Index 2 kein valider Pointer
// auf ein Objekt zeigt.
System.out.println(objectArray[2]);

Eine interessante Mischform nimmt dabei wieder der String ein, da er sich wie immer wie ein Objekt verhält, das aber nicht mit new instatiiert werden muss:

String[] stringArray = new String[42];
stringArray[0] = "hallo";
stringArray[1] = "Juhuuu";
stringArray[2] = "Blablalb";
 
System.out.println(stringArray[0]); // Ausgabe: hallo
System.out.println(stringArray[2]); // Ausgabe: Blablalb
 
// NullPointerException!
System.out.println(stringArray[3]);

So viel zu den Basisics über Arrays. Wenn Euch was fehlt oder Ihr den Post gut fandet, laßt es mich gern in Form eines Kommentars wissen.

The advantage is mainly rendering speed which is greatly improved as you don’t pump your geometry into the rendering pipeline through individual glVertex, glNormal etc. commands in every render pass. Instead, you render your potentially complex geometry into a display list once and call ist every time you want the geometry to be rendered. This becomes enormously beneficial in a Java environment where you want to use as few JNI calls as possible.

The disadvantage is that a display list is fixed once it is uploaded to video memory. That means you cannot modify the order or geometry data after you compiled your list. Even if you only need to change one single glTranslate parameter, you would need to delete the entire list and create a new one.

So far for dry theory, let’s look at the example. Please note that this example makes use of my LWJGL example base class which I recommend to copy first so that the example runs out of the box.

We start with setting up the example class as follows. The setUp method is responsible for recording the GL commands into the “macro”.

public class DisplayListExample extends LwjglExampleBase
{
	// handle (id) of the display list to be generated
	private int displayListHandle = -1;
 
	// angle in degrees required for rotating the cubes
	private float rotationAngle = 0;
 
	/**
	 * Sets up LWJGL and OpenGL and renders the 
	 * display list.
	 */
	public void setUp() 
	{
		// Set up LWJGL and OpenGL using the
		// base class.
		super.setUp();
 
		// Generate one (!) display list.
		// The handle is used to identify the
		// list later.
		displayListHandle = glGenLists(1);
 
		// Start recording the new display list.
		glNewList(displayListHandle, GL_COMPILE);
 
		// Render a single cube
		renderCube(1);
 
		// End the recording of the current display list.
		glEndList();
	}

Setting up a display list is a simple as that. Note the parameter GL_COMPILE. It tells OpenGL to only compile the list and not to draw it at the same time. Alternatively,
one could use GL_COMPILE_AND_EXECUTE which would render the result while recording.

Lets us have a look into the renderCube() which basically contains the OpenGL commands to render a simple cube (without normals because we dont have lighting).

	public static void renderCube(float size)
	{
		final float HALF = size/2;
		glBegin(GL_QUADS);
 
		glColor3f(0, 0, 1);
		glVertex3f(-HALF, -HALF, -HALF); 
		glVertex3f(-HALF, size-HALF, -HALF); 
		glVertex3f(size-HALF, size-HALF, -HALF); 
		glVertex3f(size-HALF, -HALF, -HALF);  
 
		glColor3f(0, 1, 1);
		glVertex3f(-HALF, -HALF, size-HALF);  
		glVertex3f(-HALF, size-HALF, size-HALF);  
		glVertex3f(size-HALF, size-HALF, size-HALF); 
		glVertex3f(size-HALF, -HALF, size-HALF);  
 
		glColor3f(1, 0, 1);
		glVertex3f(-HALF, size-HALF, -HALF);  
		glVertex3f(size-HALF, size-HALF, -HALF); 
		glVertex3f(size-HALF, size-HALF, size-HALF); 
		glVertex3f(-HALF, size-HALF, size-HALF); 
 
		glColor3f(1, 0, 0);
		glVertex3f(-HALF, -HALF, -HALF);  
		glVertex3f(size-HALF, -HALF, -HALF); 
		glVertex3f(size-HALF, -HALF, size-HALF); 
		glVertex3f(-HALF, -HALF, size-HALF); 
 
		glColor3f(1, 1, 0);
		glVertex3f(-HALF, -HALF, -HALF);  
		glVertex3f(-HALF, size-HALF, -HALF); 
		glVertex3f(-HALF, size-HALF, size-HALF); 
		glVertex3f(-HALF, -HALF, size-HALF);  
 
		glColor3f(0, 1, 0);
		glVertex3f(size-HALF, -HALF, -HALF);  
		glVertex3f(size-HALF, size-HALF, -HALF); 
		glVertex3f(size-HALF, size-HALF, size-HALF); 
		glVertex3f(size-HALF, -HALF, size-HALF); 
 
		glEnd();
	}

Now comes the interesting part of calling the display list. To illustrate its usefulness, I draw a grid of 5×5 of the same cube and only change its position and rotation.

	/**
	 * Render 5x5 cubes centered around the origin. Each
	 * cubes has a slightly different rotation to make this
	 * example look more interesting.
	 */
	public void render() 
	{
		// In each render pass, add one degree to rotation
		// angle.
		rotationAngle += 1;
		for( int x = 0; x < 5; x++ )
		{
			for( int z = 0; z < 5; z++ )
			{
				// Save current MODELVIEW matrix to 
				// stack.
				glPushMatrix();
 
				// position next cube
				glTranslatef(x*2 - 4,0, z*2 - 4);
 
				// rotate next cube
				glRotatef(x*z*10+rotationAngle, 1, 1, 1);
 
				// Call the display list which renders
				// the cube.
				glCallList(displayListHandle);
 
				// Remove current MODELVIEW Matrix from
				// stack.
				glPopMatrix();
			}
		}
	}

And that’s it! Pretty easy, huh? To conclude the example I provide the main() method necessary to run the example. Also, please bear in mind that you need LwjglExampleBase to run the example.

	public static void main(String[] argv) 
	{
		DisplayListExample example = new DisplayListExample();
		example.setUp();
		example.gameLoop();
	}
}

Alright, we are done with the tutorial. If you liked the post, please leave a comment and let me know if you have questions or found a bug.

Cheers, Johannes

Picking is the process of finding objects in you scene based on user input. Most commonly, you want to determine what object a user has clicked with his mouse. In this case the 2D mouse coordinates serve as a reference on the view port to identify the projected objected that has been clicked. A similar scenario is a first person shooter, where the gun serves as the picking pointer, however in world space coordinates. If you shoot your gun, the trajectory of the bullet is traced through your scene and collisions are detected.

A screenshot showing a hex map in an LWJGL application with a selected tile as an example for 3D picking

OpenGL Selection Mode vs. Ray Picking

There are two common ways of implementing picking. The first one makes use of a special OpenGL feature in which you render your scene in a so-called “selection mode”. In selection mode, OpenGL does not render to the frame buffer but gathers depths information of the objects with is later read at the point where your picking occurs. The second approach is called “Ray Picking” and is independent from OpenGL and simulates a line that is shot through the scene until it hits an object. I personally prefer the second approach for the following reasons:

• You don’t need an additional render pass. A render pass can take some considerable amount of time and special clipping/culling code is required to only render the small part of the scene which you want to perform the picking on. In addition, you render a less complex scene (omitting textures, lighting, normals, etc) in selection mode if possible which can add a high degree of complexity to your drawing routines (imagine breaking up display lists). Ray picking obviously requires some code to trace the ray through your scene, but this is usually less complex.
• Ray picking can be done independently from the rest of the game code as a simultaneous and “read-only” operation on the scene graph. In some environments such as AWT/JOGL where the input devices are handled by a separate thread, your picking code can run as part of the handler thread and does not impact the performance of the rest of the game. This comes in handy especially in scenarios where you need to perform picking very often (eg. mouse hovering, target laser on the in-game gun).
• In pretty much all Java environments, calling OpenGL takes a considerable amount of time due to JNI. It is therefore beneficial to minimize the number OpenGL calls. Rendering in selection mode would mean additional OpenGL calls that I rather substitute with ray picking.

However, there are scenarios where ray picking is simply inferior or impractical. Consider picking in a scene with a lot of small details (eg. tree with little branches and leaves) or if you need to know the individual polygon/triangle that you picked. I will therefore cover both approaches, starting with ray picking in this post.

Ray Picking

Ray picking is the process of shooting a line (ie. “ray”) from the camera through the 2D viewscreen (where the 3D scene is projected on) into the scene until it hits an object. To do so, we need to know the camera and the point on the viewscreen (eg. mouse cursor position). The first point is trivial, however the second point is a bit more difficult to determine. Let’s say we have a 2D point on the viewscreen (x, y) and now want to map this point into world coordinates. One way would be to make use of the inverted viewing matrix, but inverting a matrix is usually an expensive undertaking. Instead, we compute the position of the plane of the viewscreen in world space and map the 2D point on this plane and from there into world space.

The algorithm in pseudo code follows below. Note that cameraLookAt is the 3D point where the camera looks at (as used on glLookat), cameraPosition is the current position of the camera in world space and cameraUp is the up vector of the camera.

x = getMouseX() // scalar
y = getMouseY() // scalar

view = cameraLookAt - cameraPosition // 3D float vector
normalize view

h = crossProduct( view, cameraUp ) // 3D float vector
normalize h

v = crossProduct( h, view) // 3D float vector
normalize v

ok, so far for h and v. Note that v is actually pointing in the same direction like the camera-up vector, but we compute it via the cross product to illustrate the method.

The vectors h and v are currently normalized to the length of 1. We now need to compute the lengths of h and v in the view port. In my example I assume that you set up your frustum by a field of view angle in degrees (fovy) as commonly the case with glFrustum. Let nearClippingDistance be the distance to the near clipping plane and width/height the ratio of the view port width divided by the viewport heigth.

// convert fovy to radians
rad = fovy * PI / 180
vLength = tan( rad / 2 ) * nearClippingPlaneDistance
hLength = vLength * (width / height)

scale v by vLength
scale h by hLength

The two scalars vLength and hLength in combinaton with v and h help spanning the view port plane extending from the center point. At this point it is worth mentioning that it may make sense to only compute h and v when you update the camera orientation because the normalization involves a square root which is a relatively expensive operation (actually tan may also be avoided).

Now it is time to map the 2D mouse coordinates onto the view port plane.

// translate mouse coordinates so that the origin lies in the center
// of the view port
x -= width / 2
y -= height / 2

// scale mouse coordinates so that half the view port width and height
// becomes 1
y /= (height / 2)
x /= (width / 2)

// linear combination to compute intersection of picking ray with
// view port plane
pos = cameraPos + view + h*x + v*y

// compute direction of picking ray by subtracting intersection point
// with camera position
dir = pos - cameraPos

That's pretty much it. We now got pos as the intersection point of the picking ray in the view port plane and the picking ray direction dir. This describes a line that can now be used to intersect with the individual objects of the scene.

// brute force
for all objects in the scene
  test for intersection and keep closest
end for

So by intersecting the picking ray with all your visible objects in your scene while keeping track of the distance, you determine the object that is hit by your mouse cursor.
Checking all objects in our scene may not be very efficient though. So in a first attempt I recommend to test only objects that lie (partly) within your viewing frustum. Under normal circumstances you got that code already in your scene graph as part of the software culling routine when pumping obects into the render pipeline.

I hope this helped. If you liked the post or if you got questions, ideas hints or found a problem, please leave a comment. I am trying to answer as quickly as possible. Also, if you want me to send you the source code of this example please let me know, I am happy to share the code.

// import GL11 statically which makes the GL code
// more readable
import static org.lwjgl.opengl.GL11.*;
 
// some more LWJGL imports that I omitted for brevity.
 
public abstract class LwjglExampleBase 
{
	/** width of window */
	private int viewportWidth = 800;
 
	/** height of window */
	private int viewportHeight = 600;
 
	/**
	 * Rudimentary OpenGL setup with LWJGL. Use perspective
	 * projection with a field of view of 45 degrees. 
	 */
	public void setUp() 
	{
		// set up LWJGL display
		try
		{
			Display.setDisplayMode(new DisplayMode(viewportWidth, viewportHeight));
			Display.create();
		}
		catch (LWJGLException e) {
			e.printStackTrace();
			System.exit(0);
		}
 
		// init viewport and projection matrix
		glViewport(0, 0, viewportWidth, viewportHeight);
		glMatrixMode(GL11.GL_PROJECTION);
		glLoadIdentity();
		GLU.gluPerspective( 45.0f, (float)viewportWidth/(float)viewportHeight, 1.0f, 200.0f ); 
		glMatrixMode(GL11.GL_MODELVIEW);
 
		glEnable(GL_DEPTH_TEST);
		glShadeModel (GL_SMOOTH);
		glClearColor (0f, 0f, 0f, 0f);
	}
 
	/**
	 * Game loop is basically an infinite loop that runs
	 * until the window is closed. It calls the abstract
	 * render() method which is to be implemented by the
	 * specific example class. 
	 */
	public void gameLoop()
	{
		while (!Display.isCloseRequested())
		{
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
			glLoadIdentity();
			GLU.gluLookAt(0, 15,0, 
					0, 0, 0, 
					0, 0, 1);
 
                        // call the abstract render method implemented by the
                        // extending class (eg. example, tutorial, etc.)
			render(); 
 
                        // sync to 60 frames per second
			Display.update();
			Display.sync(60);
		}
 
		Display.destroy();
	}
 
        /**
         * Abstract render method which is supposed to be
         * implemented by the extending tutorial or example
         * class.
         */
	public abstract void render();
 
	public int getViewportWidth() {
		return viewportWidth;
	}
 
	public void setViewportWidth(int viewportWidth) {
		this.viewportWidth = viewportWidth;
	}
 
	public int getViewportHeight() {
		return viewportHeight;
	}
 
	public void setViewportHeight(int viewportHeight) {
		this.viewportHeight = viewportHeight;
	}
}

That’s already it! Please make use of it as good as you can and leave a comment if you liked it or have questions.

Genau das macht affiliate2go zu einer technisch anspruchsvollen App: Sie muss die Eigenheiten der APIs der Affiliate Netwerke implementieren und dabei insbesondere die (leider nicht trivialen) Authorisationsmechaniken abbilden. Glücklicher Weise haben wir bei ladenzeile sehr viel Erfahrung mit dem Beziehen von Salesdaten aus Affiliate Netzwerken gewonnen, sodass wir das nötige Rüstzeug haben um eine solche App zu basteln.

Das aktuelle Release bindet zwei Große Affiliate Netzwerke an: Zanox und Affili.net. Weitere Netzwerke sind in der Planung. Bisher ist die App kostenlos. Wir wollen in der aktuellen Phase aber insbesondere Userfeedback sammeln, sodass wir uns sehr über alle möglichen Formen der Rückmeldung freuen.

Hier nochmal der Link zur App: affiliate2go von ladenzeile.

Vor diesem Hintergrund grenzt es eigentlich an ein Wunder, dass ich im fortgeschrittenen Alter von knapp 30 noch einmal ein Saiteninstrument in die Hand nahm. Aber gestern wars geschenen und ich musizierte wundebare Kammermusik für vier Personen. Als (mitleweile) Jazz und Swing-Fans widmeten wir uns dem alten Superhit “Hit Fly Me To The Moon” und spielten den Song so wie wir es vor zehn Jahren gelernt haben. Klar also, dass ich auch heute die Gesangslinie wieder singen musste.

Das Ergebnis kann hier heruntergeladen werden:

Enjoy.

For this tutorial, I am using

• jogl-b633-2012-01-23_20-37-13, and
• gluegen-b480-2012-01-23_16-49-04.

This is how your project setup should look like:

So one you got the binaries, unpack the ZIP file somewhere. You will notice the jar folder with a number of JAR files. All you need is in that jar folder, because the DLL binaries are included in the JARs.

Create a new eclipse project (name doesnt matter) and add the following JARs on the classpath:

• gluegen-rt-natives-windows-amd64.jar
• gluegen-rt.jar
• jogl-all-natives-windows-amd64.jar
• gluegen-rt.jar

These files are the native part of the OpenGL binding and are linked via Java Native Interface (JNI). Since the DLLs are precompiled as part of the JAR files, you are almost ready to go.

Once you got that set up, create a package de.schabby.jogl.helloworld and copypaste the following two classes in the newly created package.

package de.schabby.jogl.helloworld;
 
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
 
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
 
public class HelloWorld 
{
    public static void main(String[] args) 
    {
    	// setup OpenGL Version 2
    	GLProfile profile = GLProfile.get(GLProfile.GL2);
    	GLCapabilities capabilities = new GLCapabilities(profile);
 
    	// The canvas is the widget that's drawn in the JFrame
    	GLCanvas glcanvas = new GLCanvas(capabilities);
    	glcanvas.addGLEventListener(new Renderer());
    	glcanvas.setSize( 300, 300 );
 
        JFrame frame = new JFrame( "Hello World" );
        frame.getContentPane().add( glcanvas);
 
        // shutdown the program on windows close event
        frame.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent ev) {
                System.exit(0);
            }
        });
 
        frame.setSize( frame.getContentPane().getPreferredSize() );
        frame.setVisible( true );
    }
}

The Render.java class looks like follows. It implements GLEventListener which is the call-back implementaiton by JOGL to do all OpenGL rendering.

package de.schabby.jogl.helloworld;
 
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.glu.GLU;
 
class Renderer implements GLEventListener 
{
    private GLU glu = new GLU();
 
    public void display(GLAutoDrawable gLDrawable) 
    {
        final GL2 gl = gLDrawable.getGL().getGL2();
        gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
        gl.glLoadIdentity();
        gl.glTranslatef(-1.5f, 0.0f, -6.0f);
        gl.glBegin(GL2.GL_TRIANGLES);		
        gl.glVertex3f(0.0f, 1.0f, 0.0f);	
        gl.glVertex3f(-1.0f, -1.0f, 0.0f);	
        gl.glVertex3f(1.0f, -1.0f, 0.0f);	
        gl.glEnd();				
        gl.glTranslatef(3.0f, 0.0f, 0.0f);
        gl.glBegin(GL2.GL_QUADS);           	
        gl.glVertex3f(-1.0f, 1.0f, 0.0f);	
        gl.glVertex3f(1.0f, 1.0f, 0.0f);	
        gl.glVertex3f(1.0f, -1.0f, 0.0f);	
        gl.glVertex3f(-1.0f, -1.0f, 0.0f);	
        gl.glEnd();				
        gl.glFlush();
    }
 
 
    public void displayChanged(GLAutoDrawable gLDrawable, boolean modeChanged, boolean deviceChanged) 
    {
    	System.out.println("displayChanged called");
    }
 
    public void init(GLAutoDrawable gLDrawable) 
    {
    	System.out.println("init() called");
        GL2 gl = gLDrawable.getGL().getGL2();
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        gl.glShadeModel(GL2.GL_FLAT);
    }
 
    public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width, int height) 
    {
    	System.out.println("reshape() called: x = "+x+", y = "+y+", width = "+width+", height = "+height);
        final GL2 gl = gLDrawable.getGL().getGL2();
 
        if (height <= 0) // avoid a divide by zero error!
        {
            height = 1;
        }
 
        final float h = (float) width / (float) height;
 
        gl.glViewport(0, 0, width, height);
        gl.glMatrixMode(GL2.GL_PROJECTION);
        gl.glLoadIdentity();
        glu.gluPerspective(45.0f, h, 1.0, 20.0);
        gl.glMatrixMode(GL2.GL_MODELVIEW);
        gl.glLoadIdentity();
    }
 
 
	public void dispose(GLAutoDrawable arg0) 
	{
		System.out.println("dispose() called");
	}
}

By right-clicking on the main() method and chosing "run as application", Eclipse will execute the program. You should see something like this:

For the lazy, I provide a video-walkthough.

Common problems and solutions:

• If you get Can't load AMD 64-bit .dll on a IA 32-bit platform, then you are using an 64bit DLL (eg. gluegen-rt.dee) with an JRE that is 32bit. In most cases you can just switch to a 64bit JRE if you are running a 64bit system. Make sure that Eclipse is using the right JRE when you execute the code.
• If you get no gluegen-rt in java.library.path, then you may need to add gluegen-rt-natives-windows-amd64.jar to you classpath.
• If you get no nativewindow_awt in java.library.path, then you may need to add jogl-all-natives-windows-amd64.jar to you classpath.

That's it so far. Please let me know if you have questions or comments.