Split up net.java.games.util; moved GLUT and BufferUtils into

net.java.games.jogl.util, and moved demo-specific utility classes into
jogl-demos project under demos.util. Added nearly all JavaOne demos
into jogl-demos project; rewrote where necessary to use
ClassLoader.getResourceAsStream() instead of flat files, put into
packages and added to Makefile. Added gleem to jogl-demos project.
Added jogl.jar build rule.


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

1 files changed, 2055 insertions, 0 deletions

diff --git a/src/demos/proceduralTexturePhysics/Water.java b/src/demos/proceduralTexturePhysics/Water.java
new file mode 100644
index 0000000..6a52d15
--- /dev/null
+++ b/src/demos/proceduralTexturePhysics/Water.java
@@ -0,0 +1,2055 @@
+/*
+ * 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.proceduralTexturePhysics;
+
+import java.awt.Image;
+import java.awt.image.*;
+import java.io.*;
+import java.text.*;
+import java.util.*;
+
+import gleem.linalg.*;
+import net.java.games.jogl.*;
+import demos.util.*;
+
+/**
+ * Auxiliary Water simulation class used by ProceduralTexturePhysics
+ * main loop. Demonstration by NVidia Corporation.
+ *
+ * <P>
+ *
+ * Ported to Java by Kenneth Russell
+ */
+
+public class Water {
+  // Note: this class is organized differently than most of the demos
+  // due to the fact that it is used for two purposes: when the
+  // pbuffer's context is current it is used to update the cellular
+  // automata, and when the parent drawable's context is current it is
+  // used to render the water geometry (with the parent drawable's GL
+  // object).
+
+  // Rendering modes
+  public static final int CA_FULLSCREEN_REFLECT   = 0;
+  public static final int CA_FULLSCREEN_FORCE     = 1;
+  public static final int CA_FULLSCREEN_HEIGHT    = 2;
+  public static final int CA_FULLSCREEN_NORMALMAP = 3;
+  public static final int CA_TILED_THREE_WINDOWS  = 4;
+  public static final int CA_DO_NOT_RENDER        = 5;
+
+  private int[] initialMapDimensions = new int[2];
+  private TGAImage initialMap;
+
+  private String tmpSpinFilename;
+  private String tmpDropletFilename;
+  private String tmpCubeMapFilenamePattern;
+
+  private GLDrawable pbuffer;
+  private Rotf cameraOrientation = new Rotf();
+
+  // Static texture names
+  private static final int CA_TEXTURE_INITIAL_MAP = 0;
+  private static final int CA_TEXTURE_SPIN        = 1;
+  private static final int CA_TEXTURE_DROPLET     = 2;
+  private static final int CA_TEXTURE_CUBEMAP     = 3;
+  private static final int CA_NUM_STATIC_TEXTURES = 4;
+
+  // Dynamic texture names
+  private static final int CA_TEXTURE_FORCE_INTERMEDIATE = 0;
+  private static final int CA_TEXTURE_FORCE_TARGET       = 1;
+  private static final int CA_TEXTURE_VELOCITY_SOURCE    = 2;
+  private static final int CA_TEXTURE_VELOCITY_TARGET    = 3;
+  private static final int CA_TEXTURE_HEIGHT_SOURCE      = 4;
+  private static final int CA_TEXTURE_HEIGHT_TARGET      = 5;
+  private static final int CA_TEXTURE_NORMAL_MAP         = 6;
+  private static final int CA_NUM_DYNAMIC_TEXTURES       = 7;
+    
+  // List names
+  private static final int CA_REGCOMBINER_EQ_WEIGHT_COMBINE     = 0;
+  private static final int CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_1 = 1;
+  private static final int CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_2 = 2;
+  private static final int CA_REGCOMBINER_APPLY_FORCE           = 3;
+  private static final int CA_REGCOMBINER_APPLY_VELOCITY        = 4;
+  private static final int CA_REGCOMBINER_CREATE_NORMAL_MAP     = 5;
+  private static final int CA_TEXTURE_SHADER_REFLECT            = 6;
+  private static final int CA_DRAW_SCREEN_QUAD                  = 7;
+  private static final int CA_NUM_LISTS                         = 8;
+
+  private int[]  staticTextureIDs = new int[CA_NUM_STATIC_TEXTURES];     
+  private int[]  dynamicTextureIDs = new int[CA_NUM_DYNAMIC_TEXTURES];
+    
+  private int       texHeightInput;                 // current input height texture ID.
+  private int       texHeightOutput;                // current output height texture ID.
+  private int       texVelocityInput;               // current input velocity texture ID.
+  private int       texVelocityOutput;              // current output velocity texture ID.
+  private int       texForceStepOne;                // intermediate force computation result texture ID.
+  private int       texForceOutput;                 // current output force texture ID.
+
+  private int[]     displayListIDs = new int[CA_NUM_LISTS];
+    
+  private int       vertexProgramID;                // one vertex shader is used to choose the texcoord offset
+
+  private int       flipState;                      // used to flip target texture configurations.
+
+  private boolean   wrap;                           // CA can either wrap its borders, or clamp (clamp by default)  
+  private boolean   reset = true;                   // are we resetting this frame? (user hit reset).
+  private boolean   singleStep;                     // animation step on keypress.
+  private boolean   animate = true;                 // continuous animation.
+  private boolean   slow = true;                    // run slow.
+  private boolean   wireframe;                      // render in wireframe mode
+  private boolean   applyInteriorBoundaries = true; // enable / disable "boundary" image drawing.
+  private boolean   spinLogo = true;                // draw spinning logo.
+  private boolean   createNormalMap = true;         // enable / disable normal map creation.
+
+  private float     perTexelWidth;                  // width of a texel (percentage of texture)
+  private float     perTexelHeight;                 // height of a texel
+
+  private float     blurDist = 0.5f;                // distance over which to blur.
+  private boolean   mustUpdateBlurOffsets;          // flag indicating blurDist was set last tick
+
+  private float     normalSTScale = 0.8f;           // scale of normals in normal map.
+  private float     bumpScale = 0.25f;              // scale of bumps in water.
+
+  private float     dropletFrequency = 0.175f;      // frequency at which droplets are drawn in water...
+
+  private int       slowDelay = 15;                 // amount (milliseconds) to delay when running slow.
+  private int       skipInterval;                   // frames to skip simulation.
+  private int       skipCount;                      // frame count for skipping rendering
+
+  private int       angle;                          // angle in degrees for spinning logo
+
+  private List/*<Droplet>*/ droplets = new ArrayList/*<Droplet>*/();             // array of droplets
+
+  private int       renderMode; 
+
+  // Constant memory locations
+  private static final int CV_WORLDVIEWPROJ_0  =  0;
+  private static final int CV_WORLDVIEWPROJ_1  =  1;
+  private static final int CV_WORLDVIEWPROJ_2  =  2;
+  private static final int CV_WORLDVIEWPROJ_3  =  3;
+
+  private static final int CV_UV_OFFSET_TO_USE =  4;
+
+  private static final int CV_UV_T0_NO_OFFSET  =  8;
+  private static final int CV_UV_T0_TYPE1      =  9;
+  private static final int CV_UV_T0_TYPE2      = 10;
+  private static final int CV_UV_T0_TYPE3      = 11;
+  private static final int CV_UV_T0_TYPE4      = 12;
+
+  private static final int CV_UV_T1_NO_OFFSET  = 13;
+  private static final int CV_UV_T1_TYPE1      = 14;
+  private static final int CV_UV_T1_TYPE2      = 15;
+  private static final int CV_UV_T1_TYPE3      = 16;
+  private static final int CV_UV_T1_TYPE4      = 17;
+
+  private static final int CV_UV_T2_NO_OFFSET  = 18;
+  private static final int CV_UV_T2_TYPE1      = 19;
+  private static final int CV_UV_T2_TYPE2      = 20;
+  private static final int CV_UV_T2_TYPE3      = 21;
+  private static final int CV_UV_T2_TYPE4      = 22;
+
+  private static final int CV_UV_T3_NO_OFFSET  = 23;
+  private static final int CV_UV_T3_TYPE1      = 24;
+  private static final int CV_UV_T3_TYPE2      = 25;
+  private static final int CV_UV_T3_TYPE3      = 26;
+  private static final int CV_UV_T3_TYPE4      = 27;
+
+  private static final int CV_CONSTS_1         = 28;
+
+  public void initialize(String initialMapFilename,
+                         String spinFilename,
+                         String dropletFilename,
+                         String cubeMapFilenamePattern,
+                         GLDrawable parentWindow) {
+    loadInitialTexture(initialMapFilename);
+    tmpSpinFilename           = spinFilename;
+    tmpDropletFilename        = dropletFilename;
+    tmpCubeMapFilenamePattern = cubeMapFilenamePattern;
+    
+    // create the pbuffer.  Will use this as an offscreen rendering buffer.
+    // it allows rendering a texture larger than our window.
+    if (!parentWindow.canCreateOffscreenDrawable()) {
+      throw new GLException("Parent window doesn't support creation of pbuffers");
+    }
+    GLCapabilities caps = new GLCapabilities();
+    caps.setDoubleBuffered(false);
+    pbuffer = parentWindow.createOffscreenDrawable(caps, 
+                                                   initialMapDimensions[0],
+                                                   initialMapDimensions[1]);
+    pbuffer.addGLEventListener(new Listener());
+  }
+
+  public void tick() { 
+    pbuffer.display();
+  }
+
+  public void draw(GL gl, Rotf cameraOrientation) {
+    this.cameraOrientation.set(cameraOrientation);
+
+    if (skipCount >= skipInterval && renderMode != CA_DO_NOT_RENDER) {
+      skipCount = 0;
+      // Display the results of the rendering to texture
+      if (wireframe) {
+        gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE);
+           
+        // chances are the texture will be all dark, so lets not use a texture
+        gl.glDisable(GL.GL_TEXTURE_2D);
+      } else {
+        gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL);
+            			
+        gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+        gl.glEnable(GL.GL_TEXTURE_2D);
+      }
+
+      switch (renderMode) {
+        case CA_FULLSCREEN_REFLECT: {
+          // include bump scale...
+          Mat4f bscale = new Mat4f();
+          bscale.makeIdent();
+          bscale.set(0, 0, bumpScale);
+          bscale.set(1, 1, bumpScale);
+          Mat4f rot = new Mat4f();
+          rot.makeIdent();
+          rot.setRotation(cameraOrientation);
+          Mat4f matRot = rot.mul(bscale);
+
+          gl.glCallList(displayListIDs[CA_TEXTURE_SHADER_REFLECT]);
+
+          // Draw quad over full display
+          gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+          gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_NORMAL_MAP]);
+          gl.glDisable(GL.GL_TEXTURE_2D);
+          gl.glActiveTextureARB(GL.GL_TEXTURE3_ARB);
+          gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, staticTextureIDs[CA_TEXTURE_CUBEMAP]);
+          gl.glEnable(GL.GL_TEXTURE_2D);
+
+          gl.glColor4f(1, 1, 1, 1);
+          gl.glBegin(GL.GL_QUADS);
+                
+          gl.glMultiTexCoord2fARB(GL.GL_TEXTURE0_ARB, 0,0);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE1_ARB, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2),  1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE2_ARB, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2),  1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE3_ARB, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2),  1);
+          gl.glVertex2f(-1,-1);
+                
+          gl.glMultiTexCoord2fARB(GL.GL_TEXTURE0_ARB, 1,0);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE1_ARB, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2), -1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE2_ARB, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2),  1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE3_ARB, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2),  1);
+          gl.glVertex2f( 1,-1);
+                
+          gl.glMultiTexCoord2fARB(GL.GL_TEXTURE0_ARB, 1,1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE1_ARB, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2), -1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE2_ARB, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2), -1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE3_ARB, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2),  1);
+          gl.glVertex2f( 1, 1);
+                
+          gl.glMultiTexCoord2fARB(GL.GL_TEXTURE0_ARB, 0,1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE1_ARB, matRot.get(0,0), matRot.get(0,1), matRot.get(0,2),  1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE2_ARB, matRot.get(1,0), matRot.get(1,1), matRot.get(1,2), -1);
+          gl.glMultiTexCoord4fARB(GL.GL_TEXTURE3_ARB, matRot.get(2,0), matRot.get(2,1), matRot.get(2,2),  1);
+          gl.glVertex2f(-1, 1);
+                
+          gl.glEnd();
+    
+          gl.glDisable(GL.GL_TEXTURE_SHADER_NV);
+          gl.glDisable(GL.GL_REGISTER_COMBINERS_NV);
+                
+          break;
+        }
+
+        case CA_FULLSCREEN_NORMALMAP: {
+          // Draw quad over full display
+          gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+          gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_NORMAL_MAP]);
+                
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          break;
+        }
+
+        case CA_FULLSCREEN_HEIGHT: {
+          // Draw quad over full display
+          gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+          gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
+                
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          break;
+        }
+
+        case CA_FULLSCREEN_FORCE: {
+          // Draw quad over full display
+          gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+          gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_FORCE_TARGET]);
+			                 
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          break;
+        }
+
+        case CA_TILED_THREE_WINDOWS: {
+          // Draw quad over full display
+          // lower left
+          gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+          gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_FORCE_TARGET]);
+          gl.glMatrixMode(GL.GL_MODELVIEW);
+          gl.glPushMatrix();
+			                 
+          gl.glTranslatef(-0.5f, -0.5f, 0);
+          gl.glScalef(0.5f, 0.5f, 1);
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          gl.glPopMatrix();
+
+          // lower right
+          gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityOutput);
+          gl.glPushMatrix();
+			                 
+          gl.glTranslatef(0.5f, -0.5f, 0);
+          gl.glScalef(0.5f, 0.5f, 1);
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          gl.glPopMatrix();
+
+          // upper left
+          gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_NORMAL_MAP]);
+          gl.glMatrixMode(GL.GL_MODELVIEW);
+          gl.glPushMatrix();
+			                 
+          gl.glTranslatef(-0.5f, 0.5f, 0);
+          gl.glScalef(0.5f, 0.5f, 1);
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          gl.glPopMatrix();
+
+          // upper right
+          gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
+          gl.glMatrixMode(GL.GL_MODELVIEW);
+          gl.glPushMatrix();
+			                 
+          gl.glTranslatef(0.5f, 0.5f, 0);
+          gl.glScalef(0.5f, 0.5f, 1);
+          gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+          gl.glPopMatrix();
+			    
+          break;
+        }
+      }
+    } else {
+      // skip rendering this frame
+      skipCount++;
+    }
+  }
+
+  public void singleStep()                               { singleStep  = true;                 }
+  public void enableAnimation(boolean enable)            { animate     = enable;               }
+  public void enableSlowAnimation(boolean enable)        { slow        = enable;               }
+  public void reset()                                    { reset       = true;                 }
+  public void setRenderMode(int mode)                    { renderMode  = mode;                 }
+    
+  public void enableWireframe(boolean enable)            { wireframe   = enable;               }
+  public void enableBorderWrapping(boolean enable)       { wrap        = enable;               }
+    
+  public void enableBoundaryApplication(boolean enable)  { applyInteriorBoundaries = enable;   }
+  public void enableSpinningLogo(boolean enable)         { spinLogo    = enable;               }
+
+  public void  setBlurDistance(float distance)           { blurDist    = distance;
+                                                           mustUpdateBlurOffsets = true;       }
+  public float getBlurDistance()                         { return blurDist;                    }
+
+  public void  setBumpScale(float scale)                 { bumpScale   = scale;                }
+  public float getBumpScale()                            { return bumpScale;                   }
+
+  public void  setDropFrequency(float frequency)         { dropletFrequency = frequency;       }
+  public float getDropFrequency()                        { return dropletFrequency;            }
+
+  public static class Droplet {
+    private float rX;
+    private float rY;
+    private float rScale;
+
+    Droplet(float rX, float rY, float rScale) {
+      this.rX     = rX;
+      this.rY     = rY;
+      this.rScale = rScale;
+    }
+    
+    float rX()     { return rX;     }
+    float rY()     { return rY;     }
+    float rScale() { return rScale; }
+  }
+
+  public synchronized void addDroplet(Droplet drop) {
+    droplets.add(drop);    
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  class Listener implements GLEventListener {
+    public void init(GLDrawable drawable) {
+      GL gl = drawable.getGL();
+      GLU glu = drawable.getGLU();
+
+      initOpenGL(gl, glu);
+    }
+
+    public void display(GLDrawable drawable) {
+      GL gl = drawable.getGL();
+      if (mustUpdateBlurOffsets) {
+        updateBlurVertOffset(gl);
+        mustUpdateBlurOffsets = false;
+      }
+      
+      // Take a single step in the cellular automaton
+
+      // Disable culling
+      gl.glDisable(GL.GL_CULL_FACE);
+
+      if (reset) {
+        reset = false;
+        flipState = 0;
+      }
+
+      if (animate) {
+        // Update the textures for one step of the simulation
+        doSingleTimeStep(gl);
+      } else if (singleStep) {
+        doSingleTimeStep(gl);
+        singleStep = false;
+      }
+	
+      if (slow && (slowDelay > 0) ) {
+        try {
+          Thread.sleep(slowDelay);
+        } catch (InterruptedException e) {
+        }
+      }
+    }
+
+    public void reshape(GLDrawable drawable, int x, int y, int width, int height) {}
+
+    // Unused routines
+    public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) {}
+  }
+
+  private TGAImage loadImage(String resourceName) {
+    try {
+      return TGAImage.read(getClass().getClassLoader().getResourceAsStream(resourceName));
+    } catch (IOException e) {
+      throw new GLException(e);
+    }
+  }
+
+  // We need to load the initial texture file early to get the width
+  // and height for the pbuffer
+  private void loadInitialTexture(String initialMapFilename) {
+    try {
+      initialMap = TGAImage.read(getClass().getClassLoader().getResourceAsStream(initialMapFilename));
+    } catch (IOException e) {
+      throw new GLException(e);
+    }
+    initialMapDimensions[0] = initialMap.getWidth();
+    initialMapDimensions[1] = initialMap.getHeight();
+  }
+
+  private void initOpenGL(GL gl, GLU glu) {
+    loadTextures(gl, tmpSpinFilename, tmpDropletFilename, tmpCubeMapFilenamePattern);
+    tmpSpinFilename           = null;
+    tmpDropletFilename        = null;
+    tmpCubeMapFilenamePattern = null;
+
+    gl.glMatrixMode(GL.GL_MODELVIEW);
+    gl.glLoadIdentity();
+    gl.glMatrixMode(GL.GL_PROJECTION);
+    gl.glLoadIdentity();
+    glu.gluOrtho2D(-1, 1, -1, 1);
+    
+    gl.glClearColor(0, 0, 0, 0);
+    gl.glDisable(GL.GL_LIGHTING);
+    gl.glDisable(GL.GL_DEPTH_TEST);
+      
+    createAndWriteUVOffsets(gl, initialMapDimensions[0], initialMapDimensions[1]);
+
+    checkExtension(gl, "GL_NV_register_combiners");
+    checkExtension(gl, "GL_NV_register_combiners2");
+    checkExtension(gl, "GL_NV_texture_shader");
+    checkExtension(gl, "GL_ARB_multitexture");
+
+    ///////////////////////////////////////////////////////////////////////////
+    // UV Offset Vertex Program
+    ///////////////////////////////////////////////////////////////////////////
+    // track the MVP matrix for the vertex program
+    gl.glTrackMatrixNV(GL.GL_VERTEX_PROGRAM_NV, 0, GL.GL_MODELVIEW_PROJECTION_NV, GL.GL_IDENTITY_NV);
+    float[] rCVConsts = new float[] { 0, 0.5f, 1.0f, 2.0f };
+    gl.glProgramParameter4fvNV(GL.GL_VERTEX_PROGRAM_NV, CV_CONSTS_1, rCVConsts);
+
+    int[] tmpInt = new int[1];
+    gl.glGenProgramsNV(1, tmpInt);
+    vertexProgramID = tmpInt[0];
+    gl.glBindProgramNV(GL.GL_VERTEX_PROGRAM_NV, vertexProgramID);
+
+    String programBuffer =
+      "!!VP1.0\n" +
+      "# CV_WORLDVIEWPROJ_0  = 0,\n" +
+      "# CV_WORLDVIEWPROJ_1  = 1,\n" +
+      "# CV_WORLDVIEWPROJ_2  = 2,\n" +
+      "# CV_WORLDVIEWPROJ_3  = 3,\n" +
+      "#\n" +
+      "# CV_UV_OFFSET_TO_USE = 4,\n" +
+      "#\n" +
+      "#\n" +
+      "# CV_UV_T0_NO_OFFSET  = 8,\n" +
+      "# CV_UV_T0_TYPE1      = 9,\n" +
+      "# CV_UV_T0_TYPE2      = 10,\n" +
+      "# CV_UV_T0_TYPE3      = 11,\n" +
+      "# CV_UV_T0_TYPE4      = 12,\n" +
+      "#\n" +
+      "# CV_UV_T1_NO_OFFSET  = 13,\n" +
+      "# CV_UV_T1_TYPE1      = 14,\n" +
+      "# CV_UV_T1_TYPE2      = 15,\n" +
+      "# CV_UV_T1_TYPE3      = 16,\n" +
+      "# CV_UV_T1_TYPE4      = 17,\n" +
+      "#\n" +
+      "# CV_UV_T2_NO_OFFSET  = 18,\n" +
+      "# CV_UV_T2_TYPE1      = 19,\n" +
+      "# CV_UV_T2_TYPE2      = 20,\n" +
+      "# CV_UV_T2_TYPE3      = 21,\n" +
+      "# CV_UV_T2_TYPE4      = 22,\n" +
+      "#\n" +
+      "# CV_UV_T3_NO_OFFSET  = 23,\n" +
+      "# CV_UV_T3_TYPE1      = 24,\n" +
+      "# CV_UV_T3_TYPE2      = 25,\n" +
+      "# CV_UV_T3_TYPE3      = 26,\n" +
+      "# CV_UV_T3_TYPE4      = 27,\n" +
+      "#\n" +
+      "# CV_CONSTS_1         = 28\n" +
+      "\n" +
+      "# Transform vertex-position to clip-space\n" +
+      "DP4 o[HPOS].x, v[OPOS], c[0];\n" +
+      "DP4 o[HPOS].y, v[OPOS], c[1];\n" +
+      "DP4 o[HPOS].z, v[OPOS], c[2];\n" +
+      "DP4 o[HPOS].w, v[OPOS], c[3];\n" +
+      "\n" +
+      "# Read which set of offsets to use\n" +
+      "ARL A0.x, c[4].x;\n" +
+      "\n" +
+      "#	c[CV_CONSTS_1] = c[28]\n" +
+      "#	x = 0\n" +
+      "#	y = 0.5\n" +
+      "#	z = 1\n" +
+      "#	w = 2.0f\n" +
+      "\n" +
+      "#  Put a scale factor into r0 so the sample points\n" +
+      "#    can be moved farther from the texel being written\n" +
+      "\n" +
+      "#MOV R0, c[28].z;\n" +
+      "\n" +
+      "# Add the offsets to the input texture\n" +
+      "# coordinate, creating 4 sets of independent\n" +
+      "# texture coordinates.\n" +
+      "\n" +
+      "ADD o[TEX0], c[A0.x + 8],  v[TEX0];\n" +
+      "ADD o[TEX1], c[A0.x + 13], v[TEX0];\n" +
+      "ADD o[TEX2], c[A0.x + 18], v[TEX0];\n" +
+      "ADD o[TEX3], c[A0.x + 23], v[TEX0];\n" +
+      "\n" +
+      "#MAD o[TEX0], R0, c[A0.x + 8],  v[TEX0];\n" +
+      "#MAD o[TEX1], R0, c[A0.x + 13], v[TEX0]; \n" +
+      "#MAD o[TEX2], R0, c[A0.x + 18], v[TEX0]; \n" +
+      "#MAD o[TEX3], R0, c[A0.x + 23], v[TEX0];\n" +
+      "\n" +
+      "END     \n";
+
+    gl.glLoadProgramNV(GL.GL_VERTEX_PROGRAM_NV, vertexProgramID, programBuffer.length(), programBuffer);
+    if (gl.glGetError() != GL.GL_NO_ERROR) {
+      throw new GLException("Error loading vertex program \"Texcoord_4_Offset.vp\"");
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // register combiner setup for equal weight combination of texels
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_REGCOMBINER_EQ_WEIGHT_COMBINE] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_REGCOMBINER_EQ_WEIGHT_COMBINE], GL.GL_COMPILE);
+    initEqWeightCombine_PostMult(gl);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // register combiners setup for computing force from neighbors (step 1)
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_1] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_1], GL.GL_COMPILE);
+    initNeighborForceCalcStep1(gl);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // register combiners setup for computing force from neighbors (step 2)
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_2] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_2], GL.GL_COMPILE);
+    initNeighborForceCalcStep2(gl);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // register combiners setup to apply force
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_REGCOMBINER_APPLY_FORCE] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_REGCOMBINER_APPLY_FORCE], GL.GL_COMPILE);
+    initApplyForce(gl);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // register combiners setup to apply velocity
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_REGCOMBINER_APPLY_VELOCITY] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_REGCOMBINER_APPLY_VELOCITY], GL.GL_COMPILE);
+    initApplyVelocity(gl);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // register combiners setup to create a normal map
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_REGCOMBINER_CREATE_NORMAL_MAP] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_REGCOMBINER_CREATE_NORMAL_MAP], GL.GL_COMPILE);
+    initCreateNormalMap(gl);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // texture shader setup for dot product reflection
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_TEXTURE_SHADER_REFLECT] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_TEXTURE_SHADER_REFLECT], GL.GL_COMPILE);
+    initDotProductReflect(gl);
+    gl.glDisable(GL.GL_BLEND);
+    gl.glEnable(GL.GL_TEXTURE_SHADER_NV);
+    gl.glEnable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glEndList();
+
+    ///////////////////////////////////////////////////////////////////////////
+    // display list to render a single screen space quad.
+    ///////////////////////////////////////////////////////////////////////////
+    displayListIDs[CA_DRAW_SCREEN_QUAD] = gl.glGenLists(1);
+    gl.glNewList(displayListIDs[CA_DRAW_SCREEN_QUAD], GL.GL_COMPILE);
+    gl.glColor4f(1, 1, 1, 1);
+    gl.glBegin(GL.GL_TRIANGLE_STRIP);
+    gl.glTexCoord2f(0, 1); gl.glVertex2f(-1,  1);
+    gl.glTexCoord2f(0, 0); gl.glVertex2f(-1, -1);
+    gl.glTexCoord2f(1, 1); gl.glVertex2f( 1,  1);
+    gl.glTexCoord2f(1, 0); gl.glVertex2f( 1, -1);
+    gl.glEnd();
+    gl.glEndList();
+  }
+
+  private void checkExtension(GL gl, String extensionName) {
+    if (!gl.isExtensionAvailable(extensionName)) {
+      throw new GLException("Unable to initialize " + extensionName + " OpenGL extension");
+    }
+  }
+
+  private void doSingleTimeStep(GL gl) {
+    int temp;
+
+    // Swap texture source & target indices & pointers
+    //  0 = start from initial loaded texture
+    //  1/2 = flip flop back and forth between targets & sources
+
+    switch (flipState) {
+    case 0:
+      texHeightInput    = dynamicTextureIDs[CA_TEXTURE_HEIGHT_SOURCE];       // initial height map.
+      texHeightOutput   = dynamicTextureIDs[CA_TEXTURE_HEIGHT_TARGET];    // next height map.
+
+      texVelocityInput  = dynamicTextureIDs[CA_TEXTURE_VELOCITY_SOURCE];  // initial velocity.
+      texVelocityOutput = dynamicTextureIDs[CA_TEXTURE_VELOCITY_TARGET];  // next velocity.
+
+      // Clear initial velocity texture to 0x80 == gray
+      gl.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
+      gl.glClear(GL.GL_COLOR_BUFFER_BIT);
+
+      // Now we need to copy the resulting pixels into the intermediate force field texture
+      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+      gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityInput);
+
+      // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+      gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
+
+      break;  
+        
+    case 1:
+      temp              = texHeightInput;
+      texHeightInput    = texHeightOutput;
+      texHeightOutput   = temp;
+
+      temp              = texVelocityInput;
+      texVelocityInput  = texVelocityOutput;
+      texVelocityOutput = temp;
+
+      break;
+
+    case 2:
+      temp              = texHeightInput;
+      texHeightInput    = texHeightOutput;
+      texHeightOutput   = temp;
+
+      temp              = texVelocityInput;
+      texVelocityInput  = texVelocityOutput;
+      texVelocityOutput = temp;
+      break;
+    }
+	
+    // even if wireframe mode, render to texture as solid
+    gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL);
+	
+    /////////////////////////////////////////////////////////////
+    //  Render first 3 components of force from three neighbors
+    //  Offsets selected are 1 center texel for center height
+    //    and 3 of the 4 nearest neighbors.  Texture selected
+    //    is same for all stages as we're turning height difference
+    //    of nearest neightbor texels into a force value.
+
+    gl.glCallList(displayListIDs[CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_1]);
+
+    // set current source texture for stage 0 texture
+    for (int i = 0; i < 4; i++)
+      {
+        gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB + i);
+        gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
+        gl.glEnable(GL.GL_TEXTURE_2D);
+      }
+
+    int wrapMode = wrap ? GL.GL_REPEAT : GL.GL_CLAMP_TO_EDGE;
+    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, wrapMode);
+    gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, wrapMode);
+
+    // disable blending
+    gl.glDisable(GL.GL_BLEND);
+
+    // render using offset 1 (type 1 -- center + 3 of 4 nearest neighbors).
+    gl.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_OFFSET_TO_USE, 1, 0, 0, 0);
+
+    // bind the vertex program to be used for this step and the next one.
+    gl.glBindProgramNV(GL.GL_VERTEX_PROGRAM_NV, vertexProgramID);
+    gl.glEnable(GL.GL_VERTEX_PROGRAM_NV);
+
+    // render a screen quad. with texture coords doing difference of nearby texels for force calc.
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    // Now we need to copy the resulting pixels into the intermediate force field texture
+    gl.glActiveTextureARB(GL.GL_TEXTURE2_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_FORCE_INTERMEDIATE]);
+
+    // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+    gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
+
+    ////////////////////////////////////////////////////////////////
+    // Now add in last component of force for the 4th neighbor
+    //  that we didn't have enough texture lookups to do in the 
+    //  first pass
+
+    gl.glCallList(displayListIDs[CA_REGCOMBINER_NEIGHBOR_FORCE_CALC_2]);
+    
+    // Cannot use additive blending as the force contribution might
+    //   be negative and would have to subtract from the dest.
+    // We must instead use an additional texture as target and read
+    //   the previous partial 3-neighbor result into the pixel shader
+    //   for possible subtraction
+
+    // Alphablend must be false
+
+    //; t0 = center  (same as last phase)
+    //; t1 = 2nd axis final point (same as last phase)
+    //; t2 = previous partial result texture sampled at center (result of last phase copied to texture)
+    //; t3 = not used (disable now)
+
+    gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, wrapMode);
+    gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, wrapMode);
+
+    gl.glActiveTextureARB(GL.GL_TEXTURE3_ARB);
+    gl.glDisable(GL.GL_TEXTURE_2D);
+
+    // vertex program already bound.
+    // render using offset 2 (type 2 -- final nearest neighbor plus center of previous result).
+    gl.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_OFFSET_TO_USE, 2, 0, 0, 0);
+
+    // render a screen quad
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    // Now we need to copy the resulting pixels into the intermediate force field texture
+    gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_FORCE_TARGET]);
+
+    // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+    gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
+
+    /////////////////////////////////////////////////////////////////
+    // Apply the force with a scale factor to reduce it's magnitude.
+    // Add this to the current texture representing the water height.
+    
+    gl.glCallList(displayListIDs[CA_REGCOMBINER_APPLY_FORCE]);
+
+    // use offsets of zero
+    gl.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_OFFSET_TO_USE, 0, 0, 0, 0);
+
+    // bind the vertex program to be used for this step and the next one.
+
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityInput);
+    gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_FORCE_TARGET]);
+    gl.glActiveTextureARB(GL.GL_TEXTURE2_ARB);
+    gl.glDisable(GL.GL_TEXTURE_2D);
+    gl.glActiveTextureARB(GL.GL_TEXTURE3_ARB);
+    gl.glDisable(GL.GL_TEXTURE_2D);
+
+    // Draw the quad to add in force.
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    ///////////////////////////////////////////////////////////////////
+    // With velocity texture selected, render new excitation droplets
+    //   at random freq.
+
+    float randomFrequency = (float) Math.random();
+
+    if (dropletFrequency > randomFrequency) {
+      // a drop falls - decide where
+      Droplet drop = new Droplet(2 * ((float)Math.random() - 0.5f),
+                                 2 * ((float)Math.random() - 0.5f),
+                                 0.02f +  0.1f * ((float)Math.random()));
+      addDroplet(drop);
+    }
+
+    //  Now draw the droplets:
+    if (!droplets.isEmpty()) {
+      drawDroplets(gl);
+      droplets.clear();
+    }
+
+    // Now we need to copy the resulting pixels into the velocity texture
+    gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, texVelocityOutput);
+
+    // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+    gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);  
+
+    //////////////////////////////////////////////////////////////////////
+    // Apply velocity to position
+    gl.glCallList(displayListIDs[CA_REGCOMBINER_APPLY_VELOCITY]);
+    gl.glEnable(GL.GL_VERTEX_PROGRAM_NV);
+
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
+    gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB); // velocity output already bound
+    gl.glEnable(GL.GL_TEXTURE_2D);
+
+    // use offsets of zero
+    gl.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_OFFSET_TO_USE, 0, 0, 0, 0);
+
+    // Draw the quad to add in force.
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    // Now we need to copy the resulting pixels into the input height texture
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
+    
+    // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+    gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]); 
+
+    ///////////////////////////////////////////////////////////////////
+    //  blur positions to smooth noise & generaly dampen things
+    //  degree of blur is controlled by magnitude of 4 neighbor texel
+    //   offsets with bilinear on
+    
+    for (int i = 1; i < 4; i++) {
+      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB + i);
+      gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightInput);
+      gl.glEnable(GL.GL_TEXTURE_2D);
+    }
+
+    // use offsets of 3
+    gl.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_OFFSET_TO_USE, 3, 0, 0, 0);
+
+    gl.glCallList(displayListIDs[CA_REGCOMBINER_EQ_WEIGHT_COMBINE]);
+
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    // Draw the logo in the water.
+    if (applyInteriorBoundaries) {
+      gl.glDisable(GL.GL_VERTEX_PROGRAM_NV);
+      drawInteriorBoundaryObjects(gl);
+    }
+
+    // Now we need to copy the resulting pixels into the velocity texture
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
+
+    // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+    gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
+      
+    ///////////////////////////////////////////////////////////////////
+    // If selected, create a normal map from the height
+      
+    if (createNormalMap) {
+      createNormalMap(gl);
+    }
+      
+    ///////////////////////////////////////////////////////////
+    // Flip the state variable for the next round of rendering
+    switch (flipState) {
+    case 0:
+      flipState = 1;
+      break;
+    case 1:
+      flipState = 2;
+      break;
+    case 2:
+      flipState = 1;
+      break;
+    }
+  }
+
+  private void createNormalMap(GL gl) {
+    // use the height output on all four texture stages
+    for (int i = 0; i < 4; i++) {
+      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB + i);
+      gl.glBindTexture(GL.GL_TEXTURE_2D, texHeightOutput);
+      gl.glEnable(GL.GL_TEXTURE_2D);
+    }
+
+    // Set constants for red & green scale factors (also essential color masks)
+    // Red mask first
+    float[] pixMasks = new float[] { normalSTScale, 0.0f, 0.0f, 0.0f };
+
+    gl.glCombinerStageParameterfvNV(GL.GL_COMBINER2_NV, GL.GL_CONSTANT_COLOR0_NV, pixMasks);
+
+    // Now green mask & scale:
+    pixMasks[0] = 0.0f;
+    pixMasks[1] = normalSTScale;
+    gl.glCombinerStageParameterfvNV(GL.GL_COMBINER2_NV, GL.GL_CONSTANT_COLOR1_NV, pixMasks);
+
+    gl.glCallList(displayListIDs[CA_REGCOMBINER_CREATE_NORMAL_MAP]);
+
+    // set vp offsets to nearest neighbors
+    gl.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_OFFSET_TO_USE, 4, 0, 0, 0);
+    gl.glEnable(GL.GL_VERTEX_PROGRAM_NV);
+    
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    // Now we need to copy the resulting pixels into the normal map
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, dynamicTextureIDs[CA_TEXTURE_NORMAL_MAP]);
+    
+    // use CopyTexSubImage for speed (even though we copy all of it) since we pre-allocated the texture
+    gl.glCopyTexSubImage2D(GL.GL_TEXTURE_2D, 0, 0, 0, 0, 0, initialMapDimensions[0], initialMapDimensions[1]);
+  }
+
+  private void drawInteriorBoundaryObjects(GL gl) {
+    gl.glDisable(GL.GL_REGISTER_COMBINERS_NV);
+    
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, staticTextureIDs[CA_TEXTURE_INITIAL_MAP]);
+    gl.glEnable(GL.GL_TEXTURE_2D);
+
+    gl.glEnable(GL.GL_ALPHA_TEST);
+
+    // disable other texture units.
+    for (int i = 1; i < 4; i++) {
+      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB + i);
+      gl.glDisable(GL.GL_TEXTURE_2D);
+    }
+    
+    gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
+    gl.glEnable(GL.GL_BLEND);
+
+    gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+    if (spinLogo) {
+      gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+      gl.glBindTexture(GL.GL_TEXTURE_2D, staticTextureIDs[CA_TEXTURE_SPIN]);
+      gl.glMatrixMode(GL.GL_MODELVIEW);
+      gl.glPushMatrix();
+      gl.glRotatef(angle, 0, 0, 1);
+      angle += 1;
+
+      gl.glCallList(displayListIDs[CA_DRAW_SCREEN_QUAD]);
+
+      gl.glPopMatrix();
+    }
+
+    gl.glDisable(GL.GL_ALPHA_TEST);
+    gl.glDisable(GL.GL_BLEND);
+  }
+
+  private void createTextureObject(GL gl, int id, TGAImage image, boolean test) {
+    // Fetch image data out of image
+    gl.glBindTexture(GL.GL_TEXTURE_2D, id);
+    gl.glTexImage2D (GL.GL_TEXTURE_2D, 
+                     0,
+                     GL.GL_RGBA8,
+                     image.getWidth(),
+                     image.getHeight(),
+                     0,
+                     image.getGLFormat(),
+                     GL.GL_UNSIGNED_BYTE,
+                     image.getData());
+    gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
+    gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+    gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+    gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+  }
+
+  private void loadCubeMap(GL gl, int id, String filenamePattern, boolean mipmap) {
+    int[] faces = new int[] { 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 };
+    String[] faceNames = new String[] { "posx", "negx", "posy", "negy", "posz", "negz" };
+
+    // create and bind a cubemap texture object
+    gl.glBindTexture(GL.GL_TEXTURE_CUBE_MAP_ARB, id);
+
+    // enable automipmap generation if needed.
+    gl.glTexParameteri(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_GENERATE_MIPMAP_SGIS, (mipmap ? 1 : 0));
+    
+    if (mipmap)
+      gl.glTexParameterf(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR);
+    else
+      gl.glTexParameterf(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
+    gl.glTexParameterf(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+    gl.glTexParameterf(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+    gl.glTexParameterf(GL.GL_TEXTURE_CUBE_MAP_ARB, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+
+    // load 6 faces.
+    MessageFormat fmt = new MessageFormat(filenamePattern);
+    for (int i = 0; i < 6; i++) {
+      String filename = MessageFormat.format(filenamePattern, new String[] { faceNames[i] });
+      TGAImage image = loadImage(filename);
+      gl.glTexImage2D(faces[i], 
+                      0,
+                      GL.GL_RGBA8,
+                      image.getWidth(),
+                      image.getHeight(),
+                      0,
+                      image.getGLFormat(),
+                      GL.GL_UNSIGNED_BYTE,
+                      image.getData());
+    }
+  }
+
+  private void loadTextures(GL gl,
+                            String spinFilename,
+                            String dropletFilename,
+                            String cubeMapFilenamePattern) {
+    if (initialMap == null) {
+      throw new GLException("Must call loadInitialTexture ahead of time");
+    }
+
+    TGAImage spin    = loadImage(spinFilename);
+    TGAImage droplet = loadImage(dropletFilename);
+
+    gl.glGenTextures(CA_NUM_STATIC_TEXTURES, staticTextureIDs); 
+    gl.glGenTextures(CA_NUM_DYNAMIC_TEXTURES, dynamicTextureIDs); // also create intermediate texture object
+
+    // upload the initial map texture
+    createTextureObject(gl, staticTextureIDs[CA_TEXTURE_INITIAL_MAP], initialMap, true);
+
+    createTextureObject(gl, staticTextureIDs[CA_TEXTURE_SPIN], spin, true);
+
+    createTextureObject(gl, staticTextureIDs[CA_TEXTURE_DROPLET], droplet, false);
+
+    // load the cubemap texture
+    loadCubeMap(gl, staticTextureIDs[CA_TEXTURE_CUBEMAP], cubeMapFilenamePattern, true);
+
+    for (int i = 0; i < CA_NUM_DYNAMIC_TEXTURES; i++) {
+      // now create a dummy intermediate textures from the initial map texture
+      createTextureObject(gl, dynamicTextureIDs[i], initialMap, false);
+    }
+
+    initialMap = null;
+
+    texHeightInput    = staticTextureIDs [CA_TEXTURE_INITIAL_MAP];      // initial height map.
+    texHeightOutput   = dynamicTextureIDs[CA_TEXTURE_HEIGHT_TARGET];    // next height map.
+    
+    texVelocityInput  = dynamicTextureIDs[CA_TEXTURE_VELOCITY_SOURCE];  // initial velocity.
+    texVelocityOutput = dynamicTextureIDs[CA_TEXTURE_VELOCITY_TARGET];  // next velocity.
+  }
+
+  private void createAndWriteUVOffsets(GL gl, int width, int height) {
+    // This sets vertex shader constants used to displace the
+    //  source texture over several additive samples.  This is 
+    //  used to accumulate neighboring texel information that we
+    //  need to run the game - the 8 surrounding texels, and the 
+    //  single source texel which will either spawn or die in the 
+    //  next generation.
+    // Label the texels as follows, for a source texel "e" that
+    //  we want to compute for the next generation:
+    //
+    //          abc
+    //          def
+    //          ghi:
+
+    // first the easy one: no offsets for sampling center
+    //  occupied or unoccupied
+    // Use index offset value 0.0 to access these in the 
+    //  vertex shader.
+    
+    perTexelWidth  = 1.0f / width;
+    perTexelHeight = 1.0f / height;
+
+    // Offset set 0 : center texel sampling
+    float[] noOffsetX = new float[] { 0, 0, 0, 0 };
+    float[] noOffsetY = new float[] { 0, 0, 0, 0 };
+
+    // Offset set 1:  For use with neighbor force pixel shader 1
+    //  samples center with 0, +u, -u, and +v,
+    //  ie the 'e','d', 'f', and 'h' texels
+    float dist = 1.5f;
+    float[] type1OffsetX = new float[] { 0.0f, -dist * perTexelWidth,  dist * perTexelWidth,   dist * perTexelWidth  };
+    float[] type1OffsetY = new float[] { 0.0f,  dist * perTexelHeight, dist * perTexelHeight, -dist * perTexelHeight };
+
+    // Offset set 2:  for use with neighbor force pixel shader 2
+    //  samples center with 0, and -v texels 
+    //  ie the 'e' and 'b' texels
+    // This completes a pattern of sampling center texel and it's
+    //   4 nearest neighbors to run the height-based water simulation
+    // 3rd must be 0 0 to sample texel center from partial result
+    //   texture.
+
+    float[] type2OffsetX = new float[] { 0.0f, -dist * perTexelWidth,  0.0f, 0.0f   };
+    float[] type2OffsetY = new float[] { 0.0f, -dist * perTexelHeight, 0.0f, 0.0f   };
+        
+    // type 3 offsets
+    updateBlurVertOffset(gl);
+
+    /////////////////////////////////////////////////////////////
+    // Nearest neighbor offsets:
+
+    float[] type4OffsetX = new float[] { -perTexelWidth,   perTexelWidth,   0.0f,              0.0f   };
+    float[] type4OffsetY = new float[] { 0.0f,             0.0f,            -perTexelHeight,   perTexelHeight };
+
+    // write all these offsets to constant memory
+    for (int i = 0; i < 4; ++i) {
+      float noOffset[]    = { noOffsetX[i],    noOffsetY[i],    0.0f, 0.0f };
+      float type1Offset[] = { type1OffsetX[i], type1OffsetY[i], 0.0f, 0.0f };
+      float type2Offset[] = { type2OffsetX[i], type2OffsetY[i], 0.0f, 0.0f };
+      float type4Offset[] = { type4OffsetX[i], type4OffsetY[i], 0.0f, 0.0f };
+
+      gl.glProgramParameter4fvNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_T0_NO_OFFSET + 5 * i, noOffset);
+      gl.glProgramParameter4fvNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_T0_TYPE1     + 5 * i, type1Offset);
+      gl.glProgramParameter4fvNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_T0_TYPE2     + 5 * i, type2Offset);
+      gl.glProgramParameter4fvNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_T0_TYPE4     + 5 * i, type4Offset);
+    }
+  }
+
+  private void updateBlurVertOffset(GL gl) {
+    float[] type3OffsetX = new float[] { -perTexelWidth * 0.5f, 
+                                         perTexelWidth, 
+                                         perTexelWidth * 0.5f, 
+                                         -perTexelWidth 
+    };
+    float[] type3OffsetY = new float[] { perTexelHeight,
+                                         perTexelHeight * 0.5f,
+                                         -perTexelHeight,
+                                         -perTexelHeight * 0.5f 
+    };
+    float[] offsets = new float[] { 0, 0, 0, 0 };
+
+    for (int i = 0; i < 4; ++i) {
+      offsets[0] = blurDist * ( type3OffsetX[i]);
+      offsets[1] = blurDist * ( type3OffsetY[i]);
+      gl.glProgramParameter4fvNV(GL.GL_VERTEX_PROGRAM_NV, CV_UV_T0_TYPE3 + 5 * i, offsets);
+    }
+  }
+
+  private synchronized void drawDroplets(GL gl) {
+    gl.glDisable(GL.GL_REGISTER_COMBINERS_NV);
+    gl.glDisable(GL.GL_VERTEX_PROGRAM_NV);
+
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, staticTextureIDs[CA_TEXTURE_DROPLET]);
+    gl.glEnable(GL.GL_TEXTURE_2D);
+
+    gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
+    gl.glDisable(GL.GL_TEXTURE_2D);
+
+    gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE);
+    gl.glEnable(GL.GL_BLEND);
+
+    gl.glBegin(GL.GL_QUADS);
+    gl.glColor4f(1, 1, 1, 1);
+    for (Iterator iter = droplets.iterator(); iter.hasNext(); ) {
+      Droplet droplet = (Droplet) iter.next();
+      // coords in [-1,1] range
+
+      // Draw a single quad to the texture render target
+      // The quad is textured with the initial droplet texture, and
+      //   covers some small portion of the render target
+      // Draw the droplet
+       
+      gl.glTexCoord2f(0, 0); gl.glVertex2f(droplet.rX() - droplet.rScale(), droplet.rY() - droplet.rScale());
+      gl.glTexCoord2f(1, 0); gl.glVertex2f(droplet.rX() + droplet.rScale(), droplet.rY() - droplet.rScale());
+      gl.glTexCoord2f(1, 1); gl.glVertex2f(droplet.rX() + droplet.rScale(), droplet.rY() + droplet.rScale());
+      gl.glTexCoord2f(0, 1); gl.glVertex2f(droplet.rX() - droplet.rScale(), droplet.rY() + droplet.rScale());          
+    }
+    gl.glEnd();
+
+    gl.glDisable(GL.GL_BLEND);
+  }
+
+  //----------------------------------------------------------------------
+  // Inlined register combiner and texture shader programs
+  // (don't want to port nvparse as it's a dead-end; we'll focus on Cg instead)
+
+  private void initEqWeightCombine_PostMult(GL gl) {
+    float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
+    float[] const1 = new float[] { 1.0f, 1.0f, 1.0f, 1.0f };
+
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR0_NV, const0);
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR1_NV, const1);
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 4);
+  
+    int stage = 0;
+    // Stage 0
+    // rgb
+    // {
+    //   discard = half_bias(tex0);
+    //   discard = half_bias(tex1);
+    //   spare0 = sum();
+    //   scale_by_one_half();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_HALF_BIAS_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE1_ARB, GL.GL_HALF_BIAS_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_SCALE_BY_ONE_HALF_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 1
+    // rgb
+    // {
+    //   discard = half_bias(tex2);
+    //   discard = half_bias(tex3);
+    //   spare1 = sum();
+    //   scale_by_one_half();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE2_ARB, GL.GL_HALF_BIAS_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE3_ARB, GL.GL_HALF_BIAS_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE1_NV, GL.GL_SCALE_BY_ONE_HALF_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 1
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 2
+    // rgb
+    // {
+    //   discard = spare0;
+    //   discard = spare1;
+    //   spare0 = sum();
+    //   scale_by_one_half();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_SCALE_BY_ONE_HALF_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 2
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 3
+    // rgb
+    // {
+    //   discard = const0;
+    //   discard = spare0;
+    //   spare0 = sum();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 3
+    // alpha
+    discardAlpha(gl, stage);
+
+    gl.glDisable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+
+    doFinal(gl, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV);
+  }
+
+  private void initNeighborForceCalcStep1(GL gl) {
+    // Step one in the nearest-neighbor force calculation for height-based water
+    // simulation.  NeighborForceCalc2 is the second step.
+    //
+    // This step takes the center point and three neighboring points, and computes
+    // the texel difference as the "force" acting to pull the center texel.
+    // 
+    // The amount to which the computed force is applied to the texel is controlled
+    // in a separate shader.
+
+    //  get colors from all 4 texture stages
+    //  tex0 = center texel
+    //  tex1 = 1st neighbor
+    //  tex2 = 2nd neighbor - same axis as 1st neighbor point
+    //       so force for that axis == t1 - t0 + t2 - t0
+    //  tex3 = 3rd neighbor on other axis
+
+    float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
+
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR0_NV, const0);
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 8);
+
+    int stage = 0;
+    // Stage 0
+    // rgb
+    // {
+    //   //s0 = t1 - t0;
+    //   discard = -tex0;
+    //   discard = tex1;
+    //   spare0 = sum();  
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE1_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 1
+    // rgb
+    // {
+    //   //s1 = t2 - t0;
+    //   discard = -tex0;
+    //   discard = tex2;
+    //   spare1 = sum();  
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE2_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE1_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 1
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 2
+    // // 'force' for 1st axis
+    // rgb 
+    // {
+    //   //s0 = s0 + s1 = t1 - t0 + t2 - t0;
+    //   discard = spare0;
+    //   discard = spare1;
+    //   spare0 = sum();  
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 2
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 3
+    // // one more point for 2nd axis
+    // rgb
+    // {
+    //   //s1 = t3 - t0;
+    //   discard = -tex0;
+    //   discard = tex3;
+    //   spare1 = sum();  
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE3_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE1_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 3
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 4
+    // rgb
+    // {
+    //   //s0 = s0 + s1 = t3 - t0 + t2 - t0 + t1 - t0;
+    //   discard = spare0;
+    //   discard = spare1;
+    //   spare0 = sum();  
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 4
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 5
+    // // Now add in a force to gently pull the center texel's 
+    // //  value to 0.5.  The strength of this is controlled by
+    // //  the PCN_EQ_REST_FAC  - restoration factor
+    // // Without this, the simulation will fade to zero or fly
+    // //  away to saturate at 1.0
+    // rgb 
+    // {
+    //   //s1 = 0.5 - t0;  
+    //   discard = -tex0;
+    //   discard = const0;
+    //   spare1 = sum();  
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE1_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+  
+    // Stage 5
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 6
+    // {
+    //   rgb
+    //   {
+    //     discard = spare1 * const0;
+    //     discard = spare0;
+    //     spare0 = sum();
+    //   }
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 6
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 7
+    // rgb
+    // {
+    //   discard = spare0;
+    //   discard = const0;
+    //   spare0 = sum();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 7
+    // alpha
+    discardAlpha(gl, stage);
+
+    gl.glDisable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+    doFinal(gl, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV);
+  }
+
+  private void initNeighborForceCalcStep2(GL gl) {
+    // 2nd step of force calc for render-to-texture
+    // water simulation.
+    //
+    // Adds the 4th & final neighbor point to the 
+    // force calc..
+    //
+    // Bias and scale the values so 0 force is 0.5, 
+    // full negative force is 0.0, and full pos is
+    // 1.0
+    //
+    // tex0    Center texel
+    // tex1    2nd axis neighbor point
+    // tex2    previous partial force amount
+    // Result from t1 - t0 is added to this t2
+    //  partial result & output
+
+    float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
+
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR0_NV, const0);
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 2);
+
+    int stage = 0;
+    // Stage 0
+    // last element of neighbor force
+    // rgb
+    // {
+    //   discard = -tex0;
+    //   discard = tex1;
+    //   spare0 = sum();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE0_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE1_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 1
+    // add with previous partial force amount
+    // rgb
+    // {
+    //   discard = spare0;
+    //   discard = tex2;
+    //   spare0 = sum();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE2_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 1
+    // alpha
+    discardAlpha(gl, stage);
+
+    gl.glDisable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+    doFinal(gl, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV);
+  }
+
+  private void initApplyForce(GL gl) {
+    // This shader samples t1, biases its value to a signed number, and applies this
+    // value multiplied by a scale factor to the t0 sample.
+    //
+    // This is used to apply a "force" texture value to a "velocity" state texture
+    // for nearest-neighbor height-based water simulations.  The output pixel is
+    // the new "velocity" value to replace the t0 sample in rendering to a new 
+    // texture which will replace the texture selected into t0.
+    //
+    // A nearly identical shader using a different scaling constant is used to
+    // apply the "velocity" value to a "height" texture at each texel.
+    //
+    // t1 comes in the range [0,1] but needs to hold signed values, so a value of
+    // 0.5 in t1 represents zero force.  This is biased to a signed value in 
+    // computing the new velocity.
+    //
+    // tex0 = previous velocity
+    // tex1 = force
+    //
+    // Bias the force so that 0.5 input = no change in t0 value
+    //  and 0.0 input means -0.5 * scale change in t0 value
+    //
+    // New velocity = force * scale + previous velocity
+
+    float[] const0 = new float[] { 0.25f, 0.25f, 0.25f, 1.0f };
+    float[] const1 = new float[] { 0.5f,  0.5f,  0.5f,  1.0f };
+
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR0_NV, const0);
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR1_NV, const1);
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 4);
+  
+    int stage = 0;
+    // Stage 0
+    // rgb
+    // {
+    //   discard = expand(tex1) * const0;
+    //   discard = expand(tex0);
+    //   spare0 = sum();
+    //   scale_by_one_half();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE1_ARB, GL.GL_EXPAND_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE0_ARB, GL.GL_EXPAND_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_SCALE_BY_ONE_HALF_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 1
+    // rgb
+    // {
+    //   discard = spare0;
+    //   discard = const1;
+    //   spare0 = sum();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_CONSTANT_COLOR1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 1
+    // alpha
+    discardAlpha(gl, stage);
+
+    gl.glDisable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+    doFinal(gl, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_UNSIGNED_IDENTITY_NV);
+  }
+
+  private void initApplyVelocity(GL gl) {
+    // This shader samples t1, biases its value to a signed number, and applies this
+    // value multiplied by a scale factor to the t0 sample.
+    //
+    // This is used to apply a "velocity" texture value to a "height" state texture
+    // for nearest-neighbor height-based water simulations.  The output pixel is
+    // the new "height" value to replace the t0 sample in rendering to a new 
+    // texture which will replace the texture selected into t0.
+    //
+    // A nearly identical shader using a different scaling constant is used to
+    // apply the "force" value to the "velocity" texture at each texel.
+    //
+    // t1 comes in the range [0,1] but needs to hold signed values, so a value of
+    // 0.5 in t1 represents zero velocity.  This is biased to a signed value in 
+    // computing the new position.                       
+    //
+    // tex0 = height field
+    // tex1 = velocity          
+    //
+    // Bias the force/velocity to a signed value so we can subtract from
+    //   the t0 position sample.
+    //
+    // New height = velocity * scale factor + old height
+
+    float[] const0 = new float[] { 0.5f, 0.5f, 0.5f, 1.0f };
+
+    gl.glCombinerParameterfvNV(GL.GL_CONSTANT_COLOR0_NV, const0);
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 2);
+  
+    int stage = 0;
+    // Stage 0
+    // rgb
+    // {
+    //   discard = expand(tex1) * const0;
+    //   discard = expand(tex0);
+    //   spare0 = sum();
+    //   scale_by_one_half();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE1_ARB, GL.GL_EXPAND_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE0_ARB, GL.GL_EXPAND_NORMAL_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_SCALE_BY_ONE_HALF_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 1
+    // rgb
+    // {
+    //   discard = spare0;
+    //   discard = const0;
+    //   spare0 = sum();
+    // }
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 1
+    // alpha
+    discardAlpha(gl, stage);
+
+    gl.glDisable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+    doFinal(gl, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_UNSIGNED_IDENTITY_NV);
+  }
+
+  private void initCreateNormalMap(GL gl) {
+    // Neighbor-differencing for RGB normal map creation.  Scale factors for s and t
+    // axis components are set in program code.
+    // This does a crude 1-s^2-t^2 calculation for the blue component in order to
+    // approximately normalize the RGB normal map vector.  For s^2+t^2 close to 1.0,
+    // this is a close approximation to blue = sqrt(1 - s^2 - t^2) which would give a
+    // normalized vector.
+    // An additional pass with a dependent texture lookup (alpha-red or green-blue)
+    // could be used to produce an exactly normalized normal.
+
+    // colors from all 4 texture stages
+    // tex0 = -s,  0
+    // tex1 = +s,  0
+    // tex2 =  0, +t
+    // tex3 =  0, -t
+
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 7);
+  
+    int stage = 0;
+    // Stage 0
+    // rgb
+    // {
+    //   // (t0 - t1)*4  : 4 for higher scale
+    //   discard = -tex1;
+    //   discard = tex0;
+    //   spare0 = sum();
+    //   scale_by_four();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE1_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE0_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_SCALE_BY_FOUR_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 1
+    // rgb
+    // {
+    //   // (t3 - t2)*4 : 4 for higher scale
+    //   discard = -tex2;
+    //   discard = tex3;
+    //   spare1 = sum();
+    //   scale_by_four();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE2_ARB, GL.GL_SIGNED_NEGATE_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_TEXTURE3_ARB, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE1_NV, GL.GL_SCALE_BY_FOUR_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 1
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 2
+    // Define const0 in the third general combiner as RGBA = (scale, 0, 0, 0)
+    //  Where scale [0,1] is applied to reduce the magnitude
+    //  of the s axis component of the normal.
+    // Define const1 in the third combiner similarly to affect the t axis component
+    // define these by "ramboing" them in the C++ code that uses this combiner script.
+    //
+    // rgb
+    // {
+    //   // see comment about consts above!
+    //   // t0 = s result in red only
+    //   discard = spare0 * const0;
+    //   discard = spare1 * const1;
+    //   spare0 = sum();
+    // }
+    //
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_CONSTANT_COLOR1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 2
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 3
+    // rgb
+    // {
+    //   tex1 = spare0 * spare0;
+    //   scale_by_two();
+    // }
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_TEXTURE1_ARB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SCALE_BY_TWO_NV, GL.GL_NONE, false, false, false);
+
+    // Stage 3
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 4
+    //
+    // const0 = (1, 1, 0, 0);
+    // rgb
+    // {
+    //   spare1 = unsigned_invert(tex1) . const0;
+    //   scale_by_one_half();
+    // }
+    //
+    float[] const0 = new float[] { 1.0f, 1.0f, 0.0f, 0.0f };
+
+    gl.glCombinerStageParameterfvNV(GL.GL_COMBINER0_NV + stage, GL.GL_CONSTANT_COLOR0_NV, const0);
+
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_TEXTURE1_ARB, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_SPARE1_NV, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SCALE_BY_ONE_HALF_NV, GL.GL_NONE, true, false, false);
+
+    // Stage 4
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 5
+    //
+    // const0 = (0.5, 0.5, 0, 0);
+    // rgb
+    // {
+    //   discard = spare0;
+    //   discard = const0;
+    //   spare0 = sum();
+    // }
+    //
+    const0 = new float[] { 0.5f, 0.5f, 0.0f, 0.0f };
+
+    gl.glCombinerStageParameterfvNV(GL.GL_COMBINER0_NV + stage, GL.GL_CONSTANT_COLOR0_NV, const0);
+
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 5
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    // Stage 6
+    //
+    //
+    // const0 = (0, 0, 1, 1);
+    // rgb 
+    // {
+    //   discard = spare1 * const0;
+    //   discard = spare0;
+    //   spare0 = sum();
+    // }
+    //
+    const0 = new float[] { 0.0f, 0.0f, 1.0f, 1.0f };
+
+    gl.glCombinerStageParameterfvNV(GL.GL_COMBINER0_NV + stage, GL.GL_CONSTANT_COLOR0_NV, const0);
+
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_SPARE1_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_CONSTANT_COLOR0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_SPARE0_NV, GL.GL_SIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_SPARE0_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 6
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    gl.glEnable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+    doFinal(gl, GL.GL_SPARE0_NV, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_ZERO, GL.GL_UNSIGNED_INVERT_NV);
+  }
+
+  private void initDotProductReflect(GL gl) {
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_SHADER_OPERATION_NV, GL.GL_TEXTURE_2D);
+
+    // 1 of 3
+    gl.glActiveTextureARB(GL.GL_TEXTURE1_ARB);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL.GL_EXPAND_NORMAL_NV);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_SHADER_OPERATION_NV, GL.GL_DOT_PRODUCT_NV);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_PREVIOUS_TEXTURE_INPUT_NV, GL.GL_TEXTURE0_ARB);
+
+    // 2 of 3
+    gl.glActiveTextureARB(GL.GL_TEXTURE2_ARB);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL.GL_EXPAND_NORMAL_NV);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_SHADER_OPERATION_NV, GL.GL_DOT_PRODUCT_NV);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_PREVIOUS_TEXTURE_INPUT_NV, GL.GL_TEXTURE0_ARB);
+
+    // 3 of 3
+    gl.glActiveTextureARB(GL.GL_TEXTURE3_ARB);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV, GL.GL_EXPAND_NORMAL_NV);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_SHADER_OPERATION_NV, GL.GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV);
+    gl.glTexEnvi(GL.GL_TEXTURE_SHADER_NV, GL.GL_PREVIOUS_TEXTURE_INPUT_NV, GL.GL_TEXTURE0_ARB);
+
+    gl.glActiveTextureARB(GL.GL_TEXTURE0_ARB);
+    gl.glCombinerParameteriNV(GL.GL_NUM_GENERAL_COMBINERS_NV, 1);
+  
+    int stage = 0;
+    // Stage 0
+    // rgb
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_A_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_C_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doIn(gl, stage, GL.GL_RGB, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_RGB);
+    doOut(gl, stage, GL.GL_RGB, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+
+    // Stage 0
+    // alpha
+    discardAlpha(gl, stage);
+
+    ++stage;
+
+    gl.glDisable(GL.GL_PER_STAGE_CONSTANTS_NV);
+    gl.glCombinerParameteriNV(GL.GL_COLOR_SUM_CLAMP_NV, GL.GL_FALSE);
+    doFinal(gl, GL.GL_TEXTURE3_ARB, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV);
+  }
+
+  private void discardAlpha(GL gl, int stage) {
+    doIn(gl, stage, GL.GL_ALPHA, GL.GL_VARIABLE_A_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_BLUE);
+    doIn(gl, stage, GL.GL_ALPHA, GL.GL_VARIABLE_B_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_BLUE);
+    doIn(gl, stage, GL.GL_ALPHA, GL.GL_VARIABLE_C_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_BLUE);
+    doIn(gl, stage, GL.GL_ALPHA, GL.GL_VARIABLE_D_NV, GL.GL_ZERO, GL.GL_UNSIGNED_IDENTITY_NV, GL.GL_BLUE);
+    doOut(gl, stage, GL.GL_ALPHA, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_DISCARD_NV, GL.GL_NONE, GL.GL_NONE, false, false, false);
+  }
+
+  private void doIn(GL gl,
+                    int stage,
+                    int colorSpace,
+                    int variable,
+                    int reg,
+                    int operation,
+                    int colorSelector) {
+    gl.glCombinerInputNV(GL.GL_COMBINER0_NV + stage,
+                         colorSpace,
+                         variable,
+                         reg,
+                         operation,
+                         colorSelector);
+  }
+
+  private void doOut(GL gl,
+                     int stage,
+                     int colorSpace,
+                     int in0,
+                     int in1,
+                     int out0,
+                     int scale,
+                     int bias,
+                     boolean unknown0,
+                     boolean unknown1,
+                     boolean unknown2) {
+    gl.glCombinerOutputNV(GL.GL_COMBINER0_NV + stage,
+                          colorSpace,
+                          in0,
+                          in1,
+                          out0,
+                          scale,
+                          bias,
+                          unknown0,
+                          unknown1,
+                          unknown2);
+  }
+
+  private void doFinal(GL gl,
+                       int variableDInput,
+                       int variableDOperation,
+                       int variableGInput,
+                       int variableGOperation) {
+    gl.glFinalCombinerInputNV(GL.GL_VARIABLE_A_NV,
+                              GL.GL_ZERO,
+                              GL.GL_UNSIGNED_IDENTITY_NV,
+                              GL.GL_RGB);
+
+    gl.glFinalCombinerInputNV(GL.GL_VARIABLE_B_NV,
+                              GL.GL_ZERO,
+                              GL.GL_UNSIGNED_IDENTITY_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,
+                              variableDInput,
+                              variableDOperation,
+                              GL.GL_RGB);
+
+    gl.glFinalCombinerInputNV(GL.GL_VARIABLE_E_NV,
+                              GL.GL_ZERO,
+                              GL.GL_UNSIGNED_IDENTITY_NV,
+                              GL.GL_RGB);
+
+    gl.glFinalCombinerInputNV(GL.GL_VARIABLE_F_NV,
+                              GL.GL_ZERO,
+                              GL.GL_UNSIGNED_IDENTITY_NV,
+                              GL.GL_RGB);
+
+    gl.glFinalCombinerInputNV(GL.GL_VARIABLE_G_NV,
+                              variableGInput,
+                              variableGOperation,
+                              GL.GL_ALPHA);
+  }
+}