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, 1346 insertions, 0 deletions

diff --git a/src/demos/infiniteShadowVolumes/InfiniteShadowVolumes.java b/src/demos/infiniteShadowVolumes/InfiniteShadowVolumes.java
new file mode 100644
index 0000000..dde5135
--- /dev/null
+++ b/src/demos/infiniteShadowVolumes/InfiniteShadowVolumes.java
@@ -0,0 +1,1346 @@
+/*
+ * 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.infiniteShadowVolumes;
+
+import com.sun.opengl.util.gl2.GLUT;
+import demos.common.Demo;
+import demos.common.DemoListener;
+import demos.util.MD2;
+import gleem.BSphere;
+import gleem.BSphereProvider;
+import gleem.CameraParameters;
+import gleem.ExaminerViewer;
+import gleem.HandleBoxManip;
+import gleem.ManipManager;
+import gleem.MouseButtonHelper;
+import gleem.linalg.Mat4f;
+import gleem.linalg.Rotf;
+import gleem.linalg.Vec3f;
+import gleem.linalg.Vec4f;
+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.io.IOException;
+import java.nio.FloatBuffer;
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2ES1;
+import javax.media.opengl.GL2;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.awt.AWTGLAutoDrawable;
+import javax.media.opengl.awt.GLCanvas;
+import javax.media.opengl.glu.GLU;
+
+
+
+/**
+  Infinite shadow volumes are described in the paper 
+  "Practical and Robust Stenciled Shadow Volumes for
+   Hardware-Accelerated Rendering" which can be found
+   online at: <P>
+   
+ <a href = "http://developer.nvidia.com/view.asp?IO=robust_shadow_volumes">http://developer.nvidia.com/view.asp?IO=robust_shadow_volumes</a><P>
+
+  This code is intended to illustrate the technique.  It
+  is not optimized for performance. <P>
+
+  Cass Everitt <BR>
+  04-04-2002 <P>
+
+  Ported to Java by Kenneth Russell
+*/
+
+public class InfiniteShadowVolumes extends Demo {
+  public static void main(String[] args) {
+    GLCapabilities caps = new GLCapabilities(null);
+    caps.setStencilBits(16);
+    final GLCanvas canvas = new GLCanvas(caps);
+    InfiniteShadowVolumes demo = new InfiniteShadowVolumes();
+    canvas.addGLEventListener(demo);
+
+    demo.setDemoListener(new DemoListener() {
+        public void shutdownDemo() {
+          runExit();
+        }
+        public void repaint() {
+          canvas.repaint();
+        }
+      });
+    
+    Frame frame = new Frame("Infinite Stenciled Shadow Volumes");
+    frame.setLayout(new BorderLayout());
+    canvas.setSize(512, 512);
+    frame.add(canvas, BorderLayout.CENTER);
+    frame.pack();
+    frame.setVisible(true);
+    canvas.requestFocus();
+
+    frame.addWindowListener(new WindowAdapter() {
+        public void windowClosing(WindowEvent e) {
+          runExit();
+        }
+      });
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  public void shutdownDemo() {
+    ManipManager.getManipManager().unregisterWindow((AWTGLAutoDrawable) drawable);
+    drawable.removeGLEventListener(this);
+    super.shutdownDemo();
+  }
+
+  static class Model {
+    Model() {
+      frame_num = 0;
+      frame_incr = 0.25f;
+      draw = true;
+      ambient =  new Vec4f(0.1f, 0.1f, 0.1f, 1);
+      diffuse =  new Vec4f(0.8f, 0,    0,    1);
+      specular = new Vec4f(0.6f, 0.6f, 0.6f, 1);
+      shininess = 64;
+    }
+
+    MD2.Model mod;
+    MD2.Frame interp_frame;
+    float frame_num;
+    float frame_incr;
+
+    Vec4f ambient;
+    Vec4f diffuse;
+    Vec4f specular;
+    float shininess;
+    boolean draw;
+  };
+
+  // You can load multiple models and 
+  // position them independently.  If they're
+  // quake2 models you can animate them as well.  
+
+  private static final int MAX_MODELS = 4;
+  private Model[] m = new Model[MAX_MODELS];
+  private int curr_model = 0;
+  private int num_models = 0;
+
+  // selector for the current view mode
+  private static final int CAMERA_VIEW = 0;
+  private static final int SCENE_VIEW  = 1;
+  private static final int CLIP_VIEW   = 2;
+  private int curr_view  = CAMERA_VIEW;
+
+  private GLU  glu  = new GLU();
+  private GLUT glut = new GLUT();
+
+  private GLAutoDrawable drawable;
+  private ExaminerViewer viewer;
+  private HandleBoxManip objectManip;
+  private HandleBoxManip lightManip;
+  private Mat4f objectManipXform;
+  private Mat4f lightManipXform;
+  int faceDisplayList;
+  int wallTexObject;
+
+  private boolean[] b = new boolean[256];
+
+  Vec4f light_position = new Vec4f(0,0,0,1);
+  float light_object_scale = 1;
+  float volume_alpha = .1f;
+  float room_ambient = .3f;
+
+  boolean doViewAll = true;
+
+  private boolean enableDepthClampNV;
+  private boolean toggleDepthClampNV;
+  private boolean animateContinually;
+  private boolean animateForward;
+  private boolean animateBackward;
+  private boolean hideCurrentModel;
+  private boolean toggleWireframe;
+
+  public void init(GLAutoDrawable drawable) {
+    GL2 gl = drawable.getGL().getGL2();
+
+    gl.glClearStencil(128);
+    //glEnable(GL2.GL_DEPTH_CLAMP_NV);
+    gl.glEnable(GL2.GL_DEPTH_TEST);
+    gl.glDepthFunc(GL2.GL_LESS);
+    gl.glEnable(GL2.GL_NORMALIZE);
+    gl.glLightModeli(GL2.GL_LIGHT_MODEL_TWO_SIDE, GL2.GL_FALSE);
+    float[] ambient = new float[] {0.3f, 0.3f, 0.3f, 1};
+    gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient, 0);
+    faceDisplayList = gl.glGenLists(1);
+    gl.glNewList(faceDisplayList, GL2.GL_COMPILE);
+    drawMesh(gl, 20, 40);
+    gl.glEndList();
+
+    int[] tmp = new int[1];
+    gl.glGenTextures(1, tmp, 0);
+    wallTexObject = tmp[0];
+    gl.glBindTexture(GL2.GL_TEXTURE_2D, wallTexObject);
+    gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_GENERATE_MIPMAP, GL2.GL_TRUE);
+    gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_LINEAR_MIPMAP_LINEAR);
+    gl.glTexParameteri(GL2.GL_TEXTURE_2D, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_LINEAR);
+
+    float[] tex = new float[32*32];
+    for(int i=0; i < 32; i++) {
+      for(int j=0; j < 32; j++) {
+        if ((i>>4 ^ j>>4) != 0)
+          tex[i+j*32] = 1;
+        else
+          tex[i+j*32] = .9f;
+      }
+    }
+    gl.glTexImage2D(GL2.GL_TEXTURE_2D, 0, GL2.GL_RGBA, 32, 32, 0, GL2.GL_LUMINANCE, GL2.GL_FLOAT, FloatBuffer.wrap(tex));
+      
+    initModel();
+    
+    b['S'] = true; // no silhouette outlines
+    b['v'] = true; // no volume drawing
+    b['I'] = true; // use infinite far plane
+    b['L'] = true; // use local light for shadowing
+
+    doViewAll = true;
+
+    //TODO drawable has no addKeyListener
+//    drawable.addKeyListener(new KeyAdapter() {
+//        public void keyTyped(KeyEvent e) {
+//          dispatchKey(e.getKeyChar());
+//          demoListener.repaint();
+//        }
+//      });
+
+    // Register the window with the ManipManager
+    ManipManager manager = ManipManager.getManipManager();
+    manager.registerWindow((AWTGLAutoDrawable) drawable);
+    this.drawable = drawable;
+
+    objectManip = new HandleBoxManip();
+    manager.showManipInWindow(objectManip, (AWTGLAutoDrawable) drawable);
+    objectManip.setTranslation(new Vec3f(0, 0, -2));
+    objectManip.setRotation(new Rotf(new Vec3f(1, 0, 0), (float) Math.toRadians(-90)));
+
+    lightManip = new HandleBoxManip();
+    manager.showManipInWindow(lightManip, (AWTGLAutoDrawable) drawable);
+    lightManip.setTranslation(new Vec3f(0.5f, 0.5f, -1));
+    lightManip.setGeometryScale(new Vec3f(0.1f, 0.1f, 0.1f));
+
+    viewer = new ExaminerViewer(MouseButtonHelper.numMouseButtons());
+    viewer.attach((AWTGLAutoDrawable) drawable, new BSphereProvider() {
+        public BSphere getBoundingSphere() {
+          return new BSphere(objectManip.getTranslation(), 1.0f);
+        }
+      });
+    viewer.setZNear(1.0f);
+    viewer.setZFar(100.0f);
+    viewer.setOrientation(new Rotf(new Vec3f(0, 1, 0), (float) Math.toRadians(15)));
+
+    // FIXME
+    //      glutAddMenuEntry("mouse controls view [1]", '1');
+    //      glutAddMenuEntry("mouse controls model  [2]", '2');
+    //      glutAddMenuEntry("mouse controls light  [3]", '3');
+    //      glutAddMenuEntry("mouse controls room   [4]", '4');
+    //      glutAddMenuEntry("enable depth clamp [!]", '!');
+    //      glutAddMenuEntry("disable depth clamp [~]", '~');
+    //      glutAddMenuEntry("start animation [ ]", ' ');
+    //      glutAddMenuEntry("step animation forward [a]", 'a');
+    //      glutAddMenuEntry("step animation backward [b]", 'b');
+    //      glutAddMenuEntry("toggle drawing silhouette [S]", 'S');
+    //      glutAddMenuEntry("toggle drawing shadow  [s]", 's');
+    //      glutAddMenuEntry("toggle drawing visible shadow volume [v]", 'v');
+    //      glutAddMenuEntry("toggle drawing model geometry[m]", 'm');
+
+    //      glutAddMenuEntry("increase shadow volume alpha [;]", ';');
+    //      glutAddMenuEntry("decrease shadow volume alpha [:]", ':');
+
+    //      glutAddMenuEntry("next model [,]", ',');
+    //      glutAddMenuEntry("hide current model [.]", '.');
+
+    //      glutAddMenuEntry("toggle view frustum clip planes [X]", 'X');
+
+    //      glutAddMenuEntry("camera view [5]", '5');
+    //      glutAddMenuEntry("scene view [6]", '6');
+    //      glutAddMenuEntry("clipspace view [7]", '7');
+
+    //      glutAddMenuEntry("enable depth clamp [!]", '!');
+    //      glutAddMenuEntry("disable depth clamp [~]", '~');
+
+    //      glutAddMenuEntry("increase light size [n]", 'n');
+    //      glutAddMenuEntry("decrease light size [N]", 'N');
+
+    //      glutAddMenuEntry("move near plane in [[]", '[');
+    //      glutAddMenuEntry("move near plane out []]", ']');
+    //      glutAddMenuEntry("move far plane in [{]", '[');
+    //      glutAddMenuEntry("move far plane out [}]", ']');
+
+    //      glutAddMenuEntry("toggle local/infinite light [L]", 'L');
+
+    //      glutAddMenuEntry("hide room [R]", 'R');
+
+    //      glutAddMenuEntry("view all with camera [c]", 'c');
+
+    //      glutAddMenuEntry("quit [<esc>]", 27);
+  }
+
+  public void dispose(GLAutoDrawable drawable) {
+    GL2 gl = drawable.getGL().getGL2();
+
+    gl.glDeleteLists(faceDisplayList, 1);
+    faceDisplayList=0;
+
+    int[] tmp = new int[1];
+    tmp[0]=wallTexObject;
+    gl.glDeleteTextures(1, tmp, 0);
+    wallTexObject = 0;
+
+    objectManip = null;
+    lightManip = null;
+    viewer = null;
+  }
+
+  public void display(GLAutoDrawable drawable) {
+    GL2 gl = drawable.getGL().getGL2();
+
+    gl.glMatrixMode(GL2.GL_PROJECTION);
+    gl.glLoadIdentity();
+
+    if (doViewAll) {
+      viewer.viewAll(gl);
+      doViewAll = false;
+    }
+
+    objectManipXform = objectManip.getTransform();
+    lightManipXform  = lightManip.getTransform();
+
+    // TODO GL_DEPTH_CLAMP_NV not available
+//    if (toggleDepthClampNV) {
+//      if (enableDepthClampNV) {
+//        gl.glEnable(GL2.GL_DEPTH_CLAMP_NV);
+//      } else {
+//        gl.glDisable(GL2.GL_DEPTH_CLAMP_NV);
+//      }
+//      toggleDepthClampNV = false;
+//    }
+
+    if (b[' ']) {
+      animateForward = true;
+    }
+
+    if (animateForward) {
+      Model mm = m[curr_model];
+      mm.frame_num += mm.frame_incr;
+      if (mm.frame_num >= mm.mod.f.length)
+        mm.frame_num = 0;
+      interpolate_frame();
+      animateForward = false;
+    }
+
+    if (animateBackward) {
+      Model mm = m[curr_model];
+      mm.frame_num -= mm.frame_incr;
+      if (mm.frame_num < 0)
+        mm.frame_num += mm.mod.f.length;
+      interpolate_frame();
+      animateBackward = false;
+    }
+
+    if (hideCurrentModel) {
+      gl.glNewList(faceDisplayList, GL2.GL_COMPILE);
+      drawMesh(gl, 20, 40);
+      gl.glEndList();
+      hideCurrentModel = false;
+    }
+
+    if (toggleWireframe) {
+      if(b['w'])
+        gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
+      else
+        gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL);
+    }
+
+    if(b['I']) {
+      // push far plane to infinity
+      switch (curr_view) {
+      case CAMERA_VIEW:
+        viewer.update(gl);
+        // Undo perspective effects of ExaminerViewer
+        gl.glMatrixMode(GL2.GL_PROJECTION);
+        gl.glLoadIdentity();
+        applyInfinitePerspective(gl, viewer);
+        break;
+
+      case SCENE_VIEW:
+        applyInfinitePerspective(gl, viewer);
+        // FIXME: do we need more primitives in the ExaminerViewer class?
+        //            scenecam.apply_inverse_transform();
+        break;
+
+      case CLIP_VIEW:
+        applyInfinitePerspective(gl, viewer);
+        // FIXME
+        //            clipcam.apply_inverse_transform();
+        gl.glScalef(10,10,-10);
+        applyInfinitePerspective(gl, viewer);
+        break;
+
+      default:
+        break;
+      }
+    } else {
+      switch (curr_view) {
+      case CAMERA_VIEW:
+        viewer.update(gl);
+        break;
+
+      case SCENE_VIEW:
+        applyInfinitePerspective(gl, viewer);
+        // FIXME
+        //            scenecam.apply_inverse_transform();
+        break;
+
+      case CLIP_VIEW:
+        applyInfinitePerspective(gl, viewer);
+        // FIXME
+        //            clipcam.apply_inverse_transform();
+        gl.glScalef(10,10,-10);
+        // FIXME
+        //            reshaper.apply_projection();
+        break;
+
+      default:
+        break;
+      }
+    }
+
+    gl.glMatrixMode(GL2.GL_MODELVIEW);
+
+    // FIXME
+    if (b['X']) {
+      gl.glLoadIdentity();
+      if(b['I']) {
+        // FIXME
+        applyInfinitePerspectiveInverse(gl, viewer);
+      } else {
+        // FIXME
+        //          reshaper.apply_projection_inverse();
+      }
+      double[] pos_x = new double[] {-1, 0, 0, 1};
+      double[] neg_x = new double[] { 1, 0, 0, 1};
+      double[] pos_y = new double[] { 0,-1, 0, 1};
+      double[] neg_y = new double[] { 0, 1, 0, 1};
+      double[] pos_z = new double[] { 0, 0,-1, 1};
+      double[] neg_z = new double[] { 0, 0, 1, 1};
+      gl.glClipPlane(GL2.GL_CLIP_PLANE0, pos_x, 0);
+      gl.glClipPlane(GL2.GL_CLIP_PLANE1, neg_x, 0);
+      gl.glClipPlane(GL2.GL_CLIP_PLANE2, pos_y, 0);
+      gl.glClipPlane(GL2.GL_CLIP_PLANE3, neg_y, 0);
+      gl.glClipPlane(GL2.GL_CLIP_PLANE4, pos_z, 0);
+      gl.glClipPlane(GL2.GL_CLIP_PLANE5, neg_z, 0);
+      gl.glEnable(GL2.GL_CLIP_PLANE0);
+      gl.glEnable(GL2.GL_CLIP_PLANE1);
+      gl.glEnable(GL2.GL_CLIP_PLANE2);
+      gl.glEnable(GL2.GL_CLIP_PLANE3);
+      gl.glEnable(GL2.GL_CLIP_PLANE4);
+      gl.glEnable(GL2.GL_CLIP_PLANE5);
+      gl.glLoadIdentity();
+    }
+
+    gl.glPushMatrix();
+    // FIXME
+    //      camera.apply_inverse_transform();
+    //      light.apply_transform();
+    gl.glMultMatrixf(getData(lightManipXform), 0);
+    gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, getData(light_position), 0);
+    gl.glPopMatrix();
+    gl.glEnable(GL2.GL_LIGHT0);
+
+    // FIXME
+    gl.glPushMatrix();
+    //      gl.glLoadIdentity();
+    //      camera.apply_inverse_transform();
+
+    gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT | GL2.GL_STENCIL_BUFFER_BIT);
+
+    ManipManager.getManipManager().updateCameraParameters((AWTGLAutoDrawable) drawable, viewer.getCameraParameters());
+    ManipManager.getManipManager().render((AWTGLAutoDrawable) drawable, gl);
+
+    if (!b['R']) {
+      drawRoom(gl, false);
+    }
+
+    if (!b['m']) {
+      for (int i = 0; i < num_models; i++)
+        if (m[i].draw)
+          drawModel(gl, i, false);
+    }
+
+    if (b['X']) {
+      gl.glDisable(GL2.GL_CLIP_PLANE0);
+      gl.glDisable(GL2.GL_CLIP_PLANE1);
+      gl.glDisable(GL2.GL_CLIP_PLANE2);
+      gl.glDisable(GL2.GL_CLIP_PLANE3);
+      gl.glDisable(GL2.GL_CLIP_PLANE4);
+      gl.glDisable(GL2.GL_CLIP_PLANE5);
+    }
+
+    if (!b['s']) {
+      for (int i = 0; i < num_models; i++)
+        if (m[i].draw)
+          drawShadowVolumeToStencil(gl, i);
+    }
+
+    // Be aware that this can cause some multipass artifacts
+    // due to invariance issues.
+    if (b['X']) {
+      gl.glEnable(GL2.GL_CLIP_PLANE0);
+      gl.glEnable(GL2.GL_CLIP_PLANE1);
+      gl.glEnable(GL2.GL_CLIP_PLANE2);
+      gl.glEnable(GL2.GL_CLIP_PLANE3);
+      gl.glEnable(GL2.GL_CLIP_PLANE4);
+      gl.glEnable(GL2.GL_CLIP_PLANE5);
+    }
+    if (!b['d']) {
+      if (!b['R'])
+        drawRoom(gl, true);
+      if (!b['m'])
+        for (int i = 0; i < num_models; i++)
+          if (m[i].draw)
+            drawModel(gl, i, true);
+    }
+
+    if(!b['S']) {
+      for (int i = 0; i < num_models; i++)
+        if (m[i].draw)
+          drawPossibleSilhouette(gl, i);
+    }
+
+    if (!b['v']) {
+      for (int i = 0; i < num_models; i++)
+        if (m[i].draw)
+          drawShadowVolumeToColor(gl, i);
+    }
+
+    // Be aware that this can cause some multipass artifacts
+    // due to invariance issues.
+    if (b['X']) {
+      gl.glDisable(GL2.GL_CLIP_PLANE0);
+      gl.glDisable(GL2.GL_CLIP_PLANE1);
+      gl.glDisable(GL2.GL_CLIP_PLANE2);
+      gl.glDisable(GL2.GL_CLIP_PLANE3);
+      gl.glDisable(GL2.GL_CLIP_PLANE4);
+      gl.glDisable(GL2.GL_CLIP_PLANE5);
+    }
+
+    drawLight(gl);
+
+    gl.glPopMatrix();
+
+    // In an "external" viewing mode, show the camera's view volume
+    // as a yellow wireframe cube or frustum.
+    if (curr_view != CAMERA_VIEW) {
+      gl.glPushMatrix();
+      if (b['I']) {
+        // FIXME
+        applyInfinitePerspectiveInverse(gl, viewer);
+      } else {
+        // FIXME
+        //          reshaper.apply_projection_inverse();
+      }
+      gl.glColor3f(.75f,.75f,0);
+      gl.glLineWidth(3);
+      glut.glutWireCube(2);
+      gl.glLineWidth(1);
+      gl.glPopMatrix();
+    }
+
+    if (b[' ']) {
+      // Animating continually. Schedule another repaint soon.
+      demoListener.repaint();
+    }
+  }
+
+  // Unused routines
+  public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
+  public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
+
+  private void dispatchKey(char k) {
+    b[k] = ! b[k];
+    if (k==27 || k=='q') {
+      shutdownDemo();
+      return;
+    }
+
+    if(';' == k) {
+      volume_alpha *= 1.1f;
+    }
+    if(':' == k) {
+      volume_alpha /= 1.1f;
+    }
+
+    if('\'' == k) {
+      room_ambient += .025f;
+    }
+    if('"' == k) {
+      room_ambient -= .025f;
+    }
+
+    if(',' == k) {
+      curr_model++;
+      curr_model %= num_models;
+      // FIXME
+      //        key('2',0,0);
+    }
+    if('.' == k) {
+      m[curr_model].draw = ! m[curr_model].draw;
+    }
+    if('w' == k) {
+      toggleWireframe = true;
+    }
+    if('1' == k) {
+      // FIXME
+      /*
+        curr_manip = 1;
+        camera.disable();
+        clipcam.disable();
+        scenecam.disable();
+        if(curr_view == 0)
+        camera.enable();
+        else if(curr_view == 1)
+        scenecam.enable();
+        else
+        clipcam.enable();
+        for(int i=0; i < num_models; i++)
+        object[i].disable();
+        light.disable();
+        room.disable();
+      */
+    }
+    if('2' == k) {
+      // FIXME
+      /*
+        curr_manip = 2;
+        camera.disable();
+        clipcam.disable();
+        scenecam.disable();
+        light.disable();
+        for(int i=0; i < num_models; i++)
+        object[i].disable();
+        object[curr_model].enable();
+        room.disable();
+      */
+    }
+    if('3' == k) {
+      // FIXME
+      /*
+        curr_manip = 3;
+        camera.disable();
+        clipcam.disable();
+        scenecam.disable();
+        light.enable();
+        for(int i=0; i < num_models; i++)
+        object[i].disable();
+        room.disable();
+      */
+    }
+    if('4' == k) {
+      // FIXME
+      /*
+        curr_manip = 4;
+        camera.disable();
+        clipcam.disable();
+        scenecam.disable();
+        light.disable();
+        for(int i=0; i < num_models; i++)
+        object[i].disable();
+        room.enable();
+      */
+    }
+
+    if('5' == k) {
+      // FIXME
+      /*
+        curr_view = 0;
+        if(curr_manip == 1)
+        key('1',0,0);
+      */
+    }
+
+    if('6' == k) {
+      // FIXME
+      /*
+        curr_view = 1;
+        if(curr_manip == 1)
+        key('1',0,0);
+      */
+    }
+
+    if('7' == k) {
+      // FIXME
+      /*
+        curr_view = 2;
+        if(curr_manip == 1)
+        key('1',0,0);
+      */
+    }
+
+    if('[' == k) {
+      // FIXME: correct?
+      viewer.setZNear(viewer.getZNear() / 2);
+      //        reshaper.zNear /= 2;
+    }
+    if(']' == k) {
+      // FIXME: correct?
+      viewer.setZNear(viewer.getZNear() * 2);
+      //        reshaper.zNear *= 2;
+    }
+
+    if('{' == k) {
+      // FIXME: correct?
+      viewer.setZFar(viewer.getZFar() / 2);
+      //        reshaper.zFar /= 2;
+    }
+    if('}' == k) {
+      // FIXME: correct?
+      viewer.setZFar(viewer.getZFar() * 2);
+      //        reshaper.zFar *= 2;
+    }
+
+    if('!' == k) {
+      enableDepthClampNV = true;
+      toggleDepthClampNV = true;
+    }
+    if('~' == k) {
+      enableDepthClampNV = false;
+      toggleDepthClampNV = true;
+    }
+
+    if('a' == k) {
+      animateForward = true;
+    }
+
+    if('b' == k) {
+      animateBackward = true;
+    }
+
+    if('.' == k) {
+      hideCurrentModel = true;
+    }
+
+    if('n' == k) {
+      light_object_scale *= 1.1f;
+    }
+    if('N' == k) {
+      light_object_scale /= 1.1f;
+    }
+
+    if('L' == k) {
+      if(b[k])
+        light_position.set(0,0,0,1);
+      else
+        light_position.set(0.25f, 0.25f, 1, 0);
+    }
+
+    if ('c' == k) {
+      doViewAll = true;
+    }
+  }
+
+  private void initModel() {
+    int i = 0;
+
+    try {
+      MD2.Model mod = MD2.loadMD2(getClass().getClassLoader().getResourceAsStream("demos/data/models/knight.md2"));
+      m[i] = new Model();
+      m[i].mod = mod;
+      m[i].interp_frame = (MD2.Frame) m[i].mod.f[0].clone();
+      m[i].ambient.componentMul(m[i].diffuse);
+      i++;
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+
+    num_models = i;
+  }
+
+  // interpolate between keyframes
+  private void interpolate_frame() {
+    float frac =  m[curr_model].frame_num - (float) Math.floor(m[curr_model].frame_num);
+    int f0_index = (int) Math.floor(m[curr_model].frame_num);
+    int f1_index = ((int) Math.ceil(m[curr_model].frame_num)) % m[curr_model].mod.f.length;
+    MD2.Frame f0 = m[curr_model].mod.f[f0_index];
+    MD2.Frame f1 = m[curr_model].mod.f[f1_index];
+
+    for (int i = 0; i < f0.pn.length; i++) {
+      MD2.PositionNormal pn  = m[curr_model].interp_frame.pn[i];
+      MD2.PositionNormal pn0 = f0.pn[i];
+      MD2.PositionNormal pn1 = f1.pn[i];
+
+      pn.x = (1-frac) * pn0.x + frac * pn1.x;
+      pn.y = (1-frac) * pn0.y + frac * pn1.y;
+      pn.z = (1-frac) * pn0.z + frac * pn1.z;
+      pn.nx = (1-frac) * pn0.nx + frac * pn1.nx;
+      pn.ny = (1-frac) * pn0.ny + frac * pn1.ny;
+      pn.nz = (1-frac) * pn0.nz + frac * pn1.nz;
+    }
+    
+    for (int i = 0; i < f0.triplane.length; i++) {
+      MD2.Plane p = m[curr_model].interp_frame.triplane[i];
+
+      MD2.computePlane(m[curr_model].interp_frame.pn[m[curr_model].mod.tri[i].v[0].pn_index], 
+                       m[curr_model].interp_frame.pn[m[curr_model].mod.tri[i].v[1].pn_index],
+                       m[curr_model].interp_frame.pn[m[curr_model].mod.tri[i].v[2].pn_index],
+                       p); 
+    }
+  }
+
+  // This routine draws the end caps (both local and infinite) for an
+  // occluder.  These caps are required for the zfail approach to work.
+  private void drawShadowVolumeEndCaps(GL2 gl, int mindex) {
+    Vec4f olight = new Vec4f();
+
+    Mat4f ml = new Mat4f(objectManipXform);
+    ml.invertRigid();
+    ml = ml.mul(lightManipXform);
+    ml.xformVec(light_position, olight);
+
+    MD2.PositionNormal[] vpn = m[mindex].interp_frame.pn;
+
+    gl.glPushMatrix();
+    gl.glMultMatrixf(getData(objectManipXform), 0);
+    gl.glBegin(GL2.GL_TRIANGLES);
+    for (int i = 0; i < m[mindex].mod.tri.length; i++) {
+      if (m[mindex].mod.tri[i].kill)
+        continue;
+      MD2.Plane p = m[mindex].interp_frame.triplane[i];
+
+      boolean facing_light  = (( p.a * olight.get(0) + 
+                                 p.b * olight.get(1) +
+                                 p.c * olight.get(2) +
+                                 p.d * olight.get(3) ) >= 0 );
+
+      for (int j = 0; j < 3; j++) {
+        MD2.PositionNormal pn = vpn[m[mindex].mod.tri[i].v[j].pn_index];
+        if (facing_light)  // draw locally
+          gl.glVertex4f(pn.x, pn.y, pn.z, 1);
+        else              // draw at infinity
+          gl.glVertex4f(pn.x*olight.get(3) - olight.get(0),
+                        pn.y*olight.get(3) - olight.get(1),
+                        pn.z*olight.get(3) - olight.get(2),
+                        0);
+      }
+    }
+    gl.glEnd();
+    gl.glPopMatrix();
+  }
+
+  private void drawModel(GL2 gl, int mindex, boolean do_diffuse) {
+    MD2.PositionNormal[] vpn = m[mindex].interp_frame.pn;
+
+    float[] zero = new float[] {  0,  0,  0,  0};
+    float[] dim  = new float[] {.2f,.2f,.2f,.2f};
+    float[] diffuse = new float[4];
+    float[] specular = new float[4];
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT, getData(m[mindex].ambient), 0);
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE, getData(m[mindex].diffuse), 0);
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, getData(m[mindex].specular), 0);
+    gl.glMaterialf(GL2.GL_FRONT_AND_BACK, GL2.GL_SHININESS, m[mindex].shininess);
+    if (!do_diffuse) {
+      gl.glGetLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, dim, 0);
+      gl.glGetLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, specular, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, zero, 0);
+    } else {
+      gl.glBlendFunc(GL2.GL_ONE, GL2.GL_ONE);
+      gl.glEnable(GL2.GL_BLEND);
+      gl.glStencilFunc(GL2.GL_EQUAL, 128, ~0);
+      gl.glStencilOp(GL2.GL_KEEP, GL2.GL_KEEP, GL2.GL_KEEP);
+      gl.glEnable(GL2.GL_STENCIL_TEST);
+      gl.glDepthFunc(GL2.GL_EQUAL);
+    }
+    gl.glPushMatrix();
+    gl.glMultMatrixf(getData(objectManipXform), 0);
+    gl.glEnable(GL2.GL_LIGHTING);
+
+    gl.glPolygonOffset(0,-2);
+    gl.glEnable(GL2.GL_POLYGON_OFFSET_FILL);
+
+    gl.glBegin(GL2.GL_TRIANGLES);
+    {
+      for (int i = 0; i < m[mindex].mod.tri.length; i++) {
+        for(int j=0; j < 3; j++) {
+          MD2.PositionNormal pn = vpn[m[mindex].mod.tri[i].v[j].pn_index];
+          gl.glNormal3f(pn.nx, pn.ny, pn.nz);
+          gl.glVertex4f(pn.x, pn.y, pn.z, 1);
+        }
+      }
+    }
+    gl.glEnd();
+
+    gl.glDisable(GL2.GL_POLYGON_OFFSET_FILL);
+
+    gl.glDisable(GL2.GL_LIGHTING);
+    gl.glPopMatrix();
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE,  new float[] { 0.8f, 0.8f, 0.8f, 1}, 0);
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, new float[] { 0.3f, 0.3f, 0.3f, 1}, 0);
+
+    if (!do_diffuse) {
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, specular, 0);
+    } else {
+      gl.glDisable(GL2.GL_BLEND);
+      //glDisable(GL2.GL_STENCIL_TEST);
+      gl.glStencilFunc(GL2.GL_ALWAYS, 128, ~0);
+      gl.glStencilOp(GL2.GL_KEEP, GL2.GL_KEEP, GL2.GL_KEEP);
+
+      gl.glDepthFunc(GL2.GL_LESS);
+    }
+  }
+
+  // This is for drawing the walls of the room.
+  private void drawMesh(GL2 gl, float size, int tess) {
+    float hsize = size/2;
+    float delta = size/(tess-1);
+
+    gl.glPushMatrix();
+    gl.glTranslatef(-hsize, -hsize, hsize);
+    
+    gl.glNormal3f(0,0,-1);
+
+    float x = 0;
+    for(int i=0; i < tess-1; i++) {
+      float y = 0;
+      gl.glBegin(GL2.GL_QUAD_STRIP);
+      for(int j=0; j < tess; j++) {
+        gl.glTexCoord2f(      x, y);
+        gl.glVertex2f  (      x, y);
+        gl.glTexCoord2f(x+delta, y);
+        gl.glVertex2f  (x+delta, y);
+        y += delta;
+      }
+      gl.glEnd();
+      x += delta;
+    }
+    gl.glPopMatrix();
+  }
+
+  private void drawCube(GL2 gl) {
+    gl.glBindTexture(GL2.GL_TEXTURE_2D, wallTexObject);
+    gl.glEnable(GL2.GL_TEXTURE_2D);
+    gl.glPushMatrix();
+    // FIXME
+    //      room.apply_transform();
+    gl.glCallList(faceDisplayList);
+    gl.glRotatef(90, 1, 0, 0);
+    gl.glCallList(faceDisplayList);
+    gl.glRotatef(90, 1, 0, 0);
+    gl.glCallList(faceDisplayList);
+    gl.glRotatef(90, 1, 0, 0);
+    gl.glCallList(faceDisplayList);
+    gl.glRotatef(90, 1, 0, 0);
+    gl.glRotatef(90, 0, 1, 0);
+    gl.glCallList(faceDisplayList);
+    gl.glRotatef(180, 0, 1, 0);
+    gl.glCallList(faceDisplayList);
+    gl.glPopMatrix();
+    gl.glDisable(GL2.GL_TEXTURE_2D);
+  }
+
+  private void drawRoom(GL2 gl, boolean do_diffuse) {
+    float[] zero = new float[] {0,0,0,0};
+    float[] a = new float[4];
+    a[0] = room_ambient;
+    a[1] = room_ambient;
+    a[2] = room_ambient;
+    a[3] = 1;
+
+    float[] d1 = new float[] {.1f,.1f,.1f,.1f};
+    float[] d2 = new float[] {.7f,.7f,.7f,.7f};
+    float[] s  = new float[] {.7f,.7f,.7f,.7f};
+    float[] emission = new float[4];
+    float[] ambient  = new float[4];
+    float[] diffuse  = new float[4];
+    float[] specular = new float[4];
+
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_AMBIENT, a, 0);
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE,  new float[] {0.8f, 0.8f, 0.8f, 1}, 0);
+    gl.glMaterialfv(GL2.GL_FRONT_AND_BACK, GL2.GL_SPECULAR, new float[] {0.4f, 0.4f, 0.4f, 1}, 0);
+    gl.glMaterialf(GL2.GL_FRONT_AND_BACK, GL2.GL_SHININESS, 64.0f);
+
+    if (!do_diffuse) {
+      gl.glGetLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, d1, 0);
+      gl.glGetLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, specular, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, zero, 0);
+      gl.glStencilFunc(GL2.GL_ALWAYS, 128, ~0);
+    } else {
+      gl.glGetLightfv(GL2.GL_LIGHT0, GL2.GL_EMISSION, emission, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_EMISSION, zero, 0);
+      gl.glGetLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, zero, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, d2, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, s, 0);
+
+      gl.glBlendFunc(GL2.GL_ONE, GL2.GL_ONE);
+      gl.glEnable(GL2.GL_BLEND);
+      gl.glStencilFunc(GL2.GL_EQUAL, 128, ~0);
+      gl.glDepthFunc(GL2.GL_EQUAL);
+    }
+    gl.glPushMatrix();
+    gl.glTranslatef(0,9,0);
+    gl.glEnable(GL2.GL_LIGHTING);
+    gl.glStencilOp(GL2.GL_KEEP, GL2.GL_KEEP, GL2.GL_KEEP);
+    gl.glEnable(GL2.GL_STENCIL_TEST);
+
+    drawCube(gl);
+
+    gl.glStencilFunc(GL2.GL_ALWAYS, 128, ~0);
+    gl.glStencilOp(GL2.GL_KEEP, GL2.GL_KEEP, GL2.GL_KEEP);
+
+    gl.glDisable(GL2.GL_LIGHTING);
+    gl.glPopMatrix();
+    
+    if (!do_diffuse) {
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, diffuse, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_SPECULAR, specular, 0);
+    } else {
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_EMISSION, emission, 0);
+      gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, ambient, 0);
+
+      gl.glDisable(GL2.GL_BLEND);
+      gl.glDepthFunc(GL2.GL_LESS);
+    }
+  }
+    
+  // This routine draws the extruded "possible silhouette" edge.  The
+  // edge is extruded to infinity.
+
+  // The paper describes identifying silhouette edge loops.  The approach
+  // in this demo is to visit each edge, determine if it's a "possible silhouette"
+  // or not, and if it is, draw the extruded edge.   This approach is not
+  // as efficient, but it has the benefit of being extremely simple.
+
+  // This routine also doubles as the routine for drawing the local and ininite
+  // silhouette edges (when prim == GL_LINES).
+  private void drawShadowVolumeEdges(GL2 gl,
+                                     int mindex,
+                                     int prim,
+                                     boolean local,
+                                     boolean infinity) {
+    Vec4f olight = new Vec4f();
+
+    Mat4f ml = new Mat4f(objectManipXform);
+    ml.invertRigid();
+    ml = ml.mul(lightManipXform);
+    ml.xformVec(light_position, olight);
+
+    gl.glPushMatrix();
+    gl.glMultMatrixf(getData(objectManipXform), 0);
+
+    MD2.Frame f = m[mindex].interp_frame;
+
+    gl.glBegin(prim);
+    for (int i = 0; i < m[mindex].mod.edge.length; i++) {
+      MD2.WingedEdge we = m[mindex].mod.edge[i];
+      if (we.w[0] == -1 || m[mindex].mod.tri[we.w[0]].kill ||
+          we.w[1] == -1 || m[mindex].mod.tri[we.w[1]].kill )
+        continue;
+
+      MD2.Plane p0 = f.triplane[we.w[0]];
+      float f0 = ( p0.a * olight.get(0) + 
+                   p0.b * olight.get(1) +
+                   p0.c * olight.get(2) +
+                   p0.d * olight.get(3) );
+            
+      float f1 = -f0;
+      if(we.w[1] != -1) {
+        MD2.Plane p1 = f.triplane[we.w[1]];
+
+        f1 = ( p1.a * olight.get(0) + 
+               p1.b * olight.get(1) +
+               p1.c * olight.get(2) +
+               p1.d * olight.get(3) );
+      }
+
+      int[] edge = new int[2];
+
+      if(f0 >= 0 && f1 < 0) {
+        edge[0] = we.e[1];
+        edge[1] = we.e[0];
+      } else if(f1 >= 0 && f0 < 0) {
+        edge[0] = we.e[0];
+        edge[1] = we.e[1];
+      } else {
+        continue;
+      }
+        
+      MD2.PositionNormal pn0 = f.pn[edge[0]];
+      MD2.PositionNormal pn1 = f.pn[edge[1]];
+
+      if(prim == GL2.GL_QUADS || local) {
+        // local segment
+        gl.glVertex4f(pn0.x, pn0.y, pn0.z, 1);
+        gl.glVertex4f(pn1.x, pn1.y, pn1.z, 1);
+      }
+      if(prim == GL2.GL_QUADS || infinity) {
+        // segment projected to infinity
+        gl.glVertex4f(pn1.x*olight.get(3) - olight.get(0),
+                      pn1.y*olight.get(3) - olight.get(1),
+                      pn1.z*olight.get(3) - olight.get(2),
+                      0);
+        gl.glVertex4f(pn0.x*olight.get(3) - olight.get(0),
+                      pn0.y*olight.get(3) - olight.get(1),
+                      pn0.z*olight.get(3) - olight.get(2),
+                      0);
+      }
+    }
+    gl.glEnd();
+    gl.glPopMatrix();
+  }
+
+  private void drawShadowVolumeExtrudedEdges(GL2 gl, int mindex) {
+    drawShadowVolumeEdges(gl, mindex, GL2.GL_QUADS, true, true);
+  }
+
+  private void drawPossibleSilhouette(GL2 gl, int mindex) {
+    gl.glLineWidth(3);
+    gl.glColor3f(1,1,1);
+    drawShadowVolumeEdges(gl, mindex, GL2.GL_LINES, true, !b['-']);
+    gl.glLineWidth(1);
+  }
+
+  // Draw the shadow volume into the stencil buffer.
+  private void drawShadowVolumeToStencil(GL2 gl, int mindex) {
+    gl.glDepthFunc(GL2.GL_LESS);
+    gl.glDepthMask(false);
+
+    gl.glStencilFunc(GL2.GL_ALWAYS, 128, ~0);
+    gl.glEnable(GL2.GL_STENCIL_TEST);
+
+    gl.glEnable(GL2.GL_CULL_FACE);
+    gl.glCullFace(GL2.GL_FRONT);
+    gl.glStencilOp(GL2.GL_KEEP, GL2.GL_INCR, GL2.GL_KEEP);
+    gl.glColorMask(false, false, false, false);
+
+    drawShadowVolumeExtrudedEdges(gl, mindex);
+    drawShadowVolumeEndCaps(gl, mindex);
+
+    gl.glCullFace(GL2.GL_BACK);
+    gl.glStencilOp(GL2.GL_KEEP, GL2.GL_DECR, GL2.GL_KEEP);
+
+    drawShadowVolumeExtrudedEdges(gl, mindex);
+    drawShadowVolumeEndCaps(gl, mindex);
+
+    gl.glColorMask(true, true, true, true);
+    gl.glDisable(GL2.GL_CULL_FACE);
+
+    gl.glStencilFunc(GL2.GL_ALWAYS, 128, ~0);
+    gl.glStencilOp(GL2.GL_KEEP, GL2.GL_KEEP, GL2.GL_KEEP);
+
+    gl.glDepthMask(true);
+    gl.glDepthFunc(GL2.GL_LESS);
+  }
+
+  // Draw the shadow volume into the color buffer.
+  private void drawShadowVolumeToColor(GL2 gl, int mindex) {
+    gl.glDepthFunc(GL2.GL_LESS);
+    gl.glDepthMask(false);
+
+    gl.glEnable(GL2.GL_BLEND);
+    gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
+
+    gl.glColor4f(1,1,1,.7f * volume_alpha);
+    drawShadowVolumeEndCaps(gl, mindex);
+    gl.glColor4f(1,1,.7f,.15f * volume_alpha);
+    drawShadowVolumeExtrudedEdges(gl, mindex);
+
+    gl.glDepthMask(true);
+    gl.glDepthFunc(GL2.GL_LESS);
+    gl.glDisable(GL2.GL_BLEND);
+  }
+
+  // Draw an icon to show where the local light is
+  // or in what direction the infinite light is pointing. 
+  private void drawLight(GL2 gl) {
+    gl.glColor3f(1,1,0);
+    gl.glPushMatrix();
+    gl.glMultMatrixf(getData(lightManipXform), 0);
+    gl.glScalef(light_object_scale, light_object_scale, light_object_scale);
+    if (b['L']) {
+      glut.glutSolidSphere(.01f, 20, 10);
+    } else {
+      Vec3f ldir = new Vec3f(light_position.get(0),
+                             light_position.get(1),
+                             light_position.get(2));
+      Rotf r = new Rotf(new Vec3f(0,0,1), ldir);
+      Mat4f m = new Mat4f();
+      m.makeIdent();
+      m.setRotation(r);
+      m = m.mul(perspectiveInverse(30, 1, 0.001f, 0.04f));
+      gl.glRotatef(180, 1, 0, 0);
+      gl.glTranslatef(0,0,-0.02f);
+      gl.glMultMatrixf(getData(m), 0);
+      glut.glutSolidCube(2);
+    }
+    gl.glPopMatrix();
+  }
+
+  // The infinite frustum set-up code.
+  private Mat4f infiniteFrustum(float left, float right,
+                                float bottom, float top,
+                                float zNear) {
+    Mat4f m = new Mat4f();
+    m.makeIdent();
+	
+    m.set(0,0, (2*zNear) / (right - left));
+    m.set(0,2, (right + left) / (right - left));
+	
+    m.set(1,1, (2*zNear) / (top - bottom));
+    m.set(1,2, (top + bottom) / (top - bottom));
+	
+    // nudge infinity in just slightly for lsb slop
+    float nudge = 1 - 1.0f / (1<<23);
+
+    m.set(2,2, -1  * nudge);
+    m.set(2,3, -2*zNear * nudge);
+	
+    m.set(3,2, -1);
+    m.set(3,3, 0);
+	
+    m.transpose();
+      
+    return m;
+  }
+
+  private Mat4f infiniteFrustumInverse(float left, float right,
+                                       float bottom, float top,
+                                       float zNear) {
+    Mat4f m = new Mat4f();
+    m.makeIdent();
+	
+    m.set(0,0, (right - left) / (2 * zNear));
+    m.set(0,3, (right + left) / (2 * zNear));
+	
+    m.set(1,1, (top - bottom) / (2 * zNear));
+    m.set(1,3, (top + bottom) / (2 * zNear));
+	
+    m.set(2,2, 0);
+    m.set(2,3, -1);
+	
+    m.set(3,2, -1 / (2 * zNear));
+    m.set(3,3, 1 / (2 * zNear));
+	
+    return m;
+  }
+
+  private Mat4f infinitePerspective(float fovy, float aspect, float zNear) {
+    float tangent = (float) Math.tan(fovy / 2.0);
+    float y = tangent * zNear;
+    float x = aspect * y;
+    return infiniteFrustum(-x, x, -y, y, zNear);
+  }
+
+  private Mat4f infinitePerspectiveInverse(float fovy, float aspect, float zNear) {
+    float tangent = (float) Math.tan(fovy / 2.0);
+    float y = tangent * zNear;
+    float x = aspect * y;
+    return infiniteFrustumInverse(-x, x, -y, y, zNear);
+  }
+
+  private void applyInfinitePerspective(GL2 gl, ExaminerViewer v) {
+    CameraParameters parms = v.getCameraParameters();
+    float aspect = parms.getImagePlaneAspectRatio();
+    gl.glMultMatrixf(getData(infinitePerspective(parms.getVertFOV(), aspect, v.getZNear())), 0);
+  }
+
+  private void applyInfinitePerspectiveInverse(GL2 gl, ExaminerViewer v) {
+    CameraParameters parms = v.getCameraParameters();
+    float aspect = parms.getImagePlaneAspectRatio();
+    gl.glMultMatrixf(getData(infinitePerspectiveInverse(parms.getVertFOV(), aspect, v.getZNear())), 0);
+  }
+
+  private Mat4f perspectiveInverse(float fovy, float aspect, float zNear, float zFar) {
+    float tangent = (float) Math.tan(Math.toRadians(fovy / 2.0));
+    float y = tangent * zNear;
+    float x = aspect * y;
+    return frustumInverse(-x, x, -y, y, zNear, zFar);
+  }
+
+  private Mat4f frustumInverse(float left, float right,
+                               float bottom, float top,
+                               float zNear, float zFar) {
+    Mat4f m = new Mat4f();
+    m.makeIdent();
+
+    m.set(0, 0, (right - left) / (2 * zNear));
+    m.set(0, 3, (right + left) / (2 * zNear));
+	
+    m.set(1, 1, (top - bottom) / (2 * zNear));
+    m.set(1, 3, (top + bottom) / (2 * zNear));
+
+    m.set(2, 2,  0);
+    m.set(2, 3, -1);
+	
+    m.set(3, 2, -(zFar - zNear) / (2 * zFar * zNear));
+    m.set(3, 3,  (zFar + zNear) / (2 * zFar * zNear));
+
+    return m;
+  }
+
+  private float[] getData(Vec4f v) {
+    return new float[] { v.x(), v.y(), v.z(), v.w() };
+  }
+
+  private float[] getData(Mat4f m) {
+    float[] res = new float[16];
+    m.getColumnMajorData(res);
+    return res;
+  }
+
+  private static void runExit() {
+    // 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. Instead run
+    // the exit routine in another thread.
+    new Thread(new Runnable() {
+        public void run() {
+          System.exit(0);
+        }
+      }).start();
+  }
+}