Copied JOGL_2_SANDBOX r350 on to trunk; JOGL_2_SANDBOX branch is now closed

git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/../svn-server-sync/jogl-demos/trunk@352 3298f667-5e0e-4b4a-8ed4-a3559d26a5f4

1 files changed, 782 insertions, 0 deletions

diff --git a/src/demos/vertexBufferObject/VertexBufferObject.java b/src/demos/vertexBufferObject/VertexBufferObject.java
new file mode 100644
index 0000000..0bc8b10
--- /dev/null
+++ b/src/demos/vertexBufferObject/VertexBufferObject.java
@@ -0,0 +1,782 @@
+/*
+ * Portions Copyright (C) 2003 Sun Microsystems, Inc.
+ * All rights reserved.
+ */
+
+/*
+ *
+ * COPYRIGHT NVIDIA CORPORATION 2003. ALL RIGHTS RESERVED.
+ * BY ACCESSING OR USING THIS SOFTWARE, YOU AGREE TO:
+ *
+ *  1) ACKNOWLEDGE NVIDIA'S EXCLUSIVE OWNERSHIP OF ALL RIGHTS
+ *     IN AND TO THE SOFTWARE;
+ *
+ *  2) NOT MAKE OR DISTRIBUTE COPIES OF THE SOFTWARE WITHOUT
+ *     INCLUDING THIS NOTICE AND AGREEMENT;
+ *
+ *  3) ACKNOWLEDGE THAT TO THE MAXIMUM EXTENT PERMITTED BY
+ *     APPLICABLE LAW, THIS SOFTWARE IS PROVIDED *AS IS* AND
+ *     THAT NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES,
+ *     EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED
+ *     TO, IMPLIED WARRANTIES OF MERCHANTABILITY  AND FITNESS
+ *     FOR A PARTICULAR PURPOSE.
+ *
+ * IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY
+ * SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
+ * WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS
+ * OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
+ * INFORMATION, OR ANY OTHER PECUNIARY LOSS), INCLUDING ATTORNEYS'
+ * FEES, RELATING TO THE USE OF OR INABILITY TO USE THIS SOFTWARE,
+ * EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ */
+
+package demos.vertexBufferObject;
+
+import demos.common.Demo;
+import demos.common.DemoListener;
+import java.awt.BorderLayout;
+import java.awt.Frame;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import javax.media.opengl.GL;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLProfile;
+import javax.media.opengl.GL2ES1;
+import javax.media.opengl.GL2;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLProfile;
+import javax.media.opengl.awt.AWTGLAutoDrawable;
+import javax.media.opengl.awt.GLCanvas;
+import javax.media.opengl.glu.GLU;
+import com.sun.opengl.util.Animator;
+import com.sun.opengl.util.BufferUtil;
+import javax.swing.JOptionPane;
+
+
+
+/** <P> A port of NVidia's [tm] Vertex Array Range demonstration to
+    OpenGL[tm] for Java[tm], the Java programming language, and the
+    vendor-neutral Vertex Buffer Object extension. The current web
+    site for the demo is <a href =
+    "http://developer.nvidia.com/object/vardemo.html">here</a>. </P>
+
+    <P> This demonstration requires the following:
+
+    <ul>
+    <li> A JDK 1.4 implementation
+    <li> A card supporting the GL_ARB_vertex_buffer_object extension
+         (only in recent drivers)
+    </ul>
+
+    </P>
+
+    <P> This demonstration illustrates the use of the java.nio direct
+    buffer classes in JDK 1.4 to access memory outside of the Java
+    garbage-collected heap, in particular that returned from the call
+    glMapBuffer, to achieve higher performance than accessing the
+    same data in system memory allows. </P>
+*/
+
+public class VertexBufferObject extends Demo {
+
+  public static void main(String[] args) {
+
+    boolean vboEnabled = true;
+
+    if (args.length > 1) {
+      usage();
+    }
+
+    if (args.length == 1) {
+      if (args[0].equals("-slow")) {
+        vboEnabled = false;
+      } else {
+        usage();
+      }
+    }
+    GLCapabilities caps = new GLCapabilities(GLProfile.get(GLProfile.GL2));
+    GLCanvas canvas = new GLCanvas(caps);
+    VertexBufferObject demo = new VertexBufferObject();
+    demo.vboEnabled = vboEnabled;
+    canvas.addGLEventListener(demo);
+
+    final Animator animator = new Animator(canvas);
+    animator.setRunAsFastAsPossible(true);
+    demo.setDemoListener(new DemoListener() {
+        public void shutdownDemo() {
+          runExit(animator);
+        }
+        public void repaint() {}
+      });
+
+    Frame frame = new Frame("Very Simple vertex_buffer_object demo");
+    frame.addWindowListener(new WindowAdapter() {
+        public void windowClosing(WindowEvent e) {
+          runExit(animator);
+        }
+      });
+    frame.setLayout(new BorderLayout());
+    canvas.setSize(800, 800);
+    frame.add(canvas, BorderLayout.CENTER);
+    frame.pack();
+    frame.setVisible(true);
+    canvas.requestFocus();
+
+    animator.start();
+  }
+
+  private static void usage() {
+    System.out.println("usage: java VertexBufferObject [-slow]");
+    System.out.println("-slow flag starts up using data in the Java heap");
+    System.exit(0);
+  }
+
+  public VertexBufferObject() {
+    setFlag(' ', true);   // animation on
+    setFlag('i', true);   // infinite viewer and light
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private GLU glu = new GLU();
+  private boolean initComplete;
+  private boolean[] b = new boolean[256];
+  private static final int SIZEOF_FLOAT = 4;
+  //  private static final int STRIP_SIZE  = 48;
+  private static final int STRIP_SIZE  = 144;
+  //  private int tileSize   = 9 * STRIP_SIZE;
+  private int tileSize   = 3 * STRIP_SIZE;
+  private int numBuffers = 1;
+  private int bufferLength = 1000000;
+  private int bufferSize   = bufferLength * SIZEOF_FLOAT;
+  private static final int SIN_ARRAY_SIZE = 1024;
+
+  private int         bigBufferObject;
+  private boolean     vboEnabled = true;
+  private ByteBuffer  bigArrayVBOBytes;
+  private FloatBuffer bigArrayVBO;
+  private FloatBuffer bigArraySystem;
+  private FloatBuffer bigArray;
+  private IntBuffer[] elements;
+  private int         elementBufferObject;
+  private float[]     xyArray;
+
+  static class VBOBuffer {
+    public FloatBuffer vertices;
+    public FloatBuffer normals;
+    public int         vertexOffset;
+    public int         normalOffset;
+  }
+  private VBOBuffer[] buffers;
+
+  private float[] sinArray;
+  private float[] cosArray;
+
+  // Primitive: GL_QUAD_STRIP, GL_LINE_STRIP, or GL_POINTS
+  private int primitive = GL2.GL_QUAD_STRIP;
+
+  // Animation parameters
+  private float hicoef = .06f;
+  private float locoef = .10f;
+  private float hifreq = 6.1f;
+  private float lofreq = 2.5f;
+  private float phaseRate = .02f;
+  private float phase2Rate = -0.12f;
+  private float phase  = 0;
+  private float phase2 = 0;
+
+  // Temporaries for computation
+  float[] ysinlo = new float[STRIP_SIZE];
+  float[] ycoslo = new float[STRIP_SIZE];
+  float[] ysinhi = new float[STRIP_SIZE];
+  float[] ycoshi = new float[STRIP_SIZE];
+
+  // For thread-safety when dealing with keypresses
+  private volatile boolean toggleVBO           = false;
+  private volatile boolean toggleLighting      = false;
+  private volatile boolean toggleLightingModel = false;
+  private volatile boolean recomputeElements   = false;
+
+  // Frames-per-second computation
+  private boolean firstProfiledFrame;
+  private int     profiledFrameCount;
+  private int     numDrawElementsCalls;
+  private long startTimeMillis;
+
+  static class PeriodicIterator {
+    public PeriodicIterator(int arraySize,
+                            float period,
+                            float initialOffset,
+                            float delta) {
+      float arrayDelta =  arraySize * (delta / period); // floating-point steps-per-increment
+      increment = (int)(arrayDelta * (1<<16));          // fixed-point steps-per-increment
+
+      float offset = arraySize * (initialOffset / period); // floating-point initial index
+      initOffset = (int)(offset * (1<<16));                // fixed-point initial index
+
+        arraySizeMask = 0;
+        int i = 20; // array should be reasonably sized...
+        while((arraySize & (1<<i)) == 0) {
+          i--;
+        }
+        arraySizeMask = (1<<i)-1;
+        index = initOffset;
+    }
+
+    public PeriodicIterator(PeriodicIterator arg) {
+      this.arraySizeMask = arg.arraySizeMask;
+      this.increment = arg.increment;
+      this.initOffset = arg.initOffset;
+      this.index = arg.index;
+    }
+
+    public int getIndex() {
+      return (index >> 16) & arraySizeMask;
+    }
+
+    public void incr() {
+      index += increment;
+    }
+
+    public void decr() {
+      index -= increment;
+    }
+
+    public void reset() {
+      index = initOffset;
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    private int arraySizeMask;
+    // fraction bits == 16
+    private int increment;
+    private int initOffset;
+    private int index;
+  }
+
+  private void setFlag(char key, boolean val) {
+    b[((int) key) & 0xFF] = val;
+  }
+
+  private boolean getFlag(char key) {
+    return b[((int) key) & 0xFF];
+  }
+
+  private void initExtension(GL gl, String glExtensionName) {
+    if (!gl.isExtensionAvailable(glExtensionName)) {
+      final String message = "OpenGL extension \"" + glExtensionName + "\" not available";
+      new Thread(new Runnable() {
+          public void run() {
+            JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE);
+            shutdownDemo();
+          }
+        }).start();
+      throw new RuntimeException(message);
+    }
+  }
+
+  public void init(GLAutoDrawable drawable) {
+    initComplete = false;
+    //    drawable.setGL(new TraceGL(drawable.getGL(), System.err));
+    //    drawable.setGL(new DebugGL(drawable.getGL()));
+
+    GL2 gl = drawable.getGL().getGL2();
+
+    // Try and disable synch-to-retrace for fastest framerate
+    gl.setSwapInterval(0);
+
+    try {
+      initExtension(gl, "GL_ARB_vertex_buffer_object");
+    } catch (RuntimeException e) {
+      throw (e);
+    }      
+      
+    gl.glEnable(GL.GL_DEPTH_TEST);
+
+    gl.glClearColor(0, 0, 0, 0);
+
+    gl.glEnable(GL2ES1.GL_LIGHT0);
+    gl.glEnable(GL2ES1.GL_LIGHTING);
+    gl.glEnable(GL2ES1.GL_NORMALIZE);
+    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2ES1.GL_AMBIENT, new float[]  {.1f, .1f,    0, 1}, 0);
+    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2ES1.GL_DIFFUSE, new float[]  {.6f, .6f,  .1f, 1}, 0);
+    gl.glMaterialfv(GL.GL_FRONT_AND_BACK, GL2ES1.GL_SPECULAR, new float[] { 1,    1, .75f, 1}, 0);
+    gl.glMaterialf(GL.GL_FRONT_AND_BACK, GL2ES1.GL_SHININESS, 128.f);
+
+    gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, new float[] { .5f, 0, .5f, 0}, 0);
+    gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
+
+    // NOTE: it looks like GLUT (or something else) sets up the
+    // projection matrix in the C version of this demo.
+    gl.glMatrixMode(GL2ES1.GL_PROJECTION);
+    gl.glLoadIdentity();
+    glu.gluPerspective(60, 1.0, 0.1, 100);
+    gl.glMatrixMode(GL2ES1.GL_MODELVIEW);
+
+    allocateBigArray(gl);
+    allocateBuffers(gl);
+
+    sinArray = new float[SIN_ARRAY_SIZE];
+    cosArray = new float[SIN_ARRAY_SIZE];
+
+    for (int i = 0; i < SIN_ARRAY_SIZE; i++) {
+      double step = i * 2 * Math.PI / SIN_ARRAY_SIZE;
+      sinArray[i] = (float) Math.sin(step);
+      cosArray[i] = (float) Math.cos(step);
+    }
+
+    if (vboEnabled) {
+      bigArray = bigArrayVBO;
+    } else {
+      bigArray = bigArraySystem;
+    }
+    setupBuffers();
+    gl.glEnableClientState(GL2ES1.GL_VERTEX_ARRAY);
+    gl.glEnableClientState(GL2ES1.GL_NORMAL_ARRAY);
+
+    computeElements(gl);
+
+    if (drawable instanceof AWTGLAutoDrawable) {
+        ((AWTGLAutoDrawable) drawable).addKeyListener(new KeyAdapter() {
+                public void keyTyped(KeyEvent e) {
+                    dispatchKey(e.getKeyChar());
+                }
+            });
+    }
+
+    initComplete = true;
+  }
+
+  private void allocateBuffers(GL gl) {
+    buffers = new VBOBuffer[numBuffers];
+    for (int i = 0; i < numBuffers; i++) {
+      buffers[i] = new VBOBuffer();
+    }
+  }
+
+  private void setupBuffers() {
+    int sliceSize = bufferLength / numBuffers;
+    for (int i = 0; i < numBuffers; i++) {
+      int startIndex = i * sliceSize;
+      buffers[i].vertices = sliceBuffer(bigArray, startIndex, sliceSize);
+      buffers[i].normals  = sliceBuffer(buffers[i].vertices, 3,
+                                        buffers[i].vertices.limit() - 3);
+      buffers[i].vertexOffset = startIndex       * BufferUtil.SIZEOF_FLOAT;
+      buffers[i].normalOffset = (startIndex + 3) * BufferUtil.SIZEOF_FLOAT;
+    }
+  }
+
+  private void dispatchKey(char k) {
+    setFlag(k, !getFlag(k));
+    // Quit on escape or 'q'
+    if ((k == (char) 27) || (k == 'q')) {
+      shutdownDemo();
+      return;
+    }
+
+    if (k == 'r') {
+      if (getFlag(k)) {
+        profiledFrameCount = 0;
+        numDrawElementsCalls = 0;
+        firstProfiledFrame = true;
+      }
+    }
+
+    if (k == 'w') {
+      if (getFlag(k)) {
+        primitive = GL.GL_LINE_STRIP;
+      } else {
+        primitive = GL2.GL_QUAD_STRIP;
+      }
+    }
+
+    if (k == 'p') {
+      if (getFlag(k)) {
+        primitive = GL.GL_POINTS;
+      } else {
+        primitive = GL2.GL_QUAD_STRIP;
+      }
+    }
+
+    if (k == 'v') {
+      toggleVBO = true;
+    }
+
+    if (k == 'd') {
+      toggleLighting = true;
+    }
+
+    if (k == 'i') {
+      toggleLightingModel = true;
+    }
+
+    if('h'==k)
+      hicoef += .005;
+    if('H'==k)
+      hicoef -= .005;
+    if('l'==k)
+      locoef += .005;
+    if('L'==k)
+      locoef -= .005;
+    if('1'==k)
+      lofreq += .1f;
+    if('2'==k)
+      lofreq -= .1f;
+    if('3'==k)
+      hifreq += .1f;
+    if('4'==k)
+      hifreq -= .1f;
+    if('5'==k)
+      phaseRate += .01f;
+    if('6'==k)
+      phaseRate -= .01f;
+    if('7'==k)
+      phase2Rate += .01f;
+    if('8'==k)
+      phase2Rate -= .01f;
+
+    if('t'==k) {
+      if(tileSize < 864) {
+        tileSize += STRIP_SIZE;
+        recomputeElements = true;
+        System.err.println("tileSize = " + tileSize);
+      }
+    }
+
+    if('T'==k) {
+      if(tileSize > STRIP_SIZE) {
+        tileSize -= STRIP_SIZE;
+        recomputeElements = true;
+        System.err.println("tileSize = " + tileSize);
+      }
+    }
+  }
+
+  public void dispose(GLAutoDrawable drawable) {
+  }
+
+  public void display(GLAutoDrawable drawable) {
+    if (!initComplete) {
+      return;
+    }
+
+    GL2 gl = drawable.getGL().getGL2();
+
+    // Check to see whether to animate
+    if (getFlag(' ')) {
+      phase += phaseRate;
+      phase2 += phase2Rate;
+
+      if (phase > (float) (20 * Math.PI)) {
+        phase = 0;
+      }
+
+      if (phase2 < (float) (-20 * Math.PI)) {
+        phase2 = 0;
+      }
+    }
+
+    PeriodicIterator loX =
+      new PeriodicIterator(SIN_ARRAY_SIZE, (float) (2 * Math.PI), phase, (float) ((1.f/tileSize)*lofreq*Math.PI));
+    PeriodicIterator loY = new PeriodicIterator(loX);
+    PeriodicIterator hiX =
+      new PeriodicIterator(SIN_ARRAY_SIZE, (float) (2 * Math.PI), phase2, (float) ((1.f/tileSize)*hifreq*Math.PI));
+    PeriodicIterator hiY = new PeriodicIterator(hiX);
+
+    if (toggleVBO) {
+      vboEnabled = !vboEnabled;
+      if (!vboEnabled) {
+        bigArray = bigArraySystem;
+        setupBuffers();
+      }
+      toggleVBO = false;
+    }
+
+    if (toggleLighting) {
+      if (getFlag('d')) {
+        gl.glDisable(GL2ES1.GL_LIGHTING);
+      } else {
+        gl.glEnable(GL2ES1.GL_LIGHTING);
+      }
+      toggleLighting = false;
+    }
+
+    if (toggleLightingModel) {
+      if(getFlag('i')) {
+        // infinite light
+        gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, new float[] { .5f, 0, .5f, 0 }, 0);
+        gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, 0);
+      } else {
+        gl.glLightfv(GL2ES1.GL_LIGHT0, GL2ES1.GL_POSITION, new float[] { .5f, 0, -.5f,1 }, 0);
+        gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
+      }
+      toggleLightingModel = false;
+    }
+
+    if (recomputeElements) {
+      computeElements(gl);
+      recomputeElements = false;
+    }
+
+    gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+
+    gl.glPushMatrix();
+
+    final float[] modelViewMatrix = new float[] {
+      1, 0, 0, 0,
+      0, 1, 0, 0,
+      0, 0, 1, 0,
+      0, 0, -1, 1
+    };
+    gl.glLoadMatrixf(modelViewMatrix, 0);
+
+    // FIXME: add mouse interaction
+    // camera.apply_inverse_transform();
+    // object.apply_transform();
+
+    int cur = 0;
+    int numSlabs = tileSize / STRIP_SIZE;
+
+    if (vboEnabled) {
+      gl.glBindBuffer(GL.GL_ARRAY_BUFFER, bigBufferObject);
+    } else {
+      gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+    }
+
+    for(int slab = numSlabs; --slab>=0; ) {
+      cur = slab % numBuffers;
+
+      if (vboEnabled) {
+        ByteBuffer tmp = gl.glMapBuffer(GL.GL_ARRAY_BUFFER, GL2.GL_WRITE_ONLY);
+        if (tmp == null) {
+          throw new RuntimeException("Unable to map vertex buffer object");
+        }
+        if (tmp != bigArrayVBOBytes) {
+          bigArrayVBOBytes = tmp;
+          bigArrayVBO = setupBuffer(tmp);
+        }
+        if (bigArray != bigArrayVBO) {
+          bigArray = bigArrayVBO;
+          setupBuffers();
+        }
+      }
+
+      FloatBuffer v = buffers[cur].vertices;
+      int vertexIndex = 0;
+
+      if (vboEnabled) {
+        gl.glVertexPointer(3, GL.GL_FLOAT, 6 * SIZEOF_FLOAT, buffers[cur].vertexOffset);
+        gl.glNormalPointer(   GL.GL_FLOAT, 6 * SIZEOF_FLOAT, buffers[cur].normalOffset);
+      } else {
+        gl.glVertexPointer(3, GL.GL_FLOAT, 6 * SIZEOF_FLOAT, v);
+        gl.glNormalPointer(   GL.GL_FLOAT, 6 * SIZEOF_FLOAT, buffers[cur].normals);
+      }
+
+      for(int jj=STRIP_SIZE; --jj>=0; ) {
+        ysinlo[jj] = sinArray[loY.getIndex()];
+        ycoslo[jj] = cosArray[loY.getIndex()]; loY.incr();
+        ysinhi[jj] = sinArray[hiY.getIndex()];
+        ycoshi[jj] = cosArray[hiY.getIndex()]; hiY.incr();
+      }
+      loY.decr();
+      hiY.decr();
+
+      for(int i = tileSize; --i>=0; ) {
+        float x = xyArray[i];
+        int loXIndex = loX.getIndex();
+        int hiXIndex = hiX.getIndex();
+
+        int jOffset = (STRIP_SIZE-1)*slab;
+        float nx = locoef * -cosArray[loXIndex] + hicoef * -cosArray[hiXIndex];
+
+        // Help the HotSpot Client Compiler by hoisting loop
+        // invariant variables into locals. Note that this may be
+        // good practice for innermost loops anyway since under
+        // the new memory model operations like accidental
+        // synchronization may force any compiler to reload these
+        // fields from memory, destroying their ability to
+        // optimize.
+        float locoef_tmp = locoef;
+        float hicoef_tmp = hicoef;
+        float[] ysinlo_tmp = ysinlo;
+        float[] ysinhi_tmp = ysinhi;
+        float[] ycoslo_tmp = ycoslo;
+        float[] ycoshi_tmp = ycoshi;
+        float[] sinArray_tmp = sinArray;
+        float[] xyArray_tmp = xyArray;
+
+        for(int j = STRIP_SIZE; --j>=0; ) {
+          float y;
+
+          y = xyArray_tmp[j + jOffset];
+
+          float ny;
+
+          v.put(vertexIndex, x);
+          v.put(vertexIndex + 1, y);
+          v.put(vertexIndex + 2, (locoef_tmp * (sinArray_tmp[loXIndex] + ysinlo_tmp[j]) +
+                                  hicoef_tmp * (sinArray_tmp[hiXIndex] + ysinhi_tmp[j])));
+          v.put(vertexIndex + 3, nx);
+          ny = locoef_tmp * -ycoslo_tmp[j] + hicoef_tmp * -ycoshi_tmp[j];
+          v.put(vertexIndex + 4, ny);
+          v.put(vertexIndex + 5, .15f); //.15f * (1.f - sqrt(nx * nx + ny * ny));
+          vertexIndex += 6;
+        }
+        loX.incr();
+        hiX.incr();
+      }
+      loX.reset();
+      hiX.reset();
+
+      if (vboEnabled) {
+        gl.glUnmapBuffer(GL.GL_ARRAY_BUFFER);
+      }
+
+      if (getFlag('m')) {
+        // Elements merged into buffer object (doesn't seem to improve performance)
+
+        int len = tileSize - 1;
+        gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, elementBufferObject);
+        for (int i = 0; i < len; i++) {
+          ++numDrawElementsCalls;
+          gl.glDrawElements(primitive, 2 * STRIP_SIZE, GL2.GL_UNSIGNED_INT,
+                            i * 2 * STRIP_SIZE * BufferUtil.SIZEOF_INT);
+          if(getFlag('f')) {
+            gl.glFlush();
+          }
+        }
+        gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
+      } else {
+        for (int i = 0; i < elements.length; i++) {
+          ++numDrawElementsCalls;
+          gl.glDrawElements(primitive, elements[i].remaining(), GL2.GL_UNSIGNED_INT, elements[i]);
+          if(getFlag('f')) {
+            gl.glFlush();
+          }
+        }
+      }
+    }
+
+    gl.glPopMatrix();
+
+    if (getFlag('r')) {
+      if (!firstProfiledFrame) {
+        if (++profiledFrameCount == 30) {
+          long endTimeMillis = System.currentTimeMillis();
+          double secs = (endTimeMillis - startTimeMillis) / 1000.0;
+          double fps  = 30.0 / secs;
+          double ppf  = tileSize * tileSize * 2;
+          double mpps = ppf * fps / 1000000.0;
+          System.err.println("fps: " + fps + " polys/frame: " + ppf + " million polys/sec: " + mpps +
+                             " DrawElements calls/frame: " + (numDrawElementsCalls / 30));
+          profiledFrameCount = 0;
+          numDrawElementsCalls = 0;
+          startTimeMillis = System.currentTimeMillis();
+        }
+      } else {
+        startTimeMillis = System.currentTimeMillis();
+        firstProfiledFrame = false;
+      }
+    }
+  }
+
+  public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
+
+  // Unused routines
+  public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
+
+  private void allocateBigArray(GL2 gl) {
+    bigArraySystem = setupBuffer(ByteBuffer.allocateDirect(bufferSize));
+
+    int[] tmp = new int[1];
+    gl.glGenBuffers(1, tmp, 0);
+    bigBufferObject = tmp[0];
+    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, bigBufferObject);
+    // Initialize data store of buffer object
+    gl.glBufferData(GL.GL_ARRAY_BUFFER, bufferSize, (Buffer) null, GL.GL_DYNAMIC_DRAW);
+    bigArrayVBOBytes = gl.glMapBuffer(GL.GL_ARRAY_BUFFER, GL2.GL_WRITE_ONLY);
+    bigArrayVBO = setupBuffer(bigArrayVBOBytes);
+    gl.glUnmapBuffer(GL.GL_ARRAY_BUFFER);
+    // Unbind buffer; will be bound again in main loop
+    gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+    
+    float megabytes = (bufferSize / 1000000.f);
+    System.err.println("Allocated " + megabytes + " megabytes of fast memory");
+  }
+
+  private FloatBuffer setupBuffer(ByteBuffer buf) {
+    buf.order(ByteOrder.nativeOrder());
+    return buf.asFloatBuffer();
+  }
+
+  private FloatBuffer sliceBuffer(FloatBuffer array,
+                                  int sliceStartIndex, int sliceLength) {
+    array.position(sliceStartIndex);
+    FloatBuffer ret = array.slice();
+    array.position(0);
+    ret.limit(sliceLength);
+    return ret;
+  }
+
+  private void computeElements(GL2 gl) {
+    xyArray = new float[tileSize];
+    for (int i = 0; i < tileSize; i++) {
+      xyArray[i] = i / (tileSize - 1.0f) - 0.5f;
+    }
+
+    elements = new IntBuffer[tileSize - 1];
+    for (int i = 0; i < tileSize - 1; i++) {
+      elements[i] = IntBuffer.allocate(2 * STRIP_SIZE);
+      for (int j = 0; j < 2 * STRIP_SIZE; j += 2) {
+        elements[i].put(j,    i      * STRIP_SIZE + (j / 2));
+        elements[i].put(j+1, (i + 1) * STRIP_SIZE + (j / 2));
+      }
+    }
+
+    // Create element array buffer
+    IntBuffer linearElements = IntBuffer.allocate((tileSize - 1) * (2 * STRIP_SIZE));
+    int idx = 0;
+    for (int i = 0; i < tileSize - 1; i++) {
+      for (int j = 0; j < 2 * STRIP_SIZE; j += 2) {
+        linearElements.put(idx++,  i      * STRIP_SIZE + (j / 2));
+        linearElements.put(idx++, (i + 1) * STRIP_SIZE + (j / 2));
+      }
+    }
+    int[] tmp = new int[1];
+    gl.glGenBuffers(1, tmp, 0);
+    elementBufferObject = tmp[0];
+    gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, elementBufferObject);
+    gl.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER,
+                       linearElements.remaining() * BufferUtil.SIZEOF_INT,
+                       linearElements,
+                       GL.GL_STATIC_DRAW);
+    gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
+  }
+
+  private static void runExit(final Animator animator) {
+    // Note: calling System.exit() synchronously inside the draw,
+    // reshape or init callbacks can lead to deadlocks on certain
+    // platforms (in particular, X11) because the JAWT's locking
+    // routines cause a global AWT lock to be grabbed. Run the
+    // exit routine in another thread.
+    new Thread(new Runnable() {
+        public void run() {
+          animator.stop();
+          System.exit(0);
+        }
+      }).start();
+  }
+}