Merged JSR-231 branch on to the main JOGL trunk. The main trunk now

contains the evolving JSR-231 Reference Implementation and the JSR-231
branch is permanently closed.


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

1 files changed, 210 insertions, 1008 deletions

diff --git a/src/demos/jrefract/JRefract.java b/src/demos/jrefract/JRefract.java
index e842eba..60361e0 100755
--- a/src/demos/jrefract/JRefract.java
+++ b/src/demos/jrefract/JRefract.java
@@ -35,20 +35,25 @@ package demos.jrefract;
 
 import java.awt.*;
 import java.awt.event.*;
-import java.awt.image.*;
-import java.io.*;
-import java.nio.*;
 import java.util.*;
-import javax.imageio.*;
-import javax.imageio.stream.*;
 import javax.swing.*;
 import javax.swing.event.*;
 
-import net.java.games.jogl.*;
-import net.java.games.jogl.util.*;
+import javax.media.opengl.*;
+import com.sun.opengl.utils.*;
+import com.sun.opengl.utils.*;
+import demos.common.*;
+import demos.hdr.HDR;
+import demos.hwShadowmapsSimple.HWShadowmapsSimple;
+import demos.infiniteShadowVolumes.InfiniteShadowVolumes;
+import demos.jgears.JGears;
+import demos.proceduralTexturePhysics.ProceduralTexturePhysics;
 import demos.util.*;
-import gleem.*;
-import gleem.linalg.*;
+import demos.vertexBufferObject.VertexBufferObject;
+import demos.vertexProgRefract.VertexProgRefract;
+import demos.vertexProgWarp.VertexProgWarp;
+
+import demos.xtrans.*;
 
 /**
   Wavelength-dependent refraction demo<br>
@@ -64,34 +69,129 @@ import gleem.linalg.*;
 
 public class JRefract {
   private boolean useRegisterCombiners;
-  private ArrayList canvases;
 
-  private volatile boolean quit;
-  private volatile boolean animatorStopped;
+  private Animator animator;
   private JDesktopPane desktop;
 
   public static void main(String[] args) {
     new JRefract().run(args);
   }
 
-  private JInternalFrame addWindow(boolean bunny) {
-    String str = bunny ?
-      "Refraction Using Vertex Programs" :
-      "Gears Demo";
+  private static final int GEARS     = 1;
+  private static final int HDR       = 2;
+  private static final int HWSHADOWS = 3;
+  private static final int INFINITE  = 4;
+  private static final int REFRACT   = 5;
+  private static final int VBO       = 6;
+  private static final int WARP      = 7;
+  private static final int WATER     = 8;
+
+  private JInternalFrame addWindow(int which) {
+    // FIXME: workaround for problem in 1.6 where ALL Components,
+    // including Swing components, are Finalizable, requiring two full
+    // GC cycles (and running of finalizers) to reclaim
+    System.gc();
+    // Try to get finalizers run
+    try {
+      Thread.sleep(1);
+    } catch (InterruptedException e) {
+    }
+    System.gc();
+
+    String str = "";
+    switch (which) {
+    case GEARS:     str = "Gears Demo"; break;
+    case HDR:       str = "High Dynamic Range Rendering Demo"; break;
+    case HWSHADOWS: str = "ARB_shadow Shadows"; break;
+    case INFINITE:  str = "Infinite Shadow Volumes"; break;
+    case REFRACT:   str = "Refraction Using Vertex Programs"; break;
+    case VBO:       str = "Very Simple vertex_buffer_object demo"; break;
+    case WATER:     str = "Procedural Texture Waves"; break;
+    }
     final JInternalFrame inner = new JInternalFrame(str);
     inner.setResizable(true);
     inner.setClosable(true);
     inner.setVisible(true);
 
     GLCapabilities caps = new GLCapabilities();
-    if (!bunny) {
-      caps.setAlphaBits(8);
+    if (which == INFINITE) {
+      caps.setStencilBits(16);
     }
-    final GLJPanel canvas = GLDrawableFactory.getFactory().createGLJPanel(caps);
-    if (bunny) {
-      canvas.addGLEventListener(new Listener());
-    } else {
-      canvas.addGLEventListener(new GearRenderer());
+    final GLJPanel canvas =
+      (which == GEARS) ?
+      new JGears() :
+      GLDrawableFactory.getFactory().createGLJPanel(caps);
+    final DemoListener demoListener = new DemoListener() {
+        public void shutdownDemo() {
+          removeJPanel(canvas);
+          SwingUtilities.invokeLater(new Runnable() {
+              public void run() {
+                inner.doDefaultCloseAction();
+              }
+            });
+        }
+
+        public void repaint() {
+          canvas.repaint();
+        }
+      };
+
+    Demo demo = null;
+    switch (which) {
+      case GEARS: {
+        // GLEventListener already added
+        break;
+      }
+
+      case HDR: {
+        demo = new HDR();
+        ((HDR) demo).setup(null);
+        inner.setSize(((HDR) demo).getPreferredWidth(), ((HDR) demo).getPreferredHeight());
+        break;
+      }
+
+      case HWSHADOWS: {
+        demo = new HWShadowmapsSimple();
+        break;
+      }
+
+      case INFINITE: {
+        demo = new InfiniteShadowVolumes();
+        break;
+      }
+
+      case REFRACT: {
+        demo = new VertexProgRefract();
+        break;
+      }
+
+      case VBO: {
+        demo = new VertexBufferObject();
+        break;
+      }
+
+      case WARP: {
+        demo = new VertexProgWarp();
+        ((VertexProgWarp) demo).setTitleSetter(new VertexProgWarp.TitleSetter() {
+            public void setTitle(final String title) {
+              SwingUtilities.invokeLater(new Runnable() {
+                  public void run() {
+                    inner.setTitle(title);
+                  }
+                });
+            }
+          });
+        break;
+      }
+
+      case WATER: {
+        demo = new ProceduralTexturePhysics();
+        break;
+      }
+    }
+    if (which != GEARS) {
+      demo.setDemoListener(demoListener);
+      canvas.addGLEventListener(demo);
     }
     canvas.addMouseListener(new MouseAdapter() {
         public void mouseClicked(MouseEvent e) {
@@ -101,31 +201,27 @@ public class JRefract {
 
     addJPanel(canvas);
 
+    final Demo fDemo = demo;
+
     inner.addInternalFrameListener(new InternalFrameAdapter() {
         public void internalFrameClosed(InternalFrameEvent e) {
-          removeJPanel(canvas);
-          System.gc();
+          if (fDemo != null) {
+            fDemo.shutdownDemo();
+          }
         }
       });
 
     inner.getContentPane().setLayout(new BorderLayout());
-    if (bunny) {
-      inner.getContentPane().add(canvas, BorderLayout.CENTER);
-      inner.getContentPane().add(new JButton("West"), BorderLayout.WEST);
-      inner.getContentPane().add(new JButton("East"), BorderLayout.EAST);
-      inner.getContentPane().add(new JButton("North"), BorderLayout.NORTH);
-      inner.getContentPane().add(new JButton("South"), BorderLayout.SOUTH);
-    } else {
+    /*    if (which == REFRACT) {
+      // Testing scrolling
+      canvas.setSize(512, 512);
+      canvas.setPreferredSize(new Dimension(512, 512));
+      JScrollPane scroller = new JScrollPane(canvas);
+      inner.getContentPane().add(scroller);
+      } else */ if (which == GEARS) {
       // Provide control over transparency of gears background
       canvas.setOpaque(false);
-      JPanel gradientPanel = new JPanel() {
-          public void paintComponent(Graphics g) {
-            ((Graphics2D) g).setPaint(new GradientPaint(0, 0, Color.WHITE,
-                                                        getWidth(), getHeight(), Color.DARK_GRAY));
-            g.fillRect(0, 0, getWidth(), getHeight());
-          }
-        };
-      gradientPanel.setLayout(new BorderLayout());
+      JPanel gradientPanel = JGears.createGradientPanel();
       inner.getContentPane().add(gradientPanel, BorderLayout.CENTER);
       gradientPanel.add(canvas, BorderLayout.CENTER);
 
@@ -136,20 +232,28 @@ public class JRefract {
           }
         });
       inner.getContentPane().add(checkBox, BorderLayout.SOUTH);
+    } else {
+      inner.getContentPane().add(canvas, BorderLayout.CENTER);
     }
 
-    inner.setSize(512, 512);
+    if (which != HDR) {
+      inner.setSize(512, 512);
+    }
     desktop.add(inner);
 
     return inner;
   }
 
   public void run(String[] args) {
-
-    canvases = new ArrayList();
-
     JFrame frame = new JFrame("JOGL and Swing Interoperability");
-    desktop = new JDesktopPane();
+    if ((args.length > 0) && args[0].equals("-xt")) {
+      desktop = new XTDesktopPane();
+      // FIXME: this is a hack to get the repaint behavior to work correctly
+      ((XTDesktopPane) desktop).setAlwaysRedraw(true);
+    } else {
+      desktop = new JDesktopPane();
+    }
+
     desktop.setSize(1024, 768);
     frame.getContentPane().setLayout(new BorderLayout());
     frame.getContentPane().add(desktop, BorderLayout.CENTER);
@@ -166,698 +270,102 @@ public class JRefract {
     JMenuBar menuBar = new JMenuBar();
 
     JMenu menu = new JMenu("Actions");
-    JMenuItem item = new JMenuItem("New bunny");
+    JMenuItem item;
+
+    item = new JMenuItem("Gears");
     item.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
-          addWindow(true);
+          addWindow(GEARS);
         }
       });
     menu.add(item);
 
-    item = new JMenuItem("New gears");
+    item = new JMenuItem("High Dynamic Range");
     item.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
-          addWindow(false);
+          addWindow(HDR);
         }
       });
     menu.add(item);
 
-    item = new JMenuItem("Auto mode");
+    item = new JMenuItem("Hardware Shadow Maps");
     item.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
-          startAutoMode();
+          addWindow(HWSHADOWS);
         }
       });
     menu.add(item);
 
-    item = new JMenuItem("Exit");
+    item = new JMenuItem("Infinite Shadow Volumes");
     item.addActionListener(new ActionListener() {
         public void actionPerformed(ActionEvent e) {
-          runExit();
+          addWindow(INFINITE);
         }
       });
     menu.add(item);
 
-    menuBar.add(menu);
-    frame.setJMenuBar(menuBar);
-
-    frame.addWindowListener(new WindowAdapter() {
-        public void windowClosing(WindowEvent e) {
-          runExit();
+    item = new JMenuItem("Refraction");
+    item.addActionListener(new ActionListener() {
+        public void actionPerformed(ActionEvent e) {
+          addWindow(REFRACT);
         }
       });
-    frame.setSize(desktop.getSize());
-    frame.setVisible(true);
-
-    new Thread(new ListAnimator()).start();
-  }
-
-  class Listener implements GLEventListener {
-    private boolean firstRender = true;
-    private int vtxProg;
-    private int fragProg;
-    private int cubemap;
-    private int bunnydl;
-    private int obj;
-
-    private GLUT glut = new GLUT();
-
-    private ExaminerViewer viewer;
-    private boolean doViewAll = true;
-
-    private Time  time = new SystemTime();
-    private float animRate = (float) Math.toRadians(-6.0f); // Radians / sec
-
-    private float refract = 1.1f;           // ratio of indicies of refraction
-    private float wavelengthDelta = 0.05f;  // difference in refraction for each "wavelength" (R,G,B)
-    private float fresnel = 2.0f;           // Fresnel multiplier
-
-    private boolean wire = false;
-    private boolean toggleWire = false;
-
-    private static final String transformRefract = 
-"!!ARBvp1.0\n" +
-"# Refraction\n" +
-"\n" +
-"# Parameters\n" +
-"PARAM mvp [4]       = { state.matrix.mvp };     # modelview projection matrix\n" +
-"PARAM mvit[4]       = { state.matrix.modelview.invtrans }; # modelview matrix inverse transpose\n" +
-"PARAM mv  [4]       = { state.matrix.modelview }; # modelview matrix\n" +
-"PARAM tex [4]       = { state.matrix.texture }; # texture matrix\n" +
-"PARAM eyePosition   = program.env[0];           # eye position\n" +
-"PARAM fresnel       = program.env[1];           # fresnel multiplier\n" +
-"PARAM texScale      = program.env[2];           # texture scale\n" +
-"PARAM misc          = program.env[3];           # misc. constants\n" +
-"PARAM refraction    = program.env[4];           # refractive index\n" +
-"\n" +
-"# Per vertex inputs\n" +
-"ATTRIB iPos         = vertex.position;          #position\n" +
-"ATTRIB iCol0        = vertex.color;             #color\n" +
-"ATTRIB iNorm        = vertex.normal;            #normal\n" +
-"\n" +
-"# Temporaries\n" +
-"TEMP r0;\n" +
-"TEMP r1;\n" +
-"TEMP r2;\n" +
-"TEMP r3;\n" +
-"TEMP r8;\n" +
-"TEMP r9;\n" +
-"TEMP r11;\n" +
-"\n" +
-"# Outputs\n" +
-"OUTPUT oPos         = result.position;          #position\n" +
-"OUTPUT oCol0        = result.color;             #primary color\n" +
-"OUTPUT oTex0        = result.texcoord[0];       #texture coordinate set 0\n" +
-"OUTPUT oTex1        = result.texcoord[1];       #texture coordinate set 1\n" +
-"\n" +
-"\n" +
-"# transform vertex position to eye space\n" +
-"DP4    r9.x, mv[0], iPos ;\n" +
-"DP4    r9.y, mv[1], iPos ;\n" +
-"DP4    r9.z, mv[2], iPos ;\n" +
-"DP4    r9.w, mv[3], iPos ;\n" +
-"\n" +
-"# transform normal to eye space\n" +
-"DP3    r11.x, mvit[0], iNorm ;\n" +
-"DP3    r11.y, mvit[1], iNorm ;\n" +
-"DP3    r11.z, mvit[2], iNorm ;\n" +
-"\n" +
-"# vertex->eye vector\n" +
-"ADD    r0, -r9, eyePosition;\n" +
-"\n" +
-"# normalize\n" +
-"DP3    r8.w, r0, r0;\n" +
-"RSQ    r8.w, r8.w;\n" +
-"MUL    r8, r0, r8.w;       # r8 = eye/incident vector\n" +
-"\n" +
-"# refraction, Renderman style\n" +
-"\n" +
-"# float IdotN = I.N;\n" +
-"# float k = 1 - eta*eta*(1 - IdotN*IdotN);\n" +
-"# return k < 0 ? (0,0,0) : eta*I - (eta*IdotN + sqrt(k))*N;\n" +
-"\n" +
-"DP3    r0.x, r11, -r8;             # r0 = N.I\n" +
-"\n" +
-"MAD    r1.x, -r0.x, r0.x, misc.y;  # r1 = -IdotN*IdotN + 1\n" +
-"MUL    r1.x, r1.x, refraction.y;   # r1 = -(r1*eta*eta)+1\n" +
-"ADD    r1.x, misc.y, -r1.x;\n" +
-"\n" +
-"RSQ    r2.x, r1.x;\n" +
-"RCP    r2.x, r2.x;\n" +
-"MAD    r2.x, refraction.x, r0.x, r2.x;\n" +
-"MUL    r2, r11, r2.x;\n" +
-"MAD    r2, refraction.x, -r8, r2;\n" +
-"\n" +
-"# transform refracted ray by cubemap transform\n" +
-"DP3    oTex0.x, tex[0], r2;\n" +
-"DP3    oTex0.y, tex[1], r2;\n" +
-"DP3    oTex0.z, tex[2], r2;\n" +
-"\n" +
-"# calculate reflection\n" +
-"MUL    r0, r11, misc.z;\n" +
-"DP3    r3.w, r11, r8;\n" +
-"MAD    r3, r3.w, r0, -r8;\n" +
-"\n" +
-"# transform reflected ray by cubemap transform\n" +
-"DP3    oTex1.x, tex[0], r3;\n" +
-"DP3    oTex1.y, tex[1], r3;\n" +
-"DP3    oTex1.z, tex[2], r3;\n" +
-"\n" +
-"# cheesy Fresnel approximation = (1-(I.N))^p\n" +
-"DP3    r0.x, r8, r11;\n" +
-"ADD    r0.x, misc.y, -r0.x;\n" +
-"MUL    r0.x, r0.x, r0.x;\n" +
-"MUL    oCol0, r0.x, fresnel;\n" +
-"\n" +
-"# transform vertex to clip space\n" +
-"DP4    oPos.x, mvp[0], iPos ;\n" +
-"DP4    oPos.y, mvp[1], iPos ;\n" +
-"DP4    oPos.z, mvp[2], iPos ;\n" +
-"DP4    oPos.w, mvp[3], iPos ;\n" +
-"\n" +
-"END\n";
-
-    public void init(GLDrawable drawable) {
-      // Use debug pipeline
-      // drawable.setGL(new DebugGL(drawable.getGL()));
-
-      GL gl = drawable.getGL();
-      GLU glu = drawable.getGLU();
-      float cc = 1.0f;
-      gl.glClearColor(cc, cc, cc, 1);
-      gl.glColor3f(1,1,1);
-      gl.glEnable(GL.GL_DEPTH_TEST);
+    menu.add(item);
 
-      try {
-        initExtension(gl, "GL_ARB_vertex_program");
-        initExtension(gl, "GL_ARB_multitexture");
-        if (!gl.isExtensionAvailable("GL_ARB_fragment_program")) {
-          if (gl.isExtensionAvailable("GL_NV_register_combiners")) {
-            useRegisterCombiners = true;
-          } else {
-            final String message = "This demo requires either the GL_ARB_fragment_program\n" +
-                                   "or GL_NV_register_combiners extension";
-            new Thread(new Runnable() {
-                public void run() {
-                  JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE);
-                  runExit();
-                }
-              }).start();
-            throw new RuntimeException(message);
-          }
+    item = new JMenuItem("Vertex Buffer Object");
+    item.addActionListener(new ActionListener() {
+        public void actionPerformed(ActionEvent e) {
+          addWindow(VBO);
         }
-      } catch (RuntimeException e) {
-        quit = true;
-        throw(e);
-      }
-
-      b[' '] = true; // animate by default
-
-      int[] vtxProgTmp = new int[1];
-      gl.glGenProgramsARB(1, vtxProgTmp);
-      vtxProg = vtxProgTmp[0];
-      gl.glBindProgramARB  (GL.GL_VERTEX_PROGRAM_ARB, vtxProg);
-      gl.glProgramStringARB(GL.GL_VERTEX_PROGRAM_ARB, GL.GL_PROGRAM_FORMAT_ASCII_ARB, transformRefract.length(), transformRefract);
-
-      gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 0, 0.0f, 0.0f, 0.0f, 1.0f);    // eye position
-
-      gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 1, fresnel, fresnel, fresnel, 1.0f);    // fresnel multiplier
-
-      gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 2, 1.0f, -1.0f, 1.0f, 0.0f);   // texture scale
-      gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 3, 0.0f, 1.0f, 2.0f, 3.0f);    // misc constants
-
-      int[] cubemapTmp = new int[1];
-      gl.glGenTextures(1, cubemapTmp);
-      cubemap = cubemapTmp[0];
-      gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap);
-
-      gl.glTexParameteri(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
-      gl.glTexParameteri(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR);
-
-      try {
-        loadPNGCubemap(gl, glu, "demos/data/cubemaps/uffizi", true);
-      } catch (IOException e) {
-        runExit();
-        throw new RuntimeException(e);
-      }
-
-      gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
-
-      gl.glDisable(GL.GL_CULL_FACE);
-
-      if (useRegisterCombiners) {
-        initCombiners(gl);
-      } else {
-        initFragmentProgram(gl);
-      }
-
-      try {
-        bunnydl = Bunny.gen3DObjectList(gl);
-      } catch (IOException e) {
-        throw new RuntimeException(e);
-      }
-
-      drawable.addKeyListener(new KeyAdapter() {
-          public void keyTyped(KeyEvent e) {
-            dispatchKey(e.getKeyChar());
-          }
-        });
-
-      doViewAll = true;
-
-      // Do this only once per drawable, not once each time the OpenGL
-      // context is created
-      if (firstRender) {
-        firstRender = false;
-
-        drawable.addKeyListener(new KeyAdapter() {
-            public void keyTyped(KeyEvent e) {
-              dispatchKey(e.getKeyChar());
-            }
-          });
-
-        // Register the window with the ManipManager
-        ManipManager manager = ManipManager.getManipManager();
-        manager.registerWindow(drawable);
-
-        viewer = new ExaminerViewer(MouseButtonHelper.numMouseButtons());
-        viewer.setNoAltKeyMode(true);
-        viewer.attach(drawable, new BSphereProvider() {
-            public BSphere getBoundingSphere() {
-              return new BSphere(new Vec3f(0, 0, 0), 1.0f);
-            }
-          });
-        viewer.setVertFOV((float) (15.0f * Math.PI / 32.0f));
-        viewer.setZNear(0.1f);
-        viewer.setZFar(10.0f);
-      }
-    }
-
-    public void display(GLDrawable drawable) {
-      if (quit) {
-        return;
-      }
-
-      time.update();
-
-      GL gl = drawable.getGL();
-      GLU glu = drawable.getGLU();
-      gl.glClear(GL.GL_COLOR_BUFFER_BIT|GL.GL_DEPTH_BUFFER_BIT);
-
-      if (doViewAll) {
-        System.err.println("viewer.viewAll()");
-	viewer.viewAll(gl);
-	doViewAll = false;
-      }
-
-      if (getFlag(' ')) {
-        viewer.rotateAboutFocalPoint(new Rotf(Vec3f.Y_AXIS, (float) (time.deltaT() * animRate)));
-      }
+      });
+    menu.add(item);
 
-      if (toggleWire) {
-        toggleWire = false;
-        wire = !wire;
-        if (wire) {
-          gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE);
-        } else {
-          gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL);
+    item = new JMenuItem("Warp");
+    item.addActionListener(new ActionListener() {
+        public void actionPerformed(ActionEvent e) {
+          addWindow(WARP);
         }
-      }
-
-      // draw background
-      gl.glDisable(GL.GL_DEPTH_TEST);
-      drawSkyBox(gl, glu);
-      gl.glEnable(GL.GL_DEPTH_TEST);
-
-      gl.glPushMatrix();
-
-      viewer.update(gl);
-      ManipManager.getManipManager().updateCameraParameters(drawable, viewer.getCameraParameters());
-      ManipManager.getManipManager().render(drawable, gl);
-
-      gl.glBindProgramARB(GL.GL_VERTEX_PROGRAM_ARB, vtxProg);
-
-      gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB);
-      gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 62, fresnel, fresnel, fresnel, 1.0f);
-
-      // set texture transforms
-      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
-      gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap);
-      gl.glEnable(GL.GL_TEXTURE_CUBE_MAP_ARB);
-      gl.glMatrixMode(GL.GL_TEXTURE);
-      gl.glLoadIdentity();
-      gl.glScalef(1.0f, -1.0f, 1.0f);
-      viewer.updateInverseRotation(gl);
-
-      gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
-      gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap);
-      gl.glEnable(GL.GL_TEXTURE_CUBE_MAP_ARB);
-      gl.glMatrixMode(GL.GL_TEXTURE);
-      gl.glLoadIdentity();
-      gl.glScalef(1.0f, -1.0f, 1.0f);
-      viewer.updateInverseRotation(gl);
-
-      if (useRegisterCombiners) {
-        gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
-      } else {
-        gl.glBindProgramARB(GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-        gl.glEnable(GL.GL_FRAGMENT_PROGRAM_ARB);
-      }
-
-      gl.glColor3f(1.0f, 1.0f, 1.0f);
-
-      if (getFlag('s')) {
-        // single pass
-        setRefraction(gl, refract);
-        drawObj(gl, glu, obj);
-
-      } else {
-        // red pass
-        gl.glColorMask(true, false, false, false);
-        setRefraction(gl, refract);
-        drawObj(gl, glu, obj);
-  
-        gl.glDepthMask(false);
-        gl.glDepthFunc(GL.GL_EQUAL);
-
-        // green pass
-        gl.glColorMask(false, true, false, false);
-        setRefraction(gl, refract + wavelengthDelta);
-        drawObj(gl, glu, obj);
-
-        // blue pass
-        gl.glColorMask(false, false, true, false);
-        setRefraction(gl, refract + (wavelengthDelta * 2));
-        drawObj(gl, glu, obj);
-
-        gl.glDepthMask(true);
-        gl.glDepthFunc(GL.GL_LESS);
-        gl.glColorMask(true, true, true, false);
-      }
-
-      if (useRegisterCombiners) {
-        gl.glDisable(GL.GL_REGISTER_COMBINERS_NV);
-      } else {
-        gl.glDisable(GL.GL_FRAGMENT_PROGRAM_ARB);
-      }
-      gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB);
-
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-      gl.glPopMatrix();
-    }
-
-    // Unused routines
-    public void reshape(GLDrawable drawable, int x, int y, int width, int height) {}
-    public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
-
-    //----------------------------------------------------------------------
-    // Internals only below this point
-    //
-    private boolean[] b = new boolean[256];
-    private void dispatchKey(char k) {
-      setFlag(k, !getFlag(k));
-      // Quit on escape or 'q'
-      if ((k == (char) 27) || (k == 'q')) {
-        runExit();
-	return;
-      }
-
-      switch (k) {
-        case '1':
-	  obj = 0;
-	  break;
-
-        case '2':
-	  obj = 1;
-	  break;
-
-        case '3':
-	  obj = 2;
-	  break;
-
-        case '4':
-	  obj = 3;
-	  break;
-
-        case 'v':
-	  doViewAll = true;
-	  break;
-
-        case 'w':
-          toggleWire = true;
-          break;
-
-        default:
-	  break;
-      }
-    }
-
-    private void setFlag(char key, boolean val) {
-      b[((int) key) & 0xFF] = val;
-    }
-
-    private boolean getFlag(char key) {
-      return b[((int) key) & 0xFF];
-    }
-
-    // FIXME: note we found that we had to swap the negy and posy portions of the cubemap.
-    // Not sure why this is the case. Vertical flip in the image read? Possible, but doesn't
-    // appear to be the case (have tried this and produced wrong results at the time).
-    String[] suffixes = { "posx", "negx", "negy", "posy", "posz", "negz" };
-    int[] targets = { GL.GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB,
-                      GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB,
-                      GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB,
-                      GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB,
-                      GL.GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB,
-                      GL.GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB };
-    private void loadPNGCubemap(GL gl, GLU glu, String baseName, boolean mipmapped) throws IOException {
-      for (int i = 0; i < suffixes.length; i++) {
-        String resourceName = baseName + "_" + suffixes[i] + ".png";
-        // Note: use of BufferedInputStream works around 4764639/4892246
-        BufferedInputStream bis = new BufferedInputStream(getClass().getClassLoader().getResourceAsStream(resourceName));
-	BufferedImage img = ImageIO.read(bis);
-        bis.close();
-	if (img == null) {
-	  throw new RuntimeException("Error reading PNG image " + resourceName);
-	}
-        makeRGBTexture(gl, glu, img, targets[i], mipmapped);
-      }
-    }
+      });
+    menu.add(item);
 
-    private void makeRGBTexture(GL gl, GLU glu, BufferedImage img, int target, boolean mipmapped) {
-      switch (img.getType()) {
-        case BufferedImage.TYPE_3BYTE_BGR:
-        case BufferedImage.TYPE_CUSTOM: {
-          byte[] data = ((DataBufferByte) img.getRaster().getDataBuffer()).getData();
-          if (mipmapped) {
-            glu.gluBuild2DMipmaps(target, GL.GL_RGB8, img.getWidth(), img.getHeight(), GL.GL_RGB,
-                                  GL.GL_UNSIGNED_BYTE, data);
-          } else {
-            gl.glTexImage2D(target, 0, GL.GL_RGB, img.getWidth(), img.getHeight(), 0,
-                            GL.GL_RGB, GL.GL_UNSIGNED_BYTE, data);
-          }
-          break;
+    item = new JMenuItem("Water");
+    item.addActionListener(new ActionListener() {
+        public void actionPerformed(ActionEvent e) {
+          addWindow(WATER);
         }
+      });
+    menu.add(item);
 
-        case BufferedImage.TYPE_INT_RGB: {
-          int[] data = ((DataBufferInt) img.getRaster().getDataBuffer()).getData();
-          if (mipmapped) {
-            glu.gluBuild2DMipmaps(target, GL.GL_RGB8, img.getWidth(), img.getHeight(), GL.GL_RGB,
-                                  GL.GL_UNSIGNED_BYTE, data);
-          } else {
-            gl.glTexImage2D(target, 0, GL.GL_RGB, img.getWidth(), img.getHeight(), 0,
-                            GL.GL_RGB, GL.GL_UNSIGNED_BYTE, data);
-          }
-          break;
+    item = new JMenuItem("Loop Gears Demo");
+    item.addActionListener(new ActionListener() {
+        public void actionPerformed(ActionEvent e) {
+          startAutoMode();
         }
+      });
+    menu.add(item);
 
-        default:
-          throw new RuntimeException("Unsupported image type " + img.getType());
-      }
-    }
-
-    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);
-              runExit();
-            }
-          }).start();
-        throw new RuntimeException(message);
-      }
-    }
-
-    // initalize texture combiners to compute:
-    // refraction*(1-fresnel) + reflection*fresnel
-    private void initCombiners(GL gl) {
-      gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 1);
-      
-      // combiner 0
-      // a*b+c*d
-      gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
-      gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_PRIMARY_COLOR_NV, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
-      gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE1_ARB, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
-      gl.glCombinerInputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_PRIMARY_COLOR_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
-
-      // output:
-      // (stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum)
-      gl.glCombinerOutputNV(GL.GL_COMBINER0_NV, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
-      
-      // final combiner
-      // output: Frgb = A*B + (1-A)*C + D
-      // (variable, input, mapping, componentUsage);
-      gl.glFinalCombinerInputNV(GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
-      gl.glFinalCombinerInputNV(GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
-      gl.glFinalCombinerInputNV(GL.GL_VARIABLE_C_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
-      gl.glFinalCombinerInputNV(GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
-    }
-
-    private void initFragmentProgram(GL gl) {
-      int[] fragProgTmp = new int[1];
-      gl.glGenProgramsARB(1, fragProgTmp);
-      fragProg = fragProgTmp[0];
-      String combineFragProg =
-"!!ARBfp1.0\n" +
-"# compute refraction*(1-fresnel) + reflection*fresnel\n" +
-"TEMP texSamp0, texSamp1;\n" +
-"TEMP invFresnel;\n" +
-"PARAM one = { 1.0, 1.0, 1.0, 1.0 };\n" +
-"TEX texSamp0, fragment.texcoord[0], texture[0], CUBE;\n" +
-"TEX texSamp1, fragment.texcoord[1], texture[1], CUBE;\n" +
-"SUB invFresnel, one, fragment.color;\n" +
-"MUL texSamp0, texSamp0, invFresnel;\n" +
-"MUL texSamp1, texSamp1, fragment.color;\n" +
-"ADD texSamp0, texSamp0, texSamp1;\n" +
-"MOV result.color, texSamp0;\n" +
-"END";
-
-      gl.glBindProgramARB  (GL.GL_FRAGMENT_PROGRAM_ARB, fragProg);
-      gl.glProgramStringARB(GL.GL_FRAGMENT_PROGRAM_ARB, GL.GL_PROGRAM_FORMAT_ASCII_ARB,
-                            combineFragProg.length(), combineFragProg);
-      int[] errPos = new int[1];
-      gl.glGetIntegerv(GL.GL_PROGRAM_ERROR_POSITION_ARB, errPos);
-      if (errPos[0] >= 0) {
-        System.out.println("Fragment program failed to load:");
-        String errMsg = gl.glGetString(GL.GL_PROGRAM_ERROR_STRING_ARB);
-        if (errMsg == null) {
-          System.out.println("[No error message available]");
-        } else {
-          System.out.println("Error message: \"" + errMsg + "\"");
-        }
-        System.out.println("Error occurred at position " + errPos[0] + " in program:");
-        int endPos = errPos[0];
-        while (endPos < combineFragProg.length() && combineFragProg.charAt(endPos) != '\n') {
-          ++endPos;
+    item = new JMenuItem("Quit");
+    item.addActionListener(new ActionListener() {
+        public void actionPerformed(ActionEvent e) {
+          runExit();
         }
-        System.out.println(combineFragProg.substring(errPos[0], endPos));
-      }
-    }
-
-    private void drawSkyBox(GL gl, GLU glu) {
-      // Compensates for ExaminerViewer's modification of modelview matrix
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-      gl.glLoadIdentity();
-
-      gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
-      gl.glDisable(GL.GL_TEXTURE_CUBE_MAP_ARB);
-  
-      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
-      gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, cubemap);
-      gl.glEnable(GL.GL_TEXTURE_CUBE_MAP_ARB);
-
-      // This is a workaround for a driver bug on Mac OS X where the
-      // normals are not being sent down to the hardware in
-      // GL_NORMAL_MAP_EXT texgen mode. Temporarily enabling lighting
-      // causes the normals to be sent down. Thanks to Ken Dyke.
-      gl.glEnable(GL.GL_LIGHTING);
-
-      gl.glTexGeni(GL.GL_S, GL.GL_TEXTURE_GEN_MODE, GL.GL_NORMAL_MAP_EXT);
-      gl.glTexGeni(GL.GL_T, GL.GL_TEXTURE_GEN_MODE, GL.GL_NORMAL_MAP_EXT);
-      gl.glTexGeni(GL.GL_R, GL.GL_TEXTURE_GEN_MODE, GL.GL_NORMAL_MAP_EXT);
-
-      gl.glEnable(GL.GL_TEXTURE_GEN_S);
-      gl.glEnable(GL.GL_TEXTURE_GEN_T);
-      gl.glEnable(GL.GL_TEXTURE_GEN_R);
-
-      gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
-
-      gl.glMatrixMode(GL.GL_TEXTURE);
-      gl.glPushMatrix();
-      gl.glLoadIdentity();
-      gl.glScalef(1.0f, -1.0f, 1.0f);
-      viewer.updateInverseRotation(gl);
-    
-      glut.glutSolidSphere(glu, 5.0, 40, 20);
-
-      gl.glDisable(GL.GL_LIGHTING);
-
-      gl.glPopMatrix();
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-
-      gl.glDisable(GL.GL_TEXTURE_GEN_S);
-      gl.glDisable(GL.GL_TEXTURE_GEN_T);
-      gl.glDisable(GL.GL_TEXTURE_GEN_R);
-    }
-
-    private void drawObj(GL gl, GLU glu, int obj) {
-      switch(obj) {
-      case 0:
-        gl.glCallList(bunnydl);
-        break;
-    
-      case 1:
-        glut.glutSolidSphere(glu, 0.5, 64, 64);
-        break;
-
-      case 2:
-	glut.glutSolidTorus(gl, 0.25, 0.5, 64, 64);
-	break;
-
-      case 3:
-        drawPlane(gl, 1.0f, 1.0f, 50, 50);
-	break;
-      }
-    }
-
-    private void setRefraction(GL gl, float index) {
-      gl.glProgramEnvParameter4fARB(GL.GL_VERTEX_PROGRAM_ARB, 4, index, index*index, 0.0f, 0.0f);
-    }
-
-    // draw square subdivided into quad strips
-    private void drawPlane(GL gl, float w, float h, int rows, int cols) {
-      int x, y;
-      float vx, vy, s, t;
-      float ts, tt, tw, th;
-
-      ts = 1.0f / cols;
-      tt = 1.0f / rows;
-
-      tw = w / cols;
-      th = h / rows;
-
-      gl.glNormal3f(0.0f, 0.0f, 1.0f);
+      });
+    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Q, InputEvent.CTRL_MASK));
+    menu.add(item);
 
-      for(y=0; y<rows; y++) {
-	gl.glBegin(GL.GL_QUAD_STRIP);
-	for(x=0; x<=cols; x++) {
-	  vx = tw * x -(w/2.0f);
-	  vy = th * y -(h/2.0f);
-	  s = ts * x;
-	  t = tt * y;
+    menuBar.add(menu);
+    frame.setJMenuBar(menuBar);
 
-	  gl.glTexCoord2f(s, t);
-	  gl.glColor3f(s, t, 0.0f);
-	  gl.glVertex3f(vx, vy, 0.0f);
+    frame.addWindowListener(new WindowAdapter() {
+        public void windowClosing(WindowEvent e) {
+          runExit();
+        }
+      });
+    frame.setSize(desktop.getSize());
+    frame.setVisible(true);
 
-	  gl.glColor3f(s, t + tt, 0.0f);
-	  gl.glTexCoord2f(s, t + tt);
-	  gl.glVertex3f(vx, vy + th, 0.0f);
-	}
-	gl.glEnd();
-      }
-    }
+    animator = new FPSAnimator(60);
+    animator.start();
   }
 
   private void runExit() {
@@ -868,324 +376,18 @@ public class JRefract {
     // the exit routine in another thread.
     new Thread(new Runnable() {
         public void run() {
-          quit = true;
-          while (!animatorStopped) {
-            try {
-              Thread.sleep(1);
-            } catch (InterruptedException e) {
-            }
-          }
+          animator.stop();
           System.exit(0);
         }
       }).start();
   }
 
   private synchronized void addJPanel(GLJPanel panel) {
-    ArrayList newCanvases = (ArrayList) canvases.clone();
-    newCanvases.add(panel);
-    canvases = newCanvases;
+    animator.add(panel);
   }
 
   private synchronized void removeJPanel(GLJPanel panel) {
-    ArrayList newCanvases = (ArrayList) canvases.clone();
-    newCanvases.remove(panel);
-    canvases = newCanvases;
-  }
-
-  class ListAnimator implements Runnable {
-    public void run() {
-      while (!quit) {
-        if (canvases.isEmpty()) {
-          try {
-            Thread.sleep(10);
-          } catch (InterruptedException e) {
-          }
-        } else {
-          for (Iterator iter = canvases.iterator(); iter.hasNext(); ) {
-            GLJPanel panel = (GLJPanel) iter.next();
-            panel.display();
-          }
-          try {
-            Thread.sleep(1);
-          } catch (InterruptedException e) {
-          }
-        }
-      }
-      animatorStopped = true;
-    }
-  }
-
-  static class GearRenderer implements GLEventListener, MouseListener, MouseMotionListener {
-    private float view_rotx = 20.0f, view_roty = 30.0f, view_rotz = 0.0f;
-    private int gear1, gear2, gear3;
-    private float angle = 0.0f;
-
-    private int prevMouseX, prevMouseY;
-    private boolean mouseRButtonDown = false;
-
-
-    public void init(GLDrawable drawable) {
-      // Use debug pipeline
-      // drawable.setGL(new DebugGL(drawable.getGL()));
-
-      GL gl = drawable.getGL();
-      System.err.println("INIT GL IS: " + gl.getClass().getName());
-
-      float pos[] = { 5.0f, 5.0f, 10.0f, 0.0f };
-      float red[] = { 0.8f, 0.1f, 0.0f, 1.0f };
-      float green[] = { 0.0f, 0.8f, 0.2f, 1.0f };
-      float blue[] = { 0.2f, 0.2f, 1.0f, 1.0f };
-
-      gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, pos);
-      gl.glEnable(GL.GL_CULL_FACE);
-      gl.glEnable(GL.GL_LIGHTING);
-      gl.glEnable(GL.GL_LIGHT0);
-      gl.glEnable(GL.GL_DEPTH_TEST);
-            
-      /* make the gears */
-      gear1 = gl.glGenLists(1);
-      gl.glNewList(gear1, GL.GL_COMPILE);
-      gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, red);
-      gear(gl, 1.0f, 4.0f, 1.0f, 20, 0.7f);
-      gl.glEndList();
-            
-      gear2 = gl.glGenLists(1);
-      gl.glNewList(gear2, GL.GL_COMPILE);
-      gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, green);
-      gear(gl, 0.5f, 2.0f, 2.0f, 10, 0.7f);
-      gl.glEndList();
-            
-      gear3 = gl.glGenLists(1);
-      gl.glNewList(gear3, GL.GL_COMPILE);
-      gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, blue);
-      gear(gl, 1.3f, 2.0f, 0.5f, 10, 0.7f);
-      gl.glEndList();
-            
-      gl.glEnable(GL.GL_NORMALIZE);
-                
-      drawable.addMouseListener(this);
-      drawable.addMouseMotionListener(this);
-    }
-    
-    public void reshape(GLDrawable drawable, int x, int y, int width, int height) {
-      GL gl = drawable.getGL();
-
-      float h = (float)height / (float)width;
-            
-      gl.glMatrixMode(GL.GL_PROJECTION);
-
-      System.err.println("GL_VENDOR: " + gl.glGetString(GL.GL_VENDOR));
-      System.err.println("GL_RENDERER: " + gl.glGetString(GL.GL_RENDERER));
-      System.err.println("GL_VERSION: " + gl.glGetString(GL.GL_VERSION));
-      System.err.println();
-      System.err.println("glLoadTransposeMatrixfARB() supported: " +
-                         gl.isFunctionAvailable("glLoadTransposeMatrixfARB"));
-      if (!gl.isFunctionAvailable("glLoadTransposeMatrixfARB")) {
-        // --- not using extensions
-        gl.glLoadIdentity();
-      } else {
-        // --- using extensions
-        final float[] identityTranspose = new float[] {
-          1, 0, 0, 0,
-          0, 1, 0, 0,
-          0, 0, 1, 0,
-          0, 0, 0, 1
-        };
-        gl.glLoadTransposeMatrixfARB(identityTranspose);
-      }
-      gl.glFrustum(-1.0f, 1.0f, -h, h, 5.0f, 60.0f);
-      gl.glMatrixMode(GL.GL_MODELVIEW);
-      gl.glLoadIdentity();
-      gl.glTranslatef(0.0f, 0.0f, -40.0f);
-    }
-
-    public void display(GLDrawable drawable) {
-      angle += 2.0f;
-
-      GL gl = drawable.getGL();
-      gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
-            
-      gl.glPushMatrix();
-      gl.glRotatef(view_rotx, 1.0f, 0.0f, 0.0f);
-      gl.glRotatef(view_roty, 0.0f, 1.0f, 0.0f);
-      gl.glRotatef(view_rotz, 0.0f, 0.0f, 1.0f);
-            
-      gl.glPushMatrix();
-      gl.glTranslatef(-3.0f, -2.0f, 0.0f);
-      gl.glRotatef(angle, 0.0f, 0.0f, 1.0f);
-      gl.glCallList(gear1);
-      gl.glPopMatrix();
-            
-      gl.glPushMatrix();
-      gl.glTranslatef(3.1f, -2.0f, 0.0f);
-      gl.glRotatef(-2.0f * angle - 9.0f, 0.0f, 0.0f, 1.0f);
-      gl.glCallList(gear2);
-      gl.glPopMatrix();
-            
-      gl.glPushMatrix();
-      gl.glTranslatef(-3.1f, 4.2f, 0.0f);
-      gl.glRotatef(-2.0f * angle - 25.0f, 0.0f, 0.0f, 1.0f);
-      gl.glCallList(gear3);
-      gl.glPopMatrix();
-            
-      gl.glPopMatrix();
-    }
-
-    public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
-
-    private void gear(GL gl,
-                      float inner_radius,
-                      float outer_radius,
-                      float width,
-                      int teeth,
-                      float tooth_depth)
-    {
-      int i;
-      float r0, r1, r2;
-      float angle, da;
-      float u, v, len;
-
-      r0 = inner_radius;
-      r1 = outer_radius - tooth_depth / 2.0f;
-      r2 = outer_radius + tooth_depth / 2.0f;
-            
-      da = 2.0f * (float) Math.PI / teeth / 4.0f;
-            
-      gl.glShadeModel(GL.GL_FLAT);
-
-      gl.glNormal3f(0.0f, 0.0f, 1.0f);
-
-      /* draw front face */
-      gl.glBegin(GL.GL_QUAD_STRIP);
-      for (i = 0; i <= teeth; i++)
-        {
-          angle = i * 2.0f * (float) Math.PI / teeth;
-          gl.glVertex3f(r0 * (float)Math.cos(angle), r0 * (float)Math.sin(angle), width * 0.5f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle), r1 * (float)Math.sin(angle), width * 0.5f);
-          if(i < teeth)
-            {
-              gl.glVertex3f(r0 * (float)Math.cos(angle), r0 * (float)Math.sin(angle), width * 0.5f);
-              gl.glVertex3f(r1 * (float)Math.cos(angle + 3.0f * da), r1 * (float)Math.sin(angle + 3.0f * da), width * 0.5f);
-            }
-        }
-      gl.glEnd();
-
-      /* draw front sides of teeth */
-      gl.glBegin(GL.GL_QUADS);
-      for (i = 0; i < teeth; i++)
-        {
-          angle = i * 2.0f * (float) Math.PI / teeth;
-          gl.glVertex3f(r1 * (float)Math.cos(angle), r1 * (float)Math.sin(angle), width * 0.5f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + da), r2 * (float)Math.sin(angle + da), width * 0.5f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + 2.0f * da), r2 * (float)Math.sin(angle + 2.0f * da), width * 0.5f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle + 3.0f * da), r1 * (float)Math.sin(angle + 3.0f * da), width * 0.5f);
-        }
-      gl.glEnd();
-    
-      /* draw back face */
-      gl.glBegin(GL.GL_QUAD_STRIP);
-      for (i = 0; i <= teeth; i++)
-        {
-          angle = i * 2.0f * (float) Math.PI / teeth;
-          gl.glVertex3f(r1 * (float)Math.cos(angle), r1 * (float)Math.sin(angle), -width * 0.5f);
-          gl.glVertex3f(r0 * (float)Math.cos(angle), r0 * (float)Math.sin(angle), -width * 0.5f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle + 3 * da), r1 * (float)Math.sin(angle + 3 * da), -width * 0.5f);
-          gl.glVertex3f(r0 * (float)Math.cos(angle), r0 * (float)Math.sin(angle), -width * 0.5f);
-        }
-      gl.glEnd();
-    
-      /* draw back sides of teeth */
-      gl.glBegin(GL.GL_QUADS);
-      for (i = 0; i < teeth; i++)
-        {
-          angle = i * 2.0f * (float) Math.PI / teeth;
-          gl.glVertex3f(r1 * (float)Math.cos(angle + 3 * da), r1 * (float)Math.sin(angle + 3 * da), -width * 0.5f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + 2 * da), r2 * (float)Math.sin(angle + 2 * da), -width * 0.5f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + da), r2 * (float)Math.sin(angle + da), -width * 0.5f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle), r1 * (float)Math.sin(angle), -width * 0.5f);
-        }
-      gl.glEnd();
-    
-      /* draw outward faces of teeth */
-      gl.glBegin(GL.GL_QUAD_STRIP);
-      for (i = 0; i < teeth; i++)
-        {
-          angle = i * 2.0f * (float) Math.PI / teeth;
-          gl.glVertex3f(r1 * (float)Math.cos(angle), r1 * (float)Math.sin(angle), width * 0.5f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle), r1 * (float)Math.sin(angle), -width * 0.5f);
-          u = r2 * (float)Math.cos(angle + da) - r1 * (float)Math.cos(angle);
-          v = r2 * (float)Math.sin(angle + da) - r1 * (float)Math.sin(angle);
-          len = (float)Math.sqrt(u * u + v * v);
-          u /= len;
-          v /= len;
-          gl.glNormal3f(v, -u, 0.0f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + da), r2 * (float)Math.sin(angle + da), width * 0.5f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + da), r2 * (float)Math.sin(angle + da), -width * 0.5f);
-          gl.glNormal3f((float)Math.cos(angle), (float)Math.sin(angle), 0.0f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + 2 * da), r2 * (float)Math.sin(angle + 2 * da), width * 0.5f);
-          gl.glVertex3f(r2 * (float)Math.cos(angle + 2 * da), r2 * (float)Math.sin(angle + 2 * da), -width * 0.5f);
-          u = r1 * (float)Math.cos(angle + 3 * da) - r2 * (float)Math.cos(angle + 2 * da);
-          v = r1 * (float)Math.sin(angle + 3 * da) - r2 * (float)Math.sin(angle + 2 * da);
-          gl.glNormal3f(v, -u, 0.0f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle + 3 * da), r1 * (float)Math.sin(angle + 3 * da), width * 0.5f);
-          gl.glVertex3f(r1 * (float)Math.cos(angle + 3 * da), r1 * (float)Math.sin(angle + 3 * da), -width * 0.5f);
-          gl.glNormal3f((float)Math.cos(angle), (float)Math.sin(angle), 0.0f);
-        }
-      gl.glVertex3f(r1 * (float)Math.cos(0), r1 * (float)Math.sin(0), width * 0.5f);
-      gl.glVertex3f(r1 * (float)Math.cos(0), r1 * (float)Math.sin(0), -width * 0.5f);
-      gl.glEnd();
-    
-      gl.glShadeModel(GL.GL_SMOOTH);
-    
-      /* draw inside radius cylinder */
-      gl.glBegin(GL.GL_QUAD_STRIP);
-      for (i = 0; i <= teeth; i++)
-        {
-          angle = i * 2.0f * (float) Math.PI / teeth;
-          gl.glNormal3f(-(float)Math.cos(angle), -(float)Math.sin(angle), 0.0f);
-          gl.glVertex3f(r0 * (float)Math.cos(angle), r0 * (float)Math.sin(angle), -width * 0.5f);
-          gl.glVertex3f(r0 * (float)Math.cos(angle), r0 * (float)Math.sin(angle), width * 0.5f);
-        }
-      gl.glEnd();
-    }
-
-    // Methods required for the implementation of MouseListener
-    public void mouseEntered(MouseEvent e) {}
-    public void mouseExited(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 mouseClicked(MouseEvent e) {}
-    
-    // Methods required for the implementation of MouseMotionListener
-    public void mouseDragged(MouseEvent e) {
-      int x = e.getX();
-      int y = e.getY();
-      Dimension size = e.getComponent().getSize();
-
-      float thetaY = 360.0f * ( (float)(x-prevMouseX)/(float)size.width);
-      float thetaX = 360.0f * ( (float)(prevMouseY-y)/(float)size.height);
-    
-      prevMouseX = x;
-      prevMouseY = y;
-
-      view_rotx += thetaX;
-      view_roty += thetaY;
-    }
-    
-    public void mouseMoved(MouseEvent e) {}
+    animator.remove(panel);
   }
 
   private JInternalFrame curFrame;
@@ -1196,7 +398,7 @@ public class JRefract {
             try {
               SwingUtilities.invokeAndWait(new Runnable() {
                   public void run() {
-                    curFrame = addWindow(false);
+                    curFrame = addWindow(GEARS);
                   }
                 });
             } catch (Exception e) {