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

diff --git a/src/demos/vertexProgRefract/VertexProgRefract.java b/src/demos/vertexProgRefract/VertexProgRefract.java
new file mode 100644
index 0000000..edbef87
--- /dev/null
+++ b/src/demos/vertexProgRefract/VertexProgRefract.java
@@ -0,0 +1,722 @@
+/*
+ * 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.vertexProgRefract;
+
+import com.sun.opengl.util.gl2.GLUT;
+import com.sun.opengl.util.texture.Texture;
+import demos.common.Demo;
+import demos.common.DemoListener;
+import demos.util.Bunny;
+import demos.util.Cubemap;
+import demos.util.SystemTime;
+import demos.util.Time;
+import gleem.BSphere;
+import gleem.BSphereProvider;
+import gleem.ExaminerViewer;
+import gleem.ManipManager;
+import gleem.MouseButtonHelper;
+import gleem.linalg.Rotf;
+import gleem.linalg.Vec3f;
+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 javax.media.opengl.*;
+import javax.media.opengl.awt.*;
+import javax.media.opengl.glu.GLU;
+import com.sun.opengl.util.Animator;
+import com.sun.opengl.util.BufferUtil;
+import javax.swing.JOptionPane;
+
+
+
+/**
+  Wavelength-dependent refraction demo<br>
+  It's a chromatic aberration!<br>
+  [email protected] 4/2001<br><p>
+
+  Currently 3 passes - could do it in 1 with 4 texture units<p>
+
+  Cubemap courtesy of Paul Debevec<p>
+
+  Ported to Java and ARB_fragment_program by Kenneth Russell
+*/
+
+public class VertexProgRefract extends Demo {
+  public static void main(String[] args) {
+
+    GLCanvas canvas = new GLCanvas();
+    final VertexProgRefract demo = new VertexProgRefract();
+
+    canvas.addGLEventListener(demo);
+    canvas.addKeyListener(new KeyAdapter() {
+          public void keyTyped(KeyEvent e) {
+            demo.dispatchKey(e.getKeyChar());
+          }
+    });
+
+    final Animator animator = new Animator(canvas);
+    demo.setDemoListener(new DemoListener() {
+        public void shutdownDemo() {
+          runExit(animator);
+        }
+        public void repaint() {}
+      });
+
+    Frame frame = new Frame("Refraction Using Vertex Programs");
+    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(animator);
+        }
+      });
+
+    animator.start();
+  }
+
+//  private boolean useRegisterCombiners;
+  private boolean initComplete;
+  private boolean firstRender = true;
+  private int vtxProg;
+  private int fragProg;
+  private Texture cubemap;
+  private int bunnydl;
+  private int obj;
+
+  private GLU  glu  = new GLU();
+  private GLUT glut = new GLUT();
+
+  private GLAutoDrawable drawable;
+  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(GLAutoDrawable drawable) {
+
+    drawable.setGL(new DebugGL2(drawable.getGL().getGL2()));
+
+    initComplete = false;
+
+    GL2 gl = drawable.getGL().getGL2();
+
+    float cc = 1.0f;
+    gl.glClearColor(cc, cc, cc, 1);
+    gl.glColor3f(1,1,1);
+    gl.glEnable(GL.GL_DEPTH_TEST);
+
+    try {
+      initExtension(gl, "GL_ARB_vertex_program");
+      initExtension(gl, "GL_VERSION_1_3"); // For multitexturing support
+      if (!gl.isExtensionAvailable("GL_ARB_fragment_program")) {
+//        if (gl.isExtensionAvailable("GL_NV_register_combiners")) {
+//          useRegisterCombiners = true;
+//        } else {
+          final String message = "This demo requires the GL_ARB_fragment_program extension";
+//                  +  "or GL_NV_register_combiners extension";
+          new Thread(new Runnable() {
+              public void run() {
+                JOptionPane.showMessageDialog(null, message, "Unavailable extension", JOptionPane.ERROR_MESSAGE);
+                shutdownDemo();
+              }
+            }).start();
+          throw new RuntimeException(message);
+//        }
+      }
+    } catch (RuntimeException e) {
+      shutdownDemo();
+      throw(e);
+    }
+
+    b[' '] = true; // animate by default
+
+    int[] vtxProgTmp = new int[1];
+    gl.glGenProgramsARB(1, vtxProgTmp, 0);
+    vtxProg = vtxProgTmp[0];
+    gl.glBindProgramARB(GL2.GL_VERTEX_PROGRAM_ARB, vtxProg);
+    gl.glProgramStringARB(GL2.GL_VERTEX_PROGRAM_ARB, GL2.GL_PROGRAM_FORMAT_ASCII_ARB, transformRefract.length(),
+                          transformRefract);
+
+    gl.glProgramEnvParameter4fARB(GL2.GL_VERTEX_PROGRAM_ARB, 0, 0.0f, 0.0f, 0.0f, 1.0f);    // eye position
+
+    gl.glProgramEnvParameter4fARB(GL2.GL_VERTEX_PROGRAM_ARB, 1, fresnel, fresnel, fresnel, 1.0f);    // fresnel multiplier
+
+    gl.glProgramEnvParameter4fARB(GL2.GL_VERTEX_PROGRAM_ARB, 2, 1.0f, -1.0f, 1.0f, 0.0f);   // texture scale
+    gl.glProgramEnvParameter4fARB(GL2.GL_VERTEX_PROGRAM_ARB, 3, 0.0f, 1.0f, 2.0f, 3.0f);    // misc constants
+
+    try {
+      cubemap = Cubemap.loadFromStreams(getClass().getClassLoader(),
+                                        "demos/data/cubemaps/uffizi_",
+                                        "png",
+                                        true);
+    } catch (IOException e) {
+      shutdownDemo();
+      throw new RuntimeException(e);
+    }
+
+    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.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);
+    }
+
+    doViewAll = true;
+
+    // Do this only once per drawable, not once each time the OpenGL
+    // context is created
+    if (firstRender) {
+      firstRender = false;
+
+      // Register the window with the ManipManager
+      ManipManager manager = ManipManager.getManipManager();
+      manager.registerWindow((AWTGLAutoDrawable) drawable);
+      this.drawable = drawable;
+
+      viewer = new ExaminerViewer(MouseButtonHelper.numMouseButtons());
+      viewer.setNoAltKeyMode(true);
+      viewer.setAutoRedrawMode(false);
+      viewer.attach((AWTGLAutoDrawable) 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);
+    }
+
+    initComplete = true;
+  }
+
+  public void dispose(GLAutoDrawable drawable) {
+  }
+
+  public void display(GLAutoDrawable drawable) {
+    if (!initComplete) {
+      return;
+    }
+
+    time.update();
+
+    GL2 gl = drawable.getGL().getGL2();
+    gl.glClear(GL.GL_COLOR_BUFFER_BIT|GL.GL_DEPTH_BUFFER_BIT);
+
+    if (doViewAll) {
+      viewer.viewAll(gl);
+      doViewAll = false;
+    }
+
+    if (getFlag(' ')) {
+      viewer.rotateAboutFocalPoint(new Rotf(Vec3f.Y_AXIS, (float) (time.deltaT() * animRate)));
+    }
+
+    if (toggleWire) {
+      toggleWire = false;
+      wire = !wire;
+      if (wire) {
+        gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL2.GL_LINE);
+      } else {
+        gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL2.GL_FILL);
+      }
+    }
+
+    // draw background
+    gl.glDisable(GL.GL_DEPTH_TEST);
+    drawSkyBox(gl);
+    gl.glEnable(GL.GL_DEPTH_TEST);
+
+    gl.glPushMatrix();
+
+    viewer.update(gl);
+    ManipManager.getManipManager().updateCameraParameters((AWTGLAutoDrawable) drawable, viewer.getCameraParameters());
+    ManipManager.getManipManager().render((AWTGLAutoDrawable) drawable, gl);
+
+    gl.glBindProgramARB(GL2.GL_VERTEX_PROGRAM_ARB, vtxProg);
+
+    gl.glEnable(GL2.GL_VERTEX_PROGRAM_ARB);
+    gl.glProgramEnvParameter4fARB(GL2.GL_VERTEX_PROGRAM_ARB, 62, fresnel, fresnel, fresnel, 1.0f);
+
+    // set texture transforms
+    gl.glActiveTexture(GL.GL_TEXTURE0);
+    cubemap.bind();
+    cubemap.enable();
+    gl.glMatrixMode(GL.GL_TEXTURE);
+    gl.glLoadIdentity();
+    viewer.updateInverseRotation(gl);
+
+    gl.glActiveTexture(GL.GL_TEXTURE1);
+    cubemap.bind();
+    cubemap.enable();
+    gl.glMatrixMode(GL.GL_TEXTURE);
+    gl.glLoadIdentity();
+    viewer.updateInverseRotation(gl);
+
+//    if (useRegisterCombiners) {
+//      gl.glEnable(GL2.GL_REGISTER_COMBINERS_NV);
+//    } else {
+      gl.glBindProgramARB(GL2.GL_FRAGMENT_PROGRAM_ARB, fragProg);
+      gl.glEnable(GL2.GL_FRAGMENT_PROGRAM_ARB);
+//    }
+
+    gl.glColor3f(1.0f, 1.0f, 1.0f);
+
+    if (getFlag('s')) {
+      // single pass
+      setRefraction(gl, refract);
+      drawObj(gl, obj);
+
+    } else {
+      // red pass
+      gl.glColorMask(true, false, false, false);
+      setRefraction(gl, refract);
+      drawObj(gl, obj);
+  
+      gl.glDepthMask(false);
+      gl.glDepthFunc(GL.GL_EQUAL);
+
+      // green pass
+      gl.glColorMask(false, true, false, false);
+      setRefraction(gl, refract + wavelengthDelta);
+      drawObj(gl, obj);
+
+      // blue pass
+      gl.glColorMask(false, false, true, false);
+      setRefraction(gl, refract + (wavelengthDelta * 2));
+      drawObj(gl, obj);
+
+      gl.glDepthMask(true);
+      gl.glDepthFunc(GL.GL_LESS);
+      gl.glColorMask(true, true, true, false);
+    }
+
+//    if (useRegisterCombiners) {
+//      gl.glDisable(GL2.GL_REGISTER_COMBINERS_NV);
+//    } else {
+      gl.glDisable(GL2.GL_FRAGMENT_PROGRAM_ARB);
+//    }
+    gl.glDisable(GL2.GL_VERTEX_PROGRAM_ARB);
+
+    gl.glMatrixMode(GL2ES1.GL_MODELVIEW);
+    gl.glPopMatrix();
+  }
+
+  // Unused routines
+  public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
+  public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+  public void shutdownDemo() {
+    if (drawable != null) {
+      viewer.detach();
+      ManipManager.getManipManager().unregisterWindow((AWTGLAutoDrawable) drawable);
+      drawable.removeGLEventListener(this);
+    }
+    super.shutdownDemo();
+  }
+
+  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')) {
+      shutdownDemo();
+      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];
+  }
+
+  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);
+    }
+  }
+
+  // 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, 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, 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(GL2 gl) {
+    int[] fragProgTmp = new int[1];
+    gl.glGenProgramsARB(1, fragProgTmp, 0);
+    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(GL2.GL_FRAGMENT_PROGRAM_ARB, fragProg);
+    gl.glProgramStringARB(GL2.GL_FRAGMENT_PROGRAM_ARB, GL2.GL_PROGRAM_FORMAT_ASCII_ARB,
+                       combineFragProg.length(), combineFragProg);
+    int[] errPos = new int[1];
+    gl.glGetIntegerv(GL2.GL_PROGRAM_ERROR_POSITION_ARB, errPos, 0);
+    if (errPos[0] >= 0) {
+      System.out.println("Fragment program failed to load:");
+      String errMsg = gl.glGetString(GL2.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;
+      }
+      System.out.println(combineFragProg.substring(errPos[0], endPos));
+    }
+  }
+
+  private void drawSkyBox(GL2 gl) {
+    // Compensates for ExaminerViewer's modification of modelview matrix
+    gl.glMatrixMode(GL2ES1.GL_MODELVIEW);
+    gl.glLoadIdentity();
+
+    gl.glActiveTexture(GL.GL_TEXTURE1);
+    gl.glDisable(GL.GL_TEXTURE_CUBE_MAP);
+  
+    gl.glActiveTexture(GL.GL_TEXTURE0);
+    cubemap.bind();
+    cubemap.enable();
+
+    // 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 texgen mode. Temporarily enabling lighting
+    // causes the normals to be sent down. Thanks to Ken Dyke.
+    gl.glEnable(GL2ES1.GL_LIGHTING);
+
+    gl.glTexGeni(GL2.GL_S, GL2.GL_TEXTURE_GEN_MODE, GL2.GL_NORMAL_MAP);
+    gl.glTexGeni(GL2.GL_T, GL2.GL_TEXTURE_GEN_MODE, GL2.GL_NORMAL_MAP);
+    gl.glTexGeni(GL2.GL_R, GL2.GL_TEXTURE_GEN_MODE, GL2.GL_NORMAL_MAP);
+
+    gl.glEnable(GL2.GL_TEXTURE_GEN_S);
+    gl.glEnable(GL2.GL_TEXTURE_GEN_T);
+    gl.glEnable(GL2.GL_TEXTURE_GEN_R);
+
+    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
+
+    gl.glMatrixMode(GL.GL_TEXTURE);
+    gl.glPushMatrix();
+    gl.glLoadIdentity();
+    viewer.updateInverseRotation(gl);
+    
+    glut.glutSolidSphere(5.0, 40, 20);
+
+    gl.glDisable(GL2ES1.GL_LIGHTING);
+
+    gl.glPopMatrix();
+    gl.glMatrixMode(GL2ES1.GL_MODELVIEW);
+
+    gl.glDisable(GL2.GL_TEXTURE_GEN_S);
+    gl.glDisable(GL2.GL_TEXTURE_GEN_T);
+    gl.glDisable(GL2.GL_TEXTURE_GEN_R);
+  }
+
+  private void drawObj(GL2 gl, int obj) {
+    switch(obj) {
+    case 0:
+      gl.glCallList(bunnydl);
+      break;
+    
+    case 1:
+      glut.glutSolidSphere(0.5, 64, 64);
+      break;
+
+    case 2:
+      glut.glutSolidTorus(0.25, 0.5, 64, 64);
+      break;
+
+    case 3:
+      drawPlane(gl, 1.0f, 1.0f, 50, 50);
+      break;
+    }
+  }
+
+  private void setRefraction(GL2 gl, float index) {
+    gl.glProgramEnvParameter4fARB(GL2.GL_VERTEX_PROGRAM_ARB, 4, index, index*index, 0.0f, 0.0f);
+  }
+
+  // draw square subdivided into quad strips
+  private void drawPlane(GL2 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);
+
+    for(y=0; y<rows; y++) {
+      gl.glBegin(GL2.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;
+
+        gl.glTexCoord2f(s, t);
+        gl.glColor3f(s, t, 0.0f);
+        gl.glVertex3f(vx, vy, 0.0f);
+
+        gl.glColor3f(s, t + tt, 0.0f);
+        gl.glTexCoord2f(s, t + tt);
+        gl.glVertex3f(vx, vy + th, 0.0f);
+      }
+      gl.glEnd();
+    }
+  }
+
+  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. Instead run
+    // the exit routine in another thread.
+    new Thread(new Runnable() {
+        public void run() {
+          animator.stop();
+          System.exit(0);
+        }
+      }).start();
+  }
+}