PC's JOGL Blog

Blending with glPolygonOffset

2007-01-24T09:03:00.000+11:00

glPolygonOffset() is used to offset the polygon being rendered, and thus the pixels in the polygon, from the others currently in the displaybuffer. This does not actually effect the values written to the ZBuffer and is useful when blending two textures or polygons together.

The following images give an example of the problem and the effect of using glPolygonOffset. There are two polygons are rendered, the first being red, with the second being yellow blended over it in the same position in 3D space. The aim of the blending is to make a clean transition between red and yellow, or between 2 textures, in an animation. The second yellow polygon is a little bigger that the first red polygon be show the effect more clearly. In the first image, the "popping" of the red polygon through the yellow polygon occurs because the pixels values of the yellow polygon do not exactly match the Z buffer values of the first.

By enabling polygon offset the second polygon depth tests are performed using the following calculation...

"The value of the offset is factor * DZ + r * units, where DZ is a measurement of the change in depth relative to the screen area of the polygon, and r is the smallest value that is guaranteed to
produce a resolvable offset for a given implementation. The offset is added before the depth test is performed and before the value is written into the depth buffer *" OpenGL Reference Documentation

The result is that the second yellow polygon gives the desired result and blends nicely over the red polygon. This effect is very useful when blended between textures, for example, when changing a models level of detail. It is important when using this method that the polygons are drawn in a particular order. The offset yellow polygon must be draw original red polygon otherwise the effect does not work.

// Render first polygon
gl.glEnable(GL.GL_POLYGON_OFFSET_FILL) ;
gl.glPolygonOffset(-1.0f, 1.0f) ;
// Render second polygon
gl.glDisable(GL.GL_POLYGON_OFFSET_FILL) ;

Note that offsets can be used for the lines and the points in a polygon as well by enabling GL.GL_POLYGON_OFFSET_LINE and/or GL.GL_POLGON_OFFSET_POINT.

JNLP Download Error

2006-07-17T14:07:00.000+10:00

I came in to work this morning and decided to test my JNLP program. I was using Firefox to launch the application from my computer, which is behind a firewall and a proxy server, and web start was giving me "Download Error" message.

An error occurred while launching/
running the application.

Title: Simple Blending Example
Vendor: Peter Finch
Category: Download Error

Unable to load resource: http://www.homepla.net/webstart 
/simpleblending/simpleblending.jnlp

I found this was due to my proxy settings in IE, which was not setup to go through the proxy server (testing reasons), so web start could not get through the firewall to the Internet and load the program. It appears that web start uses the IE internet connection settings to get to the Internet by default.

You can change this using "javaws". Start "javaws" and go to the "Edit", "Preferences" menu to get the "Java Control Panel" dialog. From there go to the "General" tab and select "Network Settings". You'll probably find "Use Browser Settings" checked by default, so just set it to "use proxy server" and enter the appropriate details. It will now be independent of your browser settings.

JOGL Java Webstart (JNPL)

2006-07-15T16:29:00.000+10:00

Turning a JOGL application into a Java webstart application was relatively easy and just involves building a JAR file and creating a JNLP (Java Net Launch Protocol) file. After doing this once I bet you'll probably end up always using webstart to distribute you applications. It is just so easy to work with and installing applications on any browser with Java installed is a snap.

However, I did have a problem when trying to start the application from the browser for the first time. Webstart kept giving me an error message “Java Web Start – Unexpected Error - Unable to launch simpleblending”. When I asked for details, I got the following information (not the most helpful message).

An error occurred while launching/running 
the application.

Title: simpleblending
Vendor: Peter Finch
Category: Unexpected Error

Unexpected exception: java.lang.Exception

I tracked it down to the location I was getting the JOGL extension from. I originally used the prescribed location of https://jogl.dev.java.net/webstart/jogl-1-1.jnlp, however, when I changed this to http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jnlp the problem disappeared and the application started. Perhaps this is a library version problem or something. I understand it is possible to have your own copies of the libraries, which is probably a good idea so that you always know what version or JOGL your application running against. I'll work that out later...

Below is the JNPL file I used and here is a link to the webstart application. Just create a JAR file as you normally would. I like to use Ant scripts to automate the building and deployment for this sort of thing, as it is really easy and built into Eclipse. Note that the first time you load this it will go off and download the JOGL jar and native libraries for your platform. This could take a while (it's about 1.5MB's of data), but the great thing is that once it is downloaded, if any of you other applications use the same location they will reuse the already downloaded version and start up a lot quicking. JNPL even handles version changes (it's so cool!)

<?xml version="1.0" encoding="utf-8"?>
<jnlp spec="1.0+" codebase="http://www.homepla.net/webstart/simpleblending" href="simpleblending.jnlp">
  <information>
    <title>Simple Blending</title>
    <vendor>Peter Finch</vendor>
    <homepage href="http://www.homepla.net/webstart/simpleblending/" />
    <description>JOGL Webstart Example 1</description>
    <offline-allowed/>
  </information>
  <resources>
    <j2se version="1.4+" />
    <jar href="jplanet.jar" />
    <property name="sun.java2d.noddraw" value="true"/>
    <extension name="jogl" href="http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jnlp" />
  </resources>
  <application-desc main-class="jplanet.JPlanetWindow" />
</jnlp>

JOGL Draw Arrays

2006-07-13T16:19:00.000+10:00

Calling the OpenGL drawing primitives in Java, like glVertex() and glNormal(), quickly becomes a bottleneck for rendering scenes. The function call overhead, although small, when multiplied a million times for each polygon is a problem very quickly, however, this can be overcome using glDrawArrays (commonly known as vertex arrays). Vertices, normals, colours and texture coordinates can be loaded into an IntBuffer, FloatBuffer or a DoubleBuffer (depending on what you want to use) and then sent to the rendering engine using a single glDrawArrays() function call.


import java.nio.DoubleBuffer ;
..
DoubleBuffer verticesBuffer = BufferUtil.newDoubleBuffer(3 * 3) ;
..
verticesBuffer.put(c0.x) ;
verticesBuffer.put(c0.y) ;
verticesBuffer.put(c0.z) ;
verticesBuffer.put(c1.x) ;
verticesBuffer.put(c1.y) ;
verticesBuffer.put(c1.z) ;
verticesBuffer.put(c2.x) ;
verticesBuffer.put(c2.y) ;
verticesBuffer.put(c2.z) ;
..
gl.glEnableClientState (GL.GL_VERTEX_ARRAY);        
verticesBuffer.rewind();
gl.glVertexPointer(3, GL.GL_DOUBLE, 0, verticesBuffer);        
gl.glDrawArrays(GL.GL_TRIANGLES, 0, 3);

Sadly, there is still a function call overhead loading the values into the DoubleBuffer, however, this is less that the overhead of calling glVertex() multiple times. Make sure you rewind the location in the buffer using verticesBuffer.rewind() or verticesBuffer.position(0) before calling glVertexPointer() otherwise you will load the current location in the buffer into OpenGL instead of the starting location and you’ll end up only seeing a new vertices each call.

I found that loading the values into a local array and the calling the put(double[], int, int) function to load multiple values at once was much slower that calling multiple put(double) functions, even if the array was pre-allocated and reused. I could not find any way to load values into the buffers without doing it thought a function call… so if you know how to do please let me know.


// Really slow for some reason.
double array[] = new double[9] ;
array[0] = c0.x ;
array[1] = c0.y ;
..
verticesBuffer.put(array, 0, 9) ;

Rendering tip… remember to set gl.glEnable(GL.GL_NORMALIZE) when using matrixes to translating and scaling groups of vertices, otherwise the vertices normals passed to OpenGL get transformed as well, but they don’t get re-normalized, so you end up of unexpected lighting results.

Here is some good example code but make sure you add that rewind calling glColorPointer().

Using the mouse

2006-07-06T07:57:00.000+10:00

When using a Java Frame to hold the JOGL GLCanvas, interaction with the frame, using the mouse, can be done in the usual way by using a Listener. The listener event handler class (the class which is to receive the events), must implement the MouseListener, MouseMotionListener interfaces. One of the nice things about Eclipse is that the moment you add these interfaces to the class it will ask you if you want to add the corresponding functions.

public class joglpbuffer implements 
  GLEventListener, 
  MouseListener, 
  MouseMotionListener  {

  public void init(GLAutoDrawable drawable) {
    drawable.addMouseListener(this);
    drawable.addMouseMotionListener(this);
  }
}

The event functions themselves are self explanatory. They are all passed a MouseEvent argument which can be used to determine the location of the mouse or the button that was just pressed.

  public void mouseClicked(MouseEvent e) {}
  public void mouseEntered(MouseEvent e) {}
  public void mouseExited(MouseEvent e) {}
  public void mouseMoved(MouseEvent e) {} 
  public void mousePressed(MouseEvent e) {
    prevMouseX = e.getX();
    prevMouseY = e.getY();
    if ((e.getModifiers() & e.BUTTON3_MASK) != 0) {
      mouseRButtonDown = true;
    }
  }
  public void mouseReleased(MouseEvent e) {
    if ((e.getModifiers() & e.BUTTON3_MASK) != 0) {
      mouseRButtonDown = false;
    }
  }
  public void mouseDragged(MouseEvent e) {
    int x = e.getX();
    int y = e.getY();
  }

Simple Application

2006-06-28T19:53:00.000+10:00

Step 1 - Create a frame

There are two types of OpenGL "windows" in JOGL, a GLCanvas and a GLJPanel. The GLJPanel is for use with the normal Java2D API while the GLCanvas is a high performace version. To create an OpenGL window first create a Frame and the simply add a GLCanvas to it.

Frame frame = new Frame("PBuffers") ;
GLCanvas canvas = new GLCanvas() ;
canvas.addGLEventListener(this);
frame.add(canvas);
frame.setSize(640, 480);

The application is notified of OpenGL events via 4 simple callbacks that are called following the registration of the GLEventListener listener via the canvas.addGLEventListener(this) call. It's easier to use the GLU functions with can be called from the GLU object.

Step 2 - Initilize the OpenGL context

The init() method is called when the windows is first created. The display() function is only called when the display needs to be repainted so the Animator class be used to update the display periodically.

public void init(GLAutoDrawable drawable) 
{
  final GL gl = drawable.getGL();
  gl.setSwapInterval(0);
  animator = new Animator(canvas);
  animator.setRunAsFastAsPossible(true) ;
  animator.start() ;  
}

Step 3 - Add a display callback

The display() method is called when the window needs to be updated and is where all the OpenGL drawing should take place.

public void display(GLAutoDrawable drawable) 
{
  GL gl = drawable.getGL() ;
}

Step 4 - Add a reshape callback

The reshape() method is called when the window size changes. This callback is called once when the application is started.

public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) 
{
  GL gl = drawable.getGL();
  float h = (float) width / (float) height;
  gl.glMatrixMode(GL.GL_PROJECTION);
  gl.glLoadIdentity();
  glu.gluPerspective( 40.0, h, 1.00, 100.0 );
}

Step 5 - Add a displayChanged callback

The displayChanged() method is called then the display is changed.

public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) 
{
}

Notes:

If the GLUT objects appear to be rendered back to front (or inside out) then try gl.glEnable(GL.GL_CW) as GLUT polygons are rendered in clock-wise order.

Setup light sources with all options as LIGHT0 has defaults that the others lights do not appear to have.

gl.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, light2pos, 0);
gl.glLightfv(GL.GL_LIGHT1, GL.GL_AMBIENT, light2amb, 0);
gl.glLightfv(GL.GL_LIGHT1, GL.GL_DIFFUSE, light2diff, 0);
gl.glLightfv(GL.GL_LIGHT1, GL.GL_SPECULAR, light2spec, 0);
gl.glEnable(GL.GL_LIGHT1);

What happened to my frame rate!

2006-06-23T16:02:00.000+10:00

Ok, I don't mean to boast, but I do have a pretty good graphics card… it’s a NVidia 6800. My PC is no slouch either, and I’ve got plenty of memory, so when I started up the gears.java demo I was expecting a pretty high frame. However, it just didn’t look right. I added some code to the display() function (which gets called to display each frame) and I was getting 60FPS... Hold the phone!!!!

if(nFrame++ > 200) {
  if(nLastUpdate != 0) {
    long nTimeMS = System.currentTimeMillis() - nLastUpdate ;
    System.out.println(nFrame + " in " + nTimeMS + "msec (" +
      nFrame * 1000 / nTimeMS + " FPS)") ;
  } 
  nFrame = 0 ;
  nLastUpdate = System.currentTimeMillis() ;
}

60FPS…um… that is my monitor refresh rate (I’ve got an LCD). Ahhh, now I remember… Vertical retrace! To stop frames from tearing while being display most OpenGL implementations pause and wait for the monitors Vertical Retrace Interrupt before updating the image. Usually, it’s a pain to turn this off in OpenGL but in JOGL it’s easy. If you want to pull the maximum frame rate just set the "swap interval" to 0 in the init() function.

public void init(GLAutoDrawable drawable) {
  GL gl = drawable.getGL();
  gl.setSwapInterval(0);
  …
}

1100 FPS … That’s better, now that’s what I like to see!

Development Environment

2006-06-23T12:03:00.000+10:00

I use Eclipse for all my Java development. In fact which all it's difference plugins Eclipse is pretty a pretty good development environment for most things, I also use it for PHP, ASP and C/C++ on Linux. I found the following website by Martin John Baker that does a good job of describing the setting up of the Eclipse IDE enviroment for JOGL. Basically, for setting up a simple Java JOGL Application

Download the "jogl.jar" and the platform native libraries like "jogl-natives-macosx-universal.jar".
Create a new Java project.
In "project | Properties | Java Build Path" add the "jogl.jar" library.
Then the tricky bit, add the native libraries. They come is a "jar" from the JOGL website so you may have to extract the DLL's (so's for linux, etc) from the JAR and place them in a new directory. Then just add the path as described in the Martin's web page. i.e. Select the "Native library location" and set it to the location of your DLL's.

Add some code. I used the "gears.java" class from the demos that come with JOGL.

Introduction

2006-06-22T16:37:00.000+10:00

After years of writing OpenGL applications in C or C++ I have finally decided to try my hand at one of the many Java OpenGL API's. I have been programming in Java for many years, but I never really thought about using it for OpenGL, as I always thought it would be too slow. One of my mates at work was using LWJGL to do some stuff and I was pretty impressed by what he could do using Java, so I thought it's about time to give it a go.

I have decided to try JOGL for a number of reasons, but mainly because it seems to have better support for OpenGL 2.0 and all those neat OpenGL extensions that make modern 3D graphics look so good and seems to have a bit better Java community support. I could be wring, that's what I'm here to find out. So, I have set up this Blog to record my notes and programs, however, my hope is that you (yes YOU!) may also find this useful or even be able to help me out with suggestions or your experience. Anyway, we'll see how I go...