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.

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. 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:

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

• recent JOGL binary distribution download
• precompiled Windows Java OpenGL bindings
• you just can not find the place where to download JOGL

I had a couple of hours on my own recently and though it would be a good thing to catch up with the latest developments in the Java+OpenGL environment. So I looked for the download of JOGL (Java Bindings for OpenGL) just to realize, that I is actually quite difficult to find a recent binary distribution of JOGL!

Eventually, after a while I found it: http://jogamp.org/deployment/autobuilds/master/.

There you find an extensive list of directories containing builds, mostly for different binding projects such as gluegen, joal, etc. Search for “jogl” to jump to the JOGL builds.

The downloads are basically a list of (probably automated) builds. So I hope that this will be the place for the next months to get update-to-date JOGL binaries. The builds that have the suffix “-master” in their directory name appear to contain only documentation.

Please also note that for running JOGL you also need gluegen. I personally use the 2012-01-23 release at the moment. This is

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

which seem to work.

So the guys at JogAmp.org do actually provide precompiled binaries, they just make it difficult to find them.

Now that you downloaded JOGL, you may be interested in my JOGL Hello World example (includes how to set up the classpath and DLLs right).

Please leave a comment if it helps or my resource gets out of date.

2010-10-20 EDIT: updated download URL.
2010-11-03 EDIT: updated download URL again to point to autobild directory.
2010-11-19 EDIT: added reference to my hello world example with JOGL
2011-07-27 EDIT: updated link to JOGL downloads
2012-01-27 EDIT: updated link to JOGL downloads, added note about gluegen

crossdomain.xml is a bascially a whitelist of domains that you grant access to your site.

In more detail, browser plugins like Flash or hosted apps are always loaded from some URL, let’s say somedomain.com. Under normal circumstances, these programs are not allowed to access resources on hosts different from the host they where originally loaded, such as otherdomain.com for example. So if the client is loaded from somedomain.com and wants to load an image from otherdomain.com, it first checks otherdomain.com/crossdomain.xml if it actually allows somedomain.com to access the image.

A simple way to grant access to all resources on your site is to have a crossdomain.xml file that has the following content.

<cross-domain-policy>
   <allow-access-from domain="*"/>
</cross-domain-policy>

I hope that helps. Feel free to leave a comment!